Skip to content

Accountability infrastructure for autonomous engineering

Architecture

Self-verification is not proof.

Proof & State is organised around one boundary: the side of the system that can act, and the side that can only observe. Everything else follows from keeping those two apart.

  • Objective
  • Authority
  • Execution
  • Verification

Topology

The independence boundary

Execution and verification exchange evidence, never authority. No component on the left can influence a verdict on the right.

Proof & State — system topologyexecution ⟂ verification

Verification side

observes only

  1. Surfaceevidence

    Observable evidence

    Repository at an exact commit, CI output, configuration, routes, runtime and deployment artefacts.

  2. Independent verifieropstruth

    OpsTruth

    Reads only. Classifies each check as Verified, Risky or Unproven.

  3. Outputattestation

    Attestation closes state

    The run closes when an independent attestation says observed state matches the claim.

Self-verification is not proof

Flow

How one run moves through the system

Five steps, each producing an artefact that survives the session that created it.

  1. 01

    Objective and authority enter together

    A human states an outcome and, in the same act, declares the authority envelope it may be pursued under: permitted scope, explicit denials, budget ceiling and expiry. Admission is a check against that envelope, not a formality.

  2. 02

    DoneState executes durably

    The run becomes a durable object. Leases prevent concurrent execution, idempotency keys prevent repeated side effects, and every state transition is recorded before the next begins.

  3. 03

    Consequential effects go through AgentProof

    Anything with real-world consequence is prepared, authorised against exact state, executed exactly once and signed. The receipt is the durable artefact, not the log line describing it.

  4. 04

    OpsTruth observes from outside

    The verifier reads repository, stack, test, build, CI, secret, config, route, runtime and deployment evidence at an exact commit. It holds no write authority over any of it.

  5. 05

    Verification closes the state

    An attestation from the verifier is what moves a run from AWAITING_VERIFICATION to VERIFIED. Nothing inside the execution path can perform that transition.

Artefacts

What the architecture leaves behind

Three durable artefacts per run: a state history, a signed receipt for each consequential action, and a classified verification report.

DoneState — run staterun/7c41
  1. ADMITTED

    Outcome accepted inside authority envelope

  2. EXECUTING

    Lease held, budget consuming

  3. VALIDATING

    Local checks and build evidence gathered

  4. AWAITING_VERIFICATION

    Halted — independent attestation required

  5. VERIFIED

    Attestation received, state closed

AgentProof — signed receiptap1:7c4e9d2b83a15f60c8e7d419ab35f2c0
action
merge_pull_request
prepared state
sha256:9f2c41ab6e0d7c5183ba0e77c4d21f9a
authority
envelope/repo-write@exp-2026-08-29T09:00Z
proposer
agent:coding-harness
executor
agentproof:executor-01
signer
key:ed25519:AP-3f8c
verifier
opstruth:report-2f19
outcome
committed_once

Illustrative specimen. Field values show the shape of a receipt, not a real transaction.

OpsTruth — verification reportread-only
Illustrative OpsTruth verification report showing Verified, Risky and Unproven checks
CheckState

Build reproduces at commit

Artefact matches source tree

verified

Test suite executed

Exit status recorded in CI evidence

verified

No credentials in tracked files

Scan clean at this commit

verified

Declared routes respond

One route returns an error status

risky

Deployed artefact matches commit

No deployment evidence available

unproven

Specimens are illustrative shapes, not records of real runs.

Go deeper

Two models worth reading in full

The state model governs what a run may do next. The authority model governs what it may do at all.

Definition — Proof & State
Proof & State is AI work accountability infrastructure: DoneState executes under declared authority, AgentProof authorises consequential actions and signs receipts, and OpsTruth verifies the result read-only from outside the execution path.

Give agents authority. Keep the proof.

The architecture is only as credible as the source behind it. Read both.