Trust is a trajectory, not a checkpoint.

Everyone else fights agent review fatigue by shipping more to watch.

The question every team is asking is whether an AI reviewer is finally good enough to skip the human on a PR. It is the wrong question. Put an AI agent on consequential work (code, support replies, refunds, document intake) and a human is nominally reviewing it. But no one can meaningfully review everything an agent does at agent speed, so review collapses into rubber-stamping (review theater) or bottlenecking (the agent's speed is wasted). Engineering teams feel it first in the dev loop (nobody reads dozens of agent PRs a day), which is why Recede starts there and reaches further. The root cause is a trust-calibration bug: trust today is mis-attributed: one global "do I trust the AI?" verdict, when trusted to fix a flaky test and trusted to run a migration are different questions, and neither says anything about trusted to answer a customer. And it is mis-calibrated: granted by feeling, not evidence. The usual answer is a bigger dashboard, a 0–1000 score, more alerts. Wrong direction.

Fix attribution (per Actor × TaskType) and calibration (evidence + confidence), and small daily verified wins compound into earned, bounded autonomy, so review recedes exactly where warranted.

Five bullets, plus the proof.

I ran the test that could kill it.

A protocol that grades agents has to accept the same grading. Recede's own dogfooding ledger could not provide it: for weeks it held one actor's records with zero reverts, and a ledger that only ever says PASS carries no information. Invariant I4 says exactly that. Real history has the reverts, so I asked whether replayed lane trust, computed from evidence observable at merge time only, predicts which merged PRs later reverted, better than trivial baselines.

Before any result existed I froze the revert definition, the success thresholds, and the leakage rules, and committed to shipping the result either way. The current trust math did not beat trivial baselines on next.js, and the langchain arm was underpowered. A post-hoc correction I made to an under-converged baseline is what flipped the first result against my own thesis. The pipelines are deterministic and the scorecards publish with the writeup. The discipline of the null is why you can trust the numbers Recede does publish.

Predicting which changes will revert is a roadmap capability, not a claim Recede makes today. What ships now is the governance gate itself: warrant chains, a pure replayable decision, asymmetric trust with hard never-recede floors, and a receipt for every action a human no longer reads.

Recede doesn't know what code is.

The spec defines actors, task types, evidence, and a gate: the flow decides what Verify, Validate, and "irreversible" mean. The same eight operations:

Same protocol, same receipts. Only the checks and the policy change.

It's not another scorecard. It's a layer above them.

Recede sits above interop (MCP/A2A), eval/observability tools, static guardrails, and framework validation loops (the accessibility, SEO, type, and contract validators that already check every agent output), consuming their signals as evidence rather than replacing them. It is the memory and the gate on top of them: per lane, it decides when their green is enough to let review recede.

The whole framework is one call: wrap the function you already have.

Reference implementation: TypeScript primary, Python mirror. The gate is implicit: there is no if (needsReview) in your code. run() decides. Your existing CI, tests, and PR reviews become the evidence.

const r = new Recede({ ledger: new MemoryLedger(), checkpoint: consoleCheckpoint(), policy });

// Verify = did it right (CI green).  Validate = did the right thing (intent-fit).
const ciGreen  = check.verify("ci", io => io.output.ci === "green");
const intentOK = check.validate("intent-fit", async io => ({ ok: await reviewMatchesIntent(io.intent, io.diff), confidence: 0.8 }));

const outcome = await r.run(() => agent.implement(ticket), {
  actor:    "code-agent",
  taskType: "code.fix",
  intent:   `Fix ${ticket.id}: ${ticket.title}`,
  risk:     "reversible.low",
  checks:   [ciGreen, intentOK],
});

// The gate is IMPLICIT: run() decides whether a human is asked.
outcome.result;      // the change (or the human-edited version)
outcome.trust;       // { before, after, delta } for (code-agent, code.fix)
outcome.checkpoint;  // undefined once review has receded for low-risk fixes
outcome.warrant;     // the hash-linked chain: intent -> diff -> checks -> outcome

As the ledger accrues verified, validated changes, that same call site graduates from "always ask a human" to "merge autonomously", and reverts the moment the agent regresses. You don't rewire anything. The trajectory does it.

Wrapping a refund flow, a support reply, or a document pipeline is the same call with different checks: see One protocol, many flows.

v0.1 DRAFT: the protocol is the deliverable; the code is proof.

Breaking changes expected before 1.0. Designed clean-room from first principles and public prior art only: append-only logs, content addressing, risk matrices, calibration, human-in-the-loop gating, and verification-vs-validation from systems engineering.