Engrammic記

Agent memory gets treated as retrieval. Find the nearest chunk, put it in the window, hope it's true. The failure has a shape: an agent records "the API uses OAuth" on Monday and "the API uses API keys" on Tuesday, keeps both, and later serves whichever one embeds closer to the query. Nothing in the store ever asked which is true, or when it stopped being true.

Engrammic treats memory as epistemics: what an agent holds, why it holds it, and whether it still holds.

The rest of this page is the machinery that makes that concrete. A data model that separates claims from facts, a gate that runs at write time, and a provenance graph you can walk to answer "why does it believe this?"

Four layers stack on top of each other. An observation is a raw event bound to the source that produced it. It enters the store as a claim, a statement the system holds provisionally, never as ground truth. Claims that corroborate each other accumulate weight, and a claim that survives consensus crystallizes into a fact. A fact placed in the context of other facts is a belief, which is what an agent actually reasons from.

All of it lives as nodes and typed edges in a graph store, because provenance is edges. A claim points at its source. A fact points at the claims that promoted it. A superseding fact points at the one it replaced. The schema, the edge types, and the scoring functions that decide promotion ship as engrammic-primitives.

Most memory systems resolve conflicts at read time, if at all. Engrammic resolves them on write. When a new claim contradicts an existing fact, the write does not append another row. It stops and forces a decision: supersede the fact, corroborate the claim, or hold both in suspension pending a human.

$ engrammic write --claim "the API uses API keys" --source session:4f21
✗ rejected: contradiction
  existing fact: "the API uses OAuth2" (crystallized 2026-04-02, 3 sources)
  resolve: supersede the existing fact, or add corroboration to this claim

The cost lands where it belongs, at write time, on the writes that actually conflict. A quiet pile of contradictions never accumulates to resurface mid-task three weeks later.

Every write carries two timestamps: one for when the thing happened, one for when the system learned it. That bi-temporal record makes "what did the agent believe last Tuesday?" a query with a real answer, rather than a reconstruction.

A stronger claim supersedes a fact instead of overwriting it. A typed edge links the old fact to the one that replaced it, and the old fact stays in the graph marked no longer current. When an enterprise asks why an agent told a customer something, the answer is a walk over the graph from the statement back to the observations it rests on, not a shrug.

The obvious question is why not keep beliefs in the model. Weights are a poor store. They hold roughly 3.6 bits per parameter, split between generalizing and memorizing, which caps a 70-billion parameter model near 31GB before it reasons at all, and correcting one belief means retraining.

3.6

bits per parameter

split between generalizing and memorizing

31 GB

memorization ceiling

a 70B model, before it reasons at all

Auditing fails too: superposition means one neuron encodes pieces of many features, so "what does the model believe about X" asks about a mixture. A separate graph gives the opposite properties, explicit, queryable, revisable, and shared, so agents writing to it reach consensus rather than diverging the way partitioned distributed systems do.

engrammic-primitives is the schema, Apache 2.0: the layers, the edge types, the promotion scoring. The engine sits over a graph store and exposes an MCP server, so any agent that already speaks MCP reads and writes against it with no bespoke SDK. Manifold, a version of the same engine for latent embeddings instead of text, exists as a design document and waits on a customer who needs multimodal memory.

Measured over 500 annotated coding-agent sessions, each comparing the write gate against an embedding-only, append-only baseline.

95%

contradictions caught

baseline catches 66%

87%

corrections propagated

baseline reaches 12%

73%

contamination blocked

baseline lets it through

165ms

median gate latency

and it runs only on writes that need it

A belief needs a source. Everything else is output with confidence attached.

An agent running on this answers, on demand, what it knows, what it only generated, and which of the two a given conclusion rests on. An agent without the split answers none of them and still sounds equally sure. I think the next decade of AI turns on trust, not capability, and the research is open at engrammic.ai/research because the problem is bigger than one company. If you work on agent memory, belief revision, or multi-agent coordination, I want to hear from you.