Who gets to write truth?

The dangerous moment in an agent memory system is write-back.

An agent observes a pattern. It summarizes the pattern confidently. The summary lands in a durable store. The next agent reads the summary as reality, makes a decision based on it, and ships. That is how a guess becomes infrastructure.

Earlier posts in this series split memory into layers by job — canon, recall, relationships, traces, projections per phase. This one is the governance question across all of those: who writes, with what evidence, through which gate. If the read path is the projection, the write path is the architecture.

Observation is not synthesis

Three distinct objects often get smushed into one "memory" bucket:

• Observation: a tool trace, a session log, a captured event. Raw record of what happened.
• Synthesis: a reflective summary that interprets observations into a pattern, mental model, or rule.
• Canon: reviewed durable truth that other agents will rely on.

These need separate write permissions because they're different epistemic objects. An agent should be able to write observations freely — those are evidence, and evidence is cheap to collect. Synthesis should be a deliberate, attributed step — an agent saying "I've looked at these observations and I think the pattern is X." Canon updates should require review, full stop.

A concrete example walking up the ladder:

• Observation: Three agents over the last two weeks failed the same Playwright test with the same EADDRINUSE on port 4173.
• Synthesis: The repo's local dev flow has unstable port allocation — the dev server isn't being reliably torn down between runs.
• Canon proposal: Update docs/testing.md to require an explicit port-free check before Playwright runs, and add a pretest script that kills the leftover process.

The observation is reportable. The synthesis is a claim that needs evidence. The canon proposal is a durable change that should ship as a PR.

Synthesis is not canon

This is the slip that quietly breaks systems. Hindsight's reflect() operation is a great example of useful synthesis — it explicitly takes the bank's directives and disposition as input and generates mental models from prior observations. That's powerful. It's also dangerous, because once a "mental model" is stored, the next agent that retrieves it will tend to treat it as a fact.

A mental model is a claim. A claim needs a source. Reflection without provenance is hallucination at rest — and one of the cleanest ways to launder confidence into infrastructure is to let the synthesis layer write straight to wherever the next agent reads from.

The fix isn't to disable reflection. The fix is to make synthesis a proposal, not a write. Hindsight-style reflect outputs, AgentMemory-style trace summaries, GBrain-style derived facts — all of them should land in a "proposed canon" surface that points back to the evidence, not directly into the canonical store.

Proposal needs evidence

A useful agent does more than say "I learned X." It says: "I think X should become canon, and here is why."

The "here is why" is the load-bearing part. Evidence should be inspectable without rerunning the agent's whole session. The reviewer (human or another agent) should be able to look at the proposal and check the trail without re-deriving it. That means linking, not summarizing.

A write path that has earned its keep for me, with the boring details:

1. Agent captures tool trace as it works (the black box from the black-box recorder).
2. Semantic memory retrieves related prior failures or successes.
3. Reflective layer notices a pattern and drafts a durable lesson.
4. Proposal lands as a PR — markdown change in the canon repo, with explicit links to the traces, diffs, review comments, or docs that motivated it.
5. Human or a review agent with a narrow remit approves (or rejects with notes).
6. Canon doc merges. Future agents read the reviewed rule.

The PR is the gate. Not because PRs are magic, but because they're the lowest-friction surface I have for "show me what changed and let me say yes or no before it goes live."

Knowledge-graph memory makes this sharper because graph edges look deterministic once they're stored. Mara -> maintains -> billing adapter feels less squishy than a paragraph in a transcript. But the write path that created the edge was still messy: an LLM extracted it, normalized the names, picked the relation, and decided direction.

The ugly parts are where the architecture lives:

• Mara, mara-k, and @mk might be the same person, or they might not.
• maintains is not the same as reviewed once.
• works_on probably expires; authored usually doesn't.
• depends_on has direction, and getting direction wrong poisons traversal.
• "Billing adapter moved from REST to GraphQL" contradicts the old edge instead of politely replacing it.

So graph writes need the same contract as every other write: source, timestamp, confidence, relation type, and a way to mark contradiction or expiry. Otherwise the graph becomes a very confident rumor mill. It can walk paths. Great. Now make sure the path is not paved with stale extraction garbage.

Review is not bureaucracy

The instinct against review is usually "this'll slow everything down." It does, slightly. It also prevents the failure mode where the agent's beliefs about the world quietly become the world.

Review can be fast. Review can be partially automated. Review can have asymmetric rules — high-confidence updates from a trusted reflective layer with clear provenance can auto-merge after a sniff test; low-confidence updates from a noisier source need a human eye. Durable canon in this stack stays human-reviewable as the default, but the default is a posture, not a religion.

The instinct to skip review usually frames the gate as a human bottleneck. The gate isn't the human. The gate is the moment a claim moves from "an agent thinks" to "we agree." Whoever's standing in the gate — human, review-agent, automated check — owns that transition. The transition matters even when the gatekeeper is cheap.

This matters disproportionately for two specific paths:

• Relationship memory proposing world facts. A user preference shouldn't get promoted to repo canon just because the assistant noticed it three times. (See relationship memory for why these layers should stay separate in the first place.)
• Coding-agent traces proposing world facts. A failure pattern that recurred in three runs is evidence; it's not automatically true. The repo might have changed in a way that makes the pattern obsolete next week.

The review gate is what catches both. Skip the gate and the system slowly fills up with shadow truth that nobody signed off on.

One canon, many memory layers

The whole series argument lands here. Relationship memory stays out of world truth — it influences tone, not facts. Coding-agent traces feed canon through review — they're evidence, not declarations. Semantic recall retrieves and connects candidates — canon decides which candidates become claims. Reflection proposes synthesis with provenance — review promotes synthesis to canon. The orchestrator picks which layer each phase reads from (the projections post).

One canon. Many memory layers. Every durable claim has a path back to evidence.

That's the version I keep landing on after each round of trying something cleverer and watching the cleverness produce shadow truth.

Where the architecture is still moving

A few qualifiers, because "governance" sounds more settled than it is:

• The gate doesn't have to be a human forever. As proposers get better at provenance, automated review can absorb more of the work. Human approval is the default for durable canon in this stack today; the ratio should shift as proposers earn trust.
• Agents aren't locked out of writing. They can write observations freely. They can write proposals with evidence. They can write low-authority memories (session notes, scratch synthesis). What they can't do is silently update canon.
• Governance isn't solved here. This is the architecture I'm leaning into, not the version running in production at scale. The right shape will keep moving as the layers harden.
• Provenance doesn't eliminate hallucination. It makes hallucination inspectable — and inspectable means contestable. That's the property worth paying for.

Outcomes

• The write path is the architecture. Read paths are easier to redesign than write paths; pay the cost of getting the writes right.
• Agents can propose truth. They should not silently create it. The gate is what keeps proposed claims from becoming infrastructure by default.
• One canon, many memory layers. Every durable claim earns a path back to evidence.
• The series ends here, but the architecture doesn't. Next round is wiring the proposal-to-canon path into a real stack and seeing where the gate friction hurts most.