RELIABILITY CONTROL PLANE / UNTRUSTED COMPUTATION

Models provide intelligence. They do not get authority.

RESIDUAL is an evidence-driven control plane for deciding whether the output of unreliable computation deserves to become accepted state.

THE CORE BOUNDARY: workers may plan, code, reason, explore, and repair. They cannot certify their own success. Contracts constrain execution. Evidence records facts. Verifiers decide acceptance. Deterministic policy controls state.

NEW HERE?

What does RESIDUAL actually do?

AI can do useful work and still confidently say something is finished when it is not. RESIDUAL treats AI like a worker that cannot perform its own final quality inspection: give it clear boundaries, record what it actually does, independently check the result, fix what failed, and only then approve the work.

In one sentence: RESIDUAL is a quality-control system for AI-generated work.

AI WORKER→“I finished it.”→RESIDUAL: PROVE IT→✗ FAIL → FIX✓ PASS → ACCEPT

worker.claimSUCCESStest.observed13/14 PASSverifierFAIL · quoted-field counterexampleresidualquoted-comma obligation onlyrepair + reverifyPASSintegratorACCEPTED → receipt

RESIDUAL CLIREAL COMMAND SURFACE

residual run examples/demo.toml --json

contract  7 obligations frozen
verifier  FAIL · quoted-field counterexample
repair    residual R₁ dispatched
receipt   ACCEPTED · evidence bound

EXECUTABLE, NOT THEATER

See what you can actually run.

Start a bounded job, launch the local station, reproduce the demo, or verify a retained trace from one visible command surface.

residual runresidual serveresidual demoresidual verify-trace

▶ WATCH GUIDED PROOF LAUNCH INTERACTIVE LAB ↗REPOSITORY ↗PAPER ↗

RUN LOCALLY: python -m pip install -e . && residual run examples/demo.toml · FULL QUICKSTART ↗

Research hypothesis: reliable AI systems may not require perfectly reliable AI components. Reliability can emerge from constraining, observing, verifying, residualizing, and deterministically integrating unreliable computation.

WHY THIS IS DIFFERENT

The durable unit of progress is verified work—not an agent run.

Most agent systems optimize delegation and execution. RESIDUAL focuses on the acceptance boundary: what evidence is sufficient to trust a result, what remains unresolved, and what may enter system state.

Conventional agent loop

Model executes → claims completion

Failure → retry/rerun work

Logs/context describe events

Workflow may drive integration

RESIDUAL

Worker proposes → verifier decides

Failure → repair residual only

Evidence establishes observed facts

Deterministic policy controls integration

Residualization: 20 obligations → 19 independently verified → 1 fails → preserve 19 → R₁={failed obligation}. Correct work does not become probabilistic again through blind recomputation.

CONTROL PLANE

Untrusted proposal → evidence → accepted computation.

SELECT ANY MODULE TO INSPECT ITS ROLE, INPUTS, OUTPUTS, AND FAILURE BEHAVIOR.

SYSTEM STATUS / CLAIM DISCIPLINE

Implemented mechanisms are separated from research claims.

The repository maintains a machine-readable implementation manifest mapping feature families to code paths, tests, partial work and future work.

Status is intentionally conservative. The implementation manifest is the source of truth for feature-status claims.

IMPLEMENTATION MANIFEST ↗

EMPIRICAL PROGRAM

The architecture is implemented. The reliability hypothesis still has to earn its claim.

The controlled study must show whether the control plane lowers incorrect acceptance and recomputation without imposing prohibitive coordination cost.

↓ incorrect acceptancewrong output admitted

↓ recomputationverified work preserved

↑ containmentcontract escapes stopped

orchestration taxbenefit vs coordination cost

Baselines

Single agent · agent + retry · agent + critic · graph workflow · multi-agent voting · RESIDUAL.

Fail closed

FAIL, UNKNOWN, malformed verifier output, provider errors and abstention remain visible