What is agent memory?
Agent memory is the layer that lets an AI agent keep what it learned from one session into the next. Without it an agent starts from zero every time: it asks the same questions, fetches the same data, and works out the same decisions again. With it, yesterday's work is available today.
Below: what an agent actually needs to remember, why a vector store is not the same thing, and what it costs to run.
Why does an agent forget?
An agent forgets because the context window is the only memory it has, and that window is emptied at the end of every session. Everything the agent worked out lives in that window: who the customer is, which approach already failed, what the plan was. When the session ends, or when the window fills up and gets compacted, it is gone.
This is not a bug in any particular model. It is how the architecture works. A model has weights, which change only during training, and a context window, which is temporary by design. Anything in between has to be built.
What does an agent need to remember?
Not everything. A memory that stores every message is a transcript, and a transcript is close to useless: it is long, repetitive, and buries what matters. What an agent needs back is the small set of durable things.
- Identities and IDs: who this person is, which account, which ticket, which repository.
- Decisions and their reasons: what was chosen, and what was ruled out, so it is not re-litigated.
- Preferences and rules: how this user wants things done, what is off limits.
- Failures: what already went wrong, so the same wall is not walked into twice.
- Open loops: what was left unfinished, so someone picks it up instead of dropping it.
How is agent memory different from a vector database?
A vector database stores and searches. Agent memory curates. That difference sounds small and decides everything about how the system behaves after a few months of real use.
A vector store treats every chunk as equally valid forever. It grows, and as it grows the noise grows with it: contradictions sit next to each other, outdated facts rank as highly as current ones, and retrieval gets worse the more you put in. A memory instead consolidates, connects, matures what proves true and lets the rest fade, so it gets sharper as it grows.
| Vector database | Agent memory | |
|---|---|---|
| What it does with new data | Stores it as another chunk | Merges it with what is already known |
| Contradictions | Both versions stay and compete | Surfaced and quarantined until resolved |
| Old, unused knowledge | Ranks forever | Decays and eventually goes |
| Retrieval | Nearest neighbour by similarity | Association: related knowledge and past warnings come back together |
| Over time | Noisier | Sharper |
How does memory consolidation work?
The same way it works in a brain: not while things are happening, but in the quiet afterwards. During the day the agent writes down experiences raw and unsorted, because sorting mid-task costs time and judgement the agent does not have yet. At night a separate model reads the day back.
That model merges duplicates, clusters what belongs together, abstracts details into durable knowledge, links it into the existing graph, and marks what contradicts something already trusted. The agent never curates its own memory, which matters: an agent editing its own past is how a memory quietly poisons itself.
In the morning the agent connects and gets a briefing of what changed while it was idle.
What does agent memory cost to run?
Two different costs, and they behave differently. Reading and writing scale with usage, so they belong in a per-call price. Consolidation happens whether or not anyone calls, so it belongs in something recurring.
Tulimoa Memory prices it that way: $0.002 per call, fixed, and no recurring fee at all until a memory holds 5,000 things. From there a daily fee from $0.03 pays for the nightly consolidation. Only what is kept durably counts toward the size, and forgetting shrinks it, so what you pay for is the knowledge you keep. Create your first memory in the Tulimoa dashboard and you start with $1 of credit, enough for 500 calls.
Does agent memory reduce token cost?
It should, for a simple reason: an agent that knows something does not have to be told it again. Re-sent context, repeated tool calls and re-derived conclusions are all tokens, and all of them are avoidable when the answer is already in memory.
We have not published a solid number for this yet, so we do not quote one. Any percentage you see advertised without a published method behind it was chosen by a marketing team, not by an experiment.
Questions people ask
Is agent memory the same as RAG?
No. RAG retrieves from documents you already have, which is a way of reading. Memory is written by the agent from its own experience, which is a way of remembering. They compose well: RAG tells an agent what the manual says, memory tells it what happened last Tuesday.
Can I just use a bigger context window?
Only up to a point, and it gets expensive fast. A bigger window costs more per call for every call, holds only one session, and still empties at the end. Memory is cheaper per unit of remembering and survives the session, which is the part that matters.
Who decides what gets remembered?
In a good design, not the agent alone. The agent records experiences, and a separate consolidation step decides what becomes durable knowledge. Letting an agent curate its own memory invites drift: it keeps what fits its current story and quietly loses the rest.
What about personal data in an agent's memory?
Treat it as the hardest part, because it is. Tulimoa Memory replaces email addresses, phone numbers and IBANs with placeholders before anything is stored, and names once they are known: when the agent tags them as a person or the nightly check finds them. The plaintext sits in an encrypted vault. Erasure works by destroying the key, which makes that person unreadable everywhere at once.
Can an agent set up its own memory without a human?
With Tulimoa Memory, yes. The agent answers an HTTP 402 payment challenge with a signed USDC payment and gets its API key back in the response. No email address, no forms, no account.
And how do I start as a person?
In claude.ai or ChatGPT you add the address as a connector and sign in. For every other client, in the Tulimoa dashboard: you create a memory with one click and get $1 of starting credit plus a key that any MCP client connects with. That is also where you see what your agent knows, settle contradictions and top up by card.
Give your agent a past it can build on.
Tulimoa Memory is live: $0.002 per call, $1 of starting credit on us, database in Frankfurt, and no recurring fee until your agent knows 5,000 things.