Most AI memory just accumulates. A notes file, a vector store, a chat log — they get bigger, not smarter, and eventually they rot. The signal you actually care about ends up buried under everything you wrote down and never used again.
We built Parametric Memory to do the opposite: capture value once, then compound it. The graph doesn't just grow — it sharpens.
Accumulation rots. Compounding sharpens.
A vector store retrieves. You add embeddings, the index grows, and every query competes against more neighbours than it did last week. Nothing in that loop learns how you work. The hundredth note is as undifferentiated as the first.
Compounding is different. It means the marginal cost of capturing a signal is one cheap write, but its value contributes to every future inference — and the system gets better at using it precisely because you use it. That requires the memory to model not just what you stored, but the paths between the things you stored.
The mechanism: atoms, arcs, and a half-life
Every fact your agent stores is an atom in a SHA-256 Merkle tree. The compounding comes from what sits between atoms.
Every time the agent moves from one atom to the next, the substrate records that transition and strengthens the arc. We model this as a variable-order Markov chain: each memory_train pass adds weight to the arcs that actually fire, and unused arcs decay on a half-life — Half-Life Regression, with a default 7-day half-life. So the paths you travel get heavier, and the paths you don't fade out.
// Reinforce the route you actually took this session.
// Used arcs get heavier; everything you didn't touch decays.
await memory_train({
sequence: [
"v1.procedure.deploy_checklist",
"v1.fact.migration_runner_is_npm",
"v1.procedure.rollback_steps",
],
passes: 2,
});The result is a graph whose shape encodes how you work. The signal compounds; the noise decays. Each session leaves the next one a little cheaper, because the substrate has learned which knowledge travels together.
The payoff shows up at the start, not the end
Here's the part people underestimate: the value lands when you sit down, before you've asked anything.
When a session opens, the substrate already knows your role and your patterns. It pre-loads context ranked to your objective — relevance, proof presence, and conflict status all fold into a single evidence score — so the agent starts with what you'd otherwise have to re-explain. And because it has learned which atoms tend to follow which, on every recall it returns the predicted next atom alongside the one you asked for, each with its own Merkle proof.
{
"atom": "v1.procedure.deploy_checklist",
"payload": "…",
"proof": { "verified": true, "treeVersion": 418, "shardId": 2 },
"predictedNext": {
"atom": "v1.fact.migration_runner_is_npm",
"confidence": 0.71,
"proof": { "verified": true, "treeVersion": 418, "shardId": 0 }
}
}In our benchmarks that prediction is right 64% of the time — and every prediction carries a verifiable proof, so a confident next-step suggestion is never a hallucinated one. It surfaces the adjacent knowledge you didn't think to ask for: the migration gotcha that always bites right after the deploy checklist, the config that pairs with the host change. Not because the system is clever, but because the graph remembers that those facts travel together.
The knowledge you needed, plus the knowledge you didn't know you needed.
Why this changes the economics
When memory only accumulates, every team's context decays toward a write-only archive — present, searchable, and rarely worth the search. When it compounds, the opposite happens: the substrate gets more useful per session, the cost of re-deriving the same lessons trends toward zero, and the knowledge that lives in one person's head stops being a single point of failure.
If your team's context lives in someone's head, or a doc that rots — what would it be worth to have it compound instead?
Parametric Memory is MCP-native and ships 25+ tools for storing, recalling, training, and verifying memory. See the docs to wire it into Claude, Cursor, or your own agents.