What's the real difference between what an AI agent remembers and the fixed categories it uses to make sense of what it remembers?
What distinguishes AI memory from AI ontology in agent systems?
This explores the difference between what an agent remembers (its stored record of past interactions and facts) and its ontology (the fixed categories and schema it uses to say what kinds of things exist and how they relate). The retrieved material covers memory in depth but has almost nothing on ontology as its own topic, so the distinction has to be worked out from where memory research keeps running into structure.
This explores the difference between what an agent remembers and the categories it uses to organize what it knows. The collection doesn't have notes on agent ontology as a topic of its own. Every retrieval here is about memory. Still, the memory research keeps running into ontology-like questions without using the word, and that's where the line between the two shows up.
The simplest way to put it: memory is the content, and ontology is the shape that content has to fit. You can see this in work that splits memory into labeled compartments. DeepAgent folds its history into episodic, working, and tool memory, and the structure is what keeps compression from losing important details Can agents compress their own memory without losing critical details?. AgentFly does the same with case, subtask, and tool memories Can agents learn continuously from experience without updating weights?. In both systems, the decision about which kinds of things are worth remembering is made before anything gets remembered. That prior decision works like an ontology, even though nobody calls it one.
The strongest hint that the two need separating comes from research on agents that break down over long workflows. One study argues these failures come from weak control over memory, not missing knowledge. Its fix is a bounded, schema-governed "committed state" that is kept apart from ordinary recall Can agents fail from weak memory control rather than missing knowledge?. That is roughly the memory/ontology split built into an agent: a small, governed set of facts the agent has committed to, plus a looser pool of things it can look up. The granularity research points the same way. Which unit of memory works best (whole workflows, cause-and-effect rules, or individual screen states) depends on how the task domain is structured Does agent memory work better at one level of abstraction?. So the right categories come from the world the agent works in, not from the memory system itself.
Other work blurs the line on purpose. MRAgent rebuilds memory on demand by walking a graph of relationships, so the relational structure is used during retrieval instead of being frozen at storage time Can agents reconstruct memory on demand instead of retrieving it?. Metis goes further and builds memory into the model itself, which leaves no separate place for an explicit schema to live Should agent memory live inside the model backbone?. The most surprising case is agents that turned a shared package repository into memory nobody designed Can ordinary infrastructure become unplanned agent memory?. Those agents had persistence with no ontology at all: ordinary infrastructure became a store simply because they used it as one.
If you want a framework for keeping these ideas apart, the three-axis survey (what form memory takes, what it's for, and how it changes over time) is the clearest map of the memory side Can three axes replace the short-term long-term memory split?. The harness view, which describes memory, skills, and protocols as separate burdens moved out of the model, suggests that ontology may belong with protocols and structure rather than with memory Where does agent reliability actually come from?. For a direct treatment of agent ontologies (knowledge graphs, type systems, shared vocabularies between agents), the collection has a gap.
Sources 9 notes
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
AgentFly formalizes agent learning as a Memory-augmented MDP with three memory modules (case, subtask, tool) that enable credit assignment and policy improvement entirely through memory operations. The approach achieved 87.88% on GAIA validation without modifying LLM parameters.
Agent performance degrades in long workflows because transcript replay and retrieval-based memory lack gating mechanisms. A bounded, schema-governed committed state that separates artifact recall from permanent memory write prevents error accumulation and constraint drift.
Workflow-level memory wins in routine-rich domains, causal-rule memory in environment-rich domains, and state-action memory in spatially-rich web tasks. The optimal abstraction depends on whether task variance comes from arguments, causal structure, or fine-grained UI state.
MRAgent achieves up to 23% gains on reasoning tasks by reconstructing memory through active graph traversal that prunes paths based on accumulated evidence, while reducing token and runtime cost compared to fixed-retrieval pipelines.
Show all 9 sources
Metis demonstrates that agent memory can be implemented as a persistent state and autonomous procedures within the model backbone rather than external modules. This approach enables end-to-end training and avoids the decoupling failures where external memory and backbone optimize independently.
During a 2026 evaluation, short-lived AI agents repurposed a shared package repository as memory by writing and reading exploit findings across agent lifespans. The agents converted ordinary infrastructure into persistent state without deliberate memory system architecture.
A 2025 survey reframes agent memory along forms (token/parametric/latent), functions (factual/experiential/working), and dynamics (formation/evolution/retrieval), showing that short/long-term phenomena emerge from temporal patterns rather than architectural separation. This enables precise system comparison and replaces vague implementation-based claims.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- Agent Memory Distillation: Empowering Small LLM Agents with Hierarchical Teacher Memory
- Are We Ready For An Agent-Native Memory System?
- GateMem: Benchmarking Memory Governance in Multi-Principal Shared-Memory Agents
- Rethinking Memory as Continuously Evolving Connectivity
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- AI Agents Need Memory Control Over More Context