A reviewer decides once. The precedent governs only while its recorded conditions hold.
Review should compound, not disappear into tickets. FieldHash records a customer-approved decision as bounded precedent outside the model, then stops reuse when the conditions that authorized it no longer hold.
Governed Precedent is one possible result of the Governed Learning Loop. Some reviewed outcomes may guide later cases within approved limits; others remain one-off or update the authority available to the workflow.
The result
Valid review carried forward. The check withheld 47 of 70 invalid reuses.
FieldHash makes approved review reusable within its scope, withholds reuse when that authority expires or changes, and records the decision for inspection.
In this controlled 83-case diagnostic, the reuse check applied all 10 valid reuse cases and all 3 valid time-boundary controls. It withheld 47 of the 70 invalid-overreach cases, including every expiry, revocation, and change in authority. It gave the other 23 a clean allow. Those cases needed their own checks or a reviewer. In November 2026 we traced all 23, built the missing checks and ran the cases again: see what we did next. The SOW records which reuse conditions a pilot enforces.
Correction (October 2026): earlier versions of this page said FieldHash returned all 70 invalid cases to review. The earlier test script recorded the expected outcome in place of the check’s result. A corrected run that records the check’s raw result found it withheld 47 of the 70 and gave the other 23 a clean allow. The verification bundle on this page is built from that corrected run and replaces the earlier bundle.
The diagnostic began with a reviewed choice of governing source, then tested future cases against it. Expiry, revocation, conflict, missing support, and near-miss scope changes each tested whether the earlier decision would overreach. These are self-administered synthetic cases; customer review savings remain to be measured.
Governed Precedent is the third governed surface, alongside Governed Memory and Governed Actions. Governed Memory decides which record reaches the model. Governed Actions decides which tools and execution runs are authorized. Governed Precedent decides which reviewed decisions may influence future cases.
The operational pain
Your review queue is becoming your AI memory. It was never built to govern future answers.
Every hard AI review creates a decision someone will need again: which clause governs, which policy wins, which package is revoked, which exception no longer applies. Today, that decision often dies in a ticket, gets copied into a prompt, or becomes a brittle rule nobody trusts six months later.
FieldHash captures the decision as governed precedent under customer-defined validity conditions. A later matching case may reuse it, and material change stops reuse before the decision hardens into another stale rule.
Built for
For teams whose review decisions need to become governed future influence, not prompt folklore, stale rules, or unverifiable tribal knowledge.
Reuse cases
83
Valid reuse and overreach, tested together.
Valid reuse and invalid-overreach cases covered matching, near-miss, stale, revoked, conflicting, and unsupported future cases.
Invalid reuse the check withheld
47/70
The reuse check withheld 47 of 70 invalid reuses.
The 83 cases included 10 valid reuse cases, 3 valid time-boundary controls, and 70 invalid-overreach cases. The check applied all 13 valid cases. It gave the other 23 a clean allow; the proof buckets below show where they fell. Those cases needed their own checks, which we have since built: see what we did next.
Recorded tamper result
830/830; 9/9
Packet and bundle mutations were rejected.
The retained run reports 830 event or packet mutations and 9 artifact-level mutations rejected. The public checker verifies the published projection and its hashes; it does not rerun the internal tamper suite.
What we did next · November 2026
We traced the 23, built the missing checks and ran all 83 again.
Most of the 23 were defects in how the test was set up, not the reuse check misfiring. Fourteen of them also showed real gaps in the product: it had no way to weigh competing precedents, and no typed policy checks.
| Group | Cases | What was wrong | What changed |
|---|---|---|---|
| Extra scope fields | 4 | A field changed only in the new case; the reviewed approval never covered it. | The corrected test binds the field in the approval, then changes it. |
| Caveated outcomes | 5 | The caveat came from the test setup, not from the reviewed decision. | The corrected test uses a genuinely caveated reviewed decision. |
| Competing precedents | 8 | The check was given one precedent, so nothing could conflict with it. | New in the product: every applicable precedent is weighed, and a disagreement goes to a person. |
| Policy guards | 6 | A text label stood in for policy evidence. | New in the product: six typed policy checks, each refusing reuse on missing or failing evidence. |
83/83
cases ended where the corrected test said they should
0
invalid reuses given a clean allow
20/20
additional controls passed, including the order of competing precedents
This is not a same-input before-and-after: the inputs were corrected, so the 47 of 70 above stands as the record of the first test. When valid precedents disagree, FieldHash sends the case to a person rather than ranking them. The policy evidence comes from the operator and is not independently verified. The eight competing-precedent cases cover four distinct situations. Synthetic and self-administered, by the team that builds FieldHash.
Then 300 cases nobody hand-picked
Next we generated 300 new cases from a fixed seed, each combining one to three of the same kinds of change, and wrote down every right answer before running. A separate AI agent also built its own reuse check from a plain-language spec of the same requirements, without seeing FieldHash's code, the cases or any result.
| Approach | Right answers | Would reuse without needed review |
|---|---|---|
| FieldHashprecedent admission, current code | 300/300 | 0 |
| Separately written checkbuilt by a separate AI agent from a plain spec, 427 lines | 300/300 | 0 |
| Reuse until expiry (modeled)ignores scope, evidence, dependencies and conflicts | 166/300 | 125 |
| Always reuse (modeled)reuses the first precedent unconditionally | 92/300 | 199 |
Pre-registered and run on November 2, 2026, against the current code. The change kinds, the case generator and the spec were written by the team that builds FieldHash, so this shows the reuse rules hold under combinations nobody chose and can be implemented independently; it does not show those rules are the right ones, and it does not test new kinds of change. A pure function call on synthetic inputs; the two shortcut approaches are modeled from their rules.
Then we tried to break it
After round 3 we ran three more rounds aimed at one failure: a reuse going ahead that should have gone to a person. In each round a fuzzer generated tens of thousands of random inputs and compared FieldHash with the separately written check, and a separate AI agent, given FieldHash's source code and the written requirements, tried to find inputs that get such a reuse through. Before each round we wrote down a prediction of zero.
| Round | Ways found | After the fixes |
|---|---|---|
| Round 420,000 fuzz inputs and a first red team | 4 | 0 |
| Round 5a second fuzzer and a second red team, on the fixed code | 4 | 0 |
| Round 6over 70,000 fuzz inputs and a third red team, on the next fixes | 1, in the service's configuration handling | 0 |
All three predictions missed. Each way found was fixed with a test that fails on the earlier code, and every earlier round was re-run. On the final code: 0 in 70,006 fuzz inputs, 0 in the 60 inputs the three red teams wrote, and round 3 still 300 of 300.
Pre-registered and run on November 2, 2026. The requirements, both fuzzers, the separately written check and all three red teams were directed by the team that builds FieldHash; the testers are AI agents, not outside reviewers. This tests the reuse check as a function call on synthetic inputs, plus one configuration path of the deployed service, not a live deployment. These are counts over the inputs tried, not a proof, and no red team has attacked the final code. FieldHash still sends some cases to a person that the requirements would allow, by design.
The buyer problem
The same authority conflict keeps coming back.
A legal reviewer resolves that Legal approval overrides CRM status for a contract clause. A security reviewer decides a revoked package cannot be installed even if a stale manifest says it can. A compliance reviewer decides a regional policy supersedes the global default.
The next similar case should not start from zero. But copying that decision into a prompt, cache, or static rule creates a different risk: yesterday's judgment keeps governing after the scope changed.
A governed precedent is the middle path. FieldHash preserves the reviewer's decision as a bounded authority object, not as model folklore.
What the diagnostic showed
Mechanism
FieldHash gives reviewed decisions a bounded reuse lifecycle.
The governance layer determines whether a reviewed decision may guide a later case and returns changed or unsupported cases to review. The decision remains external to the model.
A case reaches review.
A governed handoff cannot establish a clean authority decision from the available evidence.
The reviewer establishes what governs.
An authorized reviewer resolves the bounded case. FieldHash records verified review lineage outside the model rather than turning free text into hidden model policy.
FieldHash records bounded precedent.
When the workflow permits reuse, the reviewed decision receives customer-defined validity conditions for later cases.
Future cases test whether it still holds.
The prior decision may guide a later handoff only while its authorizing conditions remain valid. Otherwise the case returns to review.
The packet proves the path.
The evidence packet records whether the prior decision was used or withheld, and why.
Adversarial proof
The pass condition was refusal, not reuse.
A weak review cache looks good because it reuses a prior decision. A governed precedent earns trust because it knows when not to. The fixture tried to turn one reviewed outcome into an overbroad rule across 11 case families, grouped below into eight reviewer-readable buckets.
Inspect the eight reviewer-readable proof buckets+
Valid reuse
10The check applied the prior decision in all 10 cases where its authorizing conditions held.
Near-miss scope
12The check withheld 8 of 12 near-miss scope cases and gave the other 4 a clean allow; those need a separate check or a reviewer.
Missing support
8Cases without sufficient supporting evidence did not receive a clean allow.
Excluded neighboring cases
8Similar cases outside the approved boundary did not inherit the earlier decision.
Time validity
9Valid boundary cases applied; expired cases did not.
Changed authority
12Material change in governing state suspended reuse.
Revoked or limited
10The check withheld the 5 revoked decisions. It gave the 5 limited ones a clean allow: their inputs supplied a plain approval, and the limit existed only in the test label.
Conflict and policy guard
14The check gave all 14 a clean allow. The conflict cases supplied no competing precedent, and the policy-guard cases supplied only a label.
Verifier path
Inspect the public outcomes and the limits of their checker.
The run’s own verifier checked the original case fixtures and expected labels, the raw observations, evidence records, integrity bindings, and tamper suite.
The public checker recomputes every total from the 83 published rows: 13 valid and 70 invalid cases, family counts, clean allows, withheld cases, and the no-go verdict. It checks member checksums and each row’s self-hash, and fails if any published figure no longer matches the rows. It accepts a faithfully recorded failing result, which this is. It does not rerun product code, authenticate who produced the run, replay the underlying authority decisions, or rerun the internal mutation suite. These checks establish consistency of the published projection.
Public consistency checks
Download the public verification bundle.
The bundle includes the observed outcome for every case, source run hashes, checksums, and a checker for the published counts and their internal consistency. It excludes production schemas, internal matching and revalidation rules, proprietary resolver code, raw reviewer notes, source bodies, prompts, tool results, customer data, provider logs, local paths, and credentials.
sha256: 2e3f181498cc86054f4a3fae4581f9ff409ac7549e5b41ab0a2f0f45b1083b1f
Reissued October 2026 from the same corrected run; figures unchanged.
Why it matters
Put useful review to work again, within its approved limits.
A resolved case can help the next reviewer when the same authority still applies. Governed Precedent carries that decision forward with its scope, supporting evidence, and expiry. Your team can inspect, narrow, or revoke its future influence.
The diagnostic tests whether FieldHash can reuse a decision under pressure and stop reusing it when the conditions no longer hold.
Study scope
Reuse behavior tested under defined conditions.
- This controlled, self-administered diagnostic tests when a reviewed outcome may influence a later handoff and when changed conditions must stop reuse.
- Authority remains outside the model. The test does not establish reviewer correctness, model learning, or live execution proof.
- Customer validation, review-time savings, and production readiness require a customer-scoped evaluation; the diagnostic does not establish them.
Next step
Bring one recurring authority conflict.
Find out which recurring decisions can use prior approved review, which need a fresh decision, and how much reviewer effort that takes. Start with a six-week shadow evaluation and an evidence report. Production enforcement remains off until separate testing and acceptance are complete.