Trust is a trajectory, not a checkpoint.

Everyone else fights AI-PR review fatigue by shipping more to watch.

You put an agent in the dev loop — it plans, writes code, adds tests, opens PRs. No human can meaningfully read 40 agent PRs a day, so review collapses into rubber-stamping (review theater) or bottlenecking (the agent's speed is wasted). 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 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, and you have the whole thing.

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

Recede sits above interop (MCP/A2A), eval/observability tools, and static guardrails — consuming their signals as evidence rather than replacing them.

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.

The same protocol scales to a higher-stakes frontier — an agent issuing refunds, moving money — riding the identical records, gate, and invariants (examples/refund). But the everyday win is your SDLC.

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.