# What do you need your agents to remember?

Remembering a customer’s preferences is one job. Keeping a team’s decisions, reasons and corrections available across its work is another. Here is how Korium, Mem0, Zep, Letta and Cognee approach the work.

## On this page

## Compare the job, not just the word “memory.”

All five products can retain information for later use. The useful comparison is how they represent it, keep changes understandable and get the right information into the next task.

**Korium** Company decisions and learning **Mem0** Memory added to an application **Zep / Graphiti** Facts and relationships over time **Letta** Agents with persistent state **Cognee** Connected memory from source material

For Korium, the job is to keep the decisions and learning a company needs people and agents to act on. That includes the reason, the source, what replaced an earlier decision and, when software is involved, where the relevant code lives.

This is our assessment of the fit, not a benchmark or a claim that the alternatives cannot store decisions. The descriptions below are grounded in the linked product documentation, reviewed September 5, 2026.

## The head-to-head comparison.

| Question | Korium | Mem0 | Zep / Graphiti | Letta | Cognee |
| --- | --- | --- | --- | --- | --- |
| What is kept? | Typed decisions, lessons, corrections and handoffs, with sources and relationships. | Memories extracted from messages, including facts, decisions and preferences; raw saves are also supported. | Episodes, entities and relationships with temporal information. | Agent-owned memory. The current Agent SDK uses files in a memory repository. | Source records, chunks, provenance, embeddings and a graph of entities and relationships. |
| What happens when information changes? | Keep a new correction and a supersedes link. Inspect current guidance separately from history. | The current add pipeline is additive, not a blanket overwrite. Expiry can hide records from ordinary search. | Temporal metadata and fact invalidation preserve changes in relationships over time. | Agents edit memory files; the current memory model is Git-backed. | Processing and improvement pipelines update the memory built from sources. Test the correction history you need. |
| How does the agent find it? | Keyword + vector search, rank fusion, importance and use-based activation. Connected recall returns the count, clarification or passage the question calls for. | Semantic search, logical filters and optional reranking. | Hybrid retrieval combining semantic, keyword and graph approaches, with temporal information. | System memory stays in context. The agent sees other memory files and reads them on demand. | Semantic, graph and hybrid retrieval over the configured stores. |
| How is memory shared across agents? | Authorized clients use the same workspace. Captures distinguish the recording agent from the decision-maker. | Application, user, agent and session identifiers organize the memory your application accesses. | Your application uses the relevant graphs and their source episodes; Zep adds a managed service. | The Agent SDK supports shared repositories attached to Cloud agents. Shared memory is not exclusive to Korium. | User and dataset permissions govern access; source provenance is retained in the relational store. |
| What are you adopting? | A shared memory service used from connected assistants; the Mac CLI adds the separate code map. | A managed memory API or the open-source SDK in your own environment. | Zep’s managed service or the open-source Graphiti framework. They are not the same deployment. | An agent and session model with its memory tools. Match the instructions to your SDK generation. | Configurable memory pipelines with relational, vector and graph stores; local defaults can be replaced. |
| What should your trial prove? | A second assistant uses a sourced decision in its plan, then finds and applies a correction. | Your application retrieves the right user or task context, without mixing identities or returning stale guidance. | A changed fact is retrieved with the correct time and source for your question. | The agent’s state survives the tasks and handoffs you need, with the intended sharing boundary. | Your source material becomes a useful, inspectable graph and the returned answer remains traceable. |

Sources for the columns: [Korium behavior](docs/korium/how-memory-works.html); [Mem0 saves](https://docs.mem0.ai/core-concepts/memory-operations/add) and [search](https://docs.mem0.ai/core-concepts/memory-operations/search); [Zep / Graphiti](https://help.getzep.com/graphiti/getting-started/overview); [Letta memory](https://docs.letta.com/agent-sdk/memory) and [sharing](https://docs.letta.com/agent-sdk/repositories); [Cognee architecture](https://docs.cognee.ai/core-concepts/architecture) and [access controls](https://docs.cognee.ai/setup-configuration/security).

A storage model is not proof of a correct answer. The last row describes tests we would run, not results we measured. Hosted products, open-source editions and older SDKs can have different behavior.

## Korium: keep the reason available to the next person or agent.

Where it fits

### Your team keeps explaining the same decisions.

A new colleague or assistant needs to know what failed, what you decided and why a check exists. Korium records that knowledge as decisions, lessons, corrections and handoffs, and connected assistants can retrieve it from the shared workspace.

The code map, skills and workflows belong in that same task. Memory explains the rule, code search locates its implementation, a skill supplies the method and the workflow carries the work through review and handoff.

What to verify

### Does the knowledge change the next plan?

Ask a different connected assistant to prepare the work, with no pasted explanation from the original conversation. Check that it uses the right source and applies the correction when the rule changes.

Follow that task through the code change, review and handoff, then save the result. The value is that the next person can use what this work taught the team.

[See the complete mechanism →](korium-how.html)

## Mem0: add reusable context to an application.

Why you would look at it

### You are building an application that should remember its users.

Mem0 takes messages, extracts useful memories and lets the application retrieve them with identifiers and filters. It offers a managed API and an open-source SDK.

Its add pipeline keeps new memories as additions, including decisions as well as facts and preferences. Search uses meaning, filters and optional reranking to return the context the application needs. [Read how Mem0 saves memory](https://docs.mem0.ai/core-concepts/memory-operations/add).

The distinction to test

### User context, or a company’s decision trail?

Choose the shape that fits your work. For shared operational knowledge, test how you will record who decided, retain the reason and distinguish the replacement from the old rule.

Korium gives those decisions, corrections and handoffs explicit types and links, alongside its code, skill and workflow capabilities. Compare that complete task with the memory behavior you would build into your application.

## Zep: take the temporal comparison seriously.

Why you would look at it

### Your question depends on what was true at a particular time.

Graphiti builds graphs of entities and relationships from source episodes. Its temporal model tracks changing facts, and retrieval combines semantic, keyword and graph approaches.

Zep is the managed service built on that foundation; Graphiti is the open-source framework. The distinction affects what you operate yourself. [Read the Zep / Graphiti overview](https://help.getzep.com/graphiti/getting-started/overview).

The distinction to test

### The fact changed. Can you also recover the decision behind it?

If temporal facts and relationships are the main job, Zep is a direct candidate. If the job is carrying a team’s reasoning through work, compare how each setup preserves decisions, rejected alternatives, corrections and responsibility.

Korium’s typed memories and code map make that a concrete evaluation. They do not make temporal history unique to Korium.

## Letta: build an agent that keeps its state.

Why you would look at it

### You are choosing how the agent itself lives and learns.

The current Letta Agent SDK gives agents persistent memory in Git-backed files. System memory remains in context; other files are read when needed, and dreaming can review conversations and update memory in the background.

It also supports shared memory repositories for Cloud agents, so several agents can work with the same persistent material. [Read the current memory model](https://docs.letta.com/agent-sdk/memory) and [shared repository support](https://docs.letta.com/agent-sdk/repositories).

The distinction to test

### Persistent agent state, or a service used by your existing assistants?

Letta is a candidate when you want its agent model and memory workflow. Korium is a candidate when people already work through different connected assistants and need shared, source-backed company decisions available to those tasks.

Test the handoff using the clients you actually intend to keep. Do not mix instructions for Letta’s older memory-block API with its current Agent SDK.

## Cognee: turn source material into connected memory.

Why you would look at it

### You need to ingest material, preserve its source and explore its connections.

Cognee combines relational storage for records and provenance, vectors for meaning search, and graph storage for entities and relationships. Its architecture includes ingestion, session learning and improvement pipelines.

User and dataset permissions govern access to the stored material. Its storage components can be configured for the environment you operate. [Read the architecture](https://docs.cognee.ai/core-concepts/architecture) and [security configuration](https://docs.cognee.ai/setup-configuration/security).

The distinction to test

### Useful connections are only the beginning of the decision.

Test the source trail, the correction path and what the next agent does with the result. For Korium, that means an explicit decision or lesson feeding a task, with a correction and outcome saved afterward.

If configuring the ingestion and graph pipelines is central to your project, include Cognee in the evaluation. If carrying company decisions through existing work is central, compare that whole workflow with Korium.

## The claims we would make every supplier prove.

A comparison helps you choose what to try. Use a task from your own work to check the behavior, and use the supplier’s security and contract documents to check the commitments.

### Code-aware memory

Korium has a separate commit-linked symbol index. Ask any supplier to show the supported languages, what leaves the machine, how results identify the indexed commit and what happens when code moves.

### Corrections, history and conflict handling

Save a decision, change it and ask for both current guidance and history. Inspect the actual replacement link and source; do not accept a persuasive explanation with no traceable record.

### Self-improvement

Saving learning or updating an agent’s memory does not prove that a system safely improves its own behavior. Ask what changes, what is measured, who approves it and how a bad change is reversed.

### Deployment and tenant isolation

A local SDK, an open-source framework and a managed multi-tenant service are different commitments. Korium’s database enforces tenant separation, but a memory scope is not a private compartment within a team; confirm the boundaries your installation needs.

### Security and procurement

Ask for the current audit report, contract, data location, subprocessors and deletion terms that cover the service you would buy. Start with our [published security information](legal/security.html).

## And the memory already inside Claude / OpenAI / Gemini?

That is a separate comparison. Their platform memory stays within their products by design; it is not automatically shared company memory for another platform.

Korium gives authorized connected assistants a common place to save and retrieve knowledge. It does not copy private conversations or install a connector for every tool in the diagram. We have also tested OpenClaw; check each client’s supported connection and permissions.

[Read the platform-memory questions →](korium-qa.html#memory)

## Start with the mistake you do not want to repeat.

Use one real, permitted example: a failed approach, the decision that followed and a later correction. Give each system the same material and ask a second agent to make the next plan.

Can it find the source, apply the current decision and explain the change without you teaching it again? That tells you more than a table full of ticks.

[Sign up for Korium →](https://app.kyroco.ai/pricing.md) [Already have an account? Try your first memory →](docs/korium/getting-started.html) [Talk through the work you need help with →](mailto:robert@kyroco.ai)