Governed Memory diagnostic
Send the governing record.
Prove the answer path.
On the public MemConflict sample, Governed Memory forwarded only the governing record (about 3x less context than even a tight prompt, 50x less than naive retrieval) and emitted a packet for every answer: what was allowed, what was blocked, and why. The point is not a higher score; it is that you can prove which record entered the model input, and that the stale one never did.
Result
Less context. Provable provenance.
Naive retrieval sends ~16,020 characters and scores 230/300. A strong prompt scores 297/300 but leaves the stale record in context and asks the model to ignore it. FieldHash forwards only the governing record (~323 characters: ~3x less than the prompt, ~50x less than naive retrieval) and scores 283/300 on the benchmark's rule scorer. Seventeen outputs did not satisfy the benchmark's narrative-form scorer. Manual review found 15 contained the correct value in a shorter form, one abstained, and one matched the comparison prompt. FieldHash's distinct claim is that the stale record was excluded before generation and the governed context was recorded for every answer.
Boundary: a configured-authority diagnostic on the public sample, not an accuracy-beating or leaderboard claim. gpt-5.5, n=300.
Attributable
All 300
Every answer carries a packet.
What governed the handoff, what was blocked, and why, all hash-chained, for every one of the 300 answers by construction. This is a property of the mechanism, not a benchmark score. You can reconstruct the governed context supplied for any answer, right or wrong, rather than relying on model output alone.
Provable
0
Blocked records that reached the model.
FieldHash removes superseded and contradicted records from the model’s input and records that it did. "The stale record never reached the model" becomes verifiable, not hoped-for.
Efficient
~50x less
Context the model has to read.
~323 characters of governed context per answer: ~3x less than even a tight authority-labeled prompt, ~50x less than naive retrieval that dumps every candidate.
Why the context collapses
Retrieval surfaces everything. Governed memory forwards one record.
A memory query can match the current record and several superseded or contradicted ones. Naive retrieval hands the model the whole set and asks it to sort them out, carrying the full text into context on every call, and scoring worst for it.
FieldHash resolves which record governs from the configured authority state, forwards only that record, and keeps the blocked alternatives in the packet. The model receives less, only the governing record reaches it, and it returns the same correct values a strong prompt does.
Per-answer context, what reaches the model, and score
| Arm | Context chars | Stale records reaching the model | Score |
|---|---|---|---|
Naive retrieval (recency-aware) Dumps every plausible candidate as raw session text; the model muddles the conflict. | 16,020 | all | 230/300 |
Strong labeled prompt Governing and blocked records are both in context, labeled, with the stale one trusted to be ignored. | 956 | all (labeled) | 297/300 |
FieldHash governed memory Only the governing record reaches the model; blocked alternatives are removed and kept in the packet. | 323 | none | 283/300 |
FieldHash sends the least context and is the only arm that keeps stale records out of the model's input: across the run the strong prompt placed 856 superseded records there, FieldHash placed none. Score is the benchmark's rule scorer. FieldHash's lower count is scoring form, not wrong answers: of its 17 misses, 15 are the exact correct value stated tersely (the gold narrates "sources disagree," FieldHash returns the value), one is an abstention the prompt also made, one matches the prompt verbatim. See Reading the failures, below.
Why attribution is the point
A correct answer does not prove which records entered model context.
On the values themselves, the strong prompt and FieldHash agree. The prompt leaves the stale record in context and asks the model to ignore it. FieldHash removes the stale record before generation and records the exclusion, so reviewers can verify the governed context supplied for the answer.
When an output misses the benchmark scorer, the packet still shows which record was supplied and which alternative was withheld. The 17 scorer misses are classified below and remain available in the row-level bundle.
That is the behavior a governance layer should have. A benchmark rewards always producing an answer; in production, an honest "not in the record" or "needs review" beats a confident fabrication every time. FieldHash declines to guess, and proves it did.
What the packet records
- Allowed record: the one that governed the answer
- Blocked records: superseded or contradicted, withheld from the model
- Reason: why each record was allowed or blocked
- Answer hash + chain: reviewer-verifiable after the fact; stronger tamper evidence depends on deployment configuration
The same correct values a strong prompt gives, with proof it cannot.
Reading the failures
Here are FieldHash's misses. Read them yourself.
The benchmark counts these as misses. The packet shows what each one actually was, so judge for yourself.
The user’s gender
“Male.”
The gold says the correct value is Male. FieldHash returns it, docked only for not adding “sources disagree.”
Number of siblings
“The user has 1 sibling.”
The exact correct count. Docked because the gold narrates the disagreement and FieldHash answers plainly.
When they watch the NBA
“The memory needs manual review.”
A conflict it could not cleanly resolve, so it declined. The strong prompt declined here too.
Seventeen outputs did not satisfy the benchmark's narrative-form scorer. Manual review found 15 contained the correct value in a shorter form, one abstained, and one matched the comparison prompt. Every row remains in the verification bundle for independent classification.
Claim boundary
What this page does and does not claim.
- This is a private configured-authority diagnostic on the public MemConflict released sample, not an official leaderboard result.
- FieldHash forwards only the governing record: ~50x less context than naive retrieval, ~3x less than a strong prompt.
- On the benchmark’s rule scorer FieldHash scores 283/300 to the strong prompt’s 297/300. Read all 17 misses: 15 are the exact correct value stated without narrating the conflict, one is an abstention the prompt also made, one matches the prompt verbatim. The gap is scoring form, not wrong answers.
- FieldHash’s edge here is not a better score. It is attribution: every answer carries a verifiable packet, and blocked records are provably absent from the model’s input.
- The packet proves the mechanism executed as configured: which record governed, and that blocked records stayed out of the model’s input. It does not prove the configuration was right. Choosing which record governs is an upstream authority policy this diagnostic does not test.
- The run uses benchmark conflict metadata as configured authority state. The claim is governed-memory influence and attribution, not autonomous timeline inference.
- Primary run: single model (gpt-5.5), n=300 stratified. The model-invariance addendum below reruns the same governed path with two local models. Every figure here is recomputable from the published verification bundles.
Model-invariance addendum · two local models · two seeds · same-day dual judge
We swapped the frontier model for a laptop. The gate didn't notice.
Same harness, same 300 questions, same seeds, same official judge. The only change was the model behind the gate: the frontier API above, then two 4-bit models running on a laptop through a local endpoint. The gate blocked the same records, routed the same conflicts to review, and every packet chain verified. What moved was the polish of the answers, not the governance.
| Model behind the gate | Naive retrieval | Strong labeled prompt | FieldHash governed |
|---|---|---|---|
| gpt-5.5 (frontier API) | 154/300 | 295/300 | 290/300 |
| Gemma 4 E2B, 4-bit, laptop | 128/300 | 278/300 | 279/300 |
| Qwen 2.5 1.5B, 4-bit, laptop | 134/300 | 259/300 | 249/300 |
Official gpt-4o judge, all cells scored the same day; the naive arm is the same recency-aware baseline as the table above. Every governed cell beat every ungoverned cell. At every tier, dumped-context answers were substantively wrong about half the time.
856 = 856 = 856
Records blocked, per model
The gate blocked the identical set of records for all three models on the primary seed, and 868 for both local models on the second seed. Governance decisions did not depend on the model.
2
Identical review routes
Every run routed the same two unresolvable conflicts to manual review, including the same conditional-conflict case the frontier run abstained on.
0
Packet-chain errors
All packet chains verified across four local runs. Every figure below recomputes from row-level artifacts in the verification bundle.
How to read this fairly
- Parity with the strong labeled prompt is within judge run-to-run variance (Gemma discordant pairs 7 vs 6, exact McNemar p=1.000; Qwen 20 vs 30, p=0.203). We do not claim the governed arm beats the prompt.
- The tier gap is real and disclosed: Gemma governed trails frontier governed 279 to 290 on the same judge (p=0.019). Qwen trails clearly. Governance sets the floor; model spend buys polish.
- Both local governed arms beat the ungoverned frontier arm on the same 300 questions: Gemma won 133 paired questions and lost 8 (p=2.4e-30); Qwen won 120 and lost 25 (p=4.4e-16).
- Same harness, seeds, sampling, temperature, and token budget as the published run, verified against its artifact; a 128-token sensitivity run produced identical seed-1 results. Local arms used an OpenAI-compatible local endpoint (chat completions) rather than the Responses API.
- All cells were judged the same day. A modern second judge (gemini-3.5-flash) agrees within a few cases per arm and preserves every ordering; the official 6/21 judge artifact matches within two cases.
- Reading the local misses: of Gemma’s 21 judge-misses, 9 carry the correct governed value, 2 are principled abstentions, and 10 are real, in two named families: polarity flips on "did it stay the same?" questions and a zero-rendering glitch. Qwen’s misses are mostly genuine small-model failures. Every miss was diagnosable from its packet.
- Task-scoped: answering from a governed record after enforcement, on 4-bit quantized weights. Not open-ended generation parity, and not customer validation.
What this buys a deployment: with the gate holding the floor, model choice becomes an economic decision, not a risk decision. The same result read the other way is the sovereignty case: a governed record answered on hardware it never left.
Why it matters
Prove the answer path, and diagnose when it is wrong.
A model answer alone does not establish which records entered its input or whether a stale alternative was present. FieldHash makes the governed path attributable: the packet records what governed, what was blocked, and why, so reviewers can inspect the context supplied for any answer and diagnose the ones that miss, at a fraction of the context.
That is Governed Memory in one line: forward the record that governs, prove the rest stayed out, and keep a receipt for every answer.