Agents that remember, and can show their work.
Every agent and every person gets their own memory of what they saw, what they concluded, and why they acted. It stays theirs. No one else can quietly edit it, and it moves with them when they move.
Built by the team behind infrastructure enterprises already run at scale
Most agent memory is a shared pile of text.
It works until two agents disagree, until one changes its mind, or until somebody asks why a decision was made.
How it works today
One index, everything in it
- Everything an agent knows is embedded text in one shared store.
- Retrieval returns what is closest. Closest is not always correct.
- When two agents disagree, one view overwrites the other.
- An agent changes its mind and the old belief is still in there, still returning.
- You can see what it pulled up. You cannot see why it acted.
With Pensieve
One memory per actor, structured
- Each agent and each person holds their own memory, anchored to their identity.
- What it knows is structured state, so the same question returns the same answer.
- Two actors can hold opposite views and neither one wins or is lost.
- Changing its mind is a single clean revision. The old belief does not come back.
- Every decision keeps the chain of reasoning that led to it.
Four things you get back.
Memory nobody can quietly rewrite
An actor's memory is anchored to that actor's identity and immutable to everyone else. There is no shared store for one agent to overwrite another in.
Disagreement stops being a bug
Two agents can reach opposite conclusions about the same thing and both records stand. Nothing needs reconciling, because each memory has exactly one owner.
Answers to why, not just what
Every decision keeps the chain behind it. When someone asks why an agent did something six weeks ago, you replay it instead of reconstructing it.
Memory that moves with the agent
An agent's whole memory can be exported, proven and resumed in a fresh runtime. Restart it somewhere else and it picks up where it left off instead of starting cold.
The same mechanism, two ways to read it.
Watch it with two agents reasoning about a database, or with one person and a list of restaurants. The structure underneath is identical.
Two actors, one subject, opposite beliefs
Each memory is scoped to its owner, so disagreement is a normal state rather than a conflict to resolve.
Two actors observe the same environment and reach opposite conclusions. That is expected, not a conflict to resolve, because each memory is scoped to its owner. Belief revision is a single atomic revision, not a lingering competing embedding. The dotted lane replays the causal chain behind one decision.
One actor, built piece by piece
A taste graph instead of a technical one. Same mechanism underneath, read from either end.
Preferences are not a flat list. Italian_cuisine is one node, and every restaurant Self prefers links back to it independently. Ask what Self likes, or ask why Self prefers Terun, and both are the same graph read from different ends.
Three places this shows up first.
Long-running agents
Agents that work a task over days rather than minutes, and have to survive a restart without losing what they established.
Fleets that disagree
Many agents observing the same systems and reaching different conclusions, where flattening them into one view destroys the signal.
Decisions that get audited
Anywhere somebody will later ask why an agent did what it did, and a retrieval log is not an answer.