Is this real?

Watch the substrate work end-to-end. Inspect the actual signed artifacts the run produced. Re-verify each one yourself under the agent's published Ed25519 pubkey.

Same binaries you would run locally. Same signatures. No mocks.

Watch the run.

A $38,400 vendor invoice flows through an autonomous payment agent. Eight acts: invoice arrives, agent requests payment, authority is checked against a Root condition, denied (authority-driven), escalated, approved, and six months later — replayed. Plus a bonus: revoked-handle denial.

# Clone, build, run.
$ git clone https://gitlab.com/drata5764111/h33/scif-backend.git
$ cd scif-backend/agent-007 && cargo build --release && \
    cd ../h33-key && cargo build --release && cd ../agent-007
$ ./demo/demo.sh                  # default pacing
$ ./demo/demo.sh --keep-home      # preserve the produced receipts

Two casts (executive ~90s, technical ~6 min) embed here when produced. Until then the static trace above is verbatim demo output — same binaries, same receipts, same exit codes.

The signed receipts the run produced.

Every artifact below is verbatim from the run shown above — with the device fingerprint redacted. Click any to expand the raw JSON. This is where auditors spend time.

{
  "accepted": true,
  "request_name": "invoice-agent",
  "secret_refs": [
    { "name": "STRIPE_SECRET",
      "h33k_id": "h33k_CY9KYCH29P0E4MM0BPJMA9PJYW",
      "purpose": "invoice_payment" }
  ],
  "verification": {
    "agent_007_verified":     true,   // legacy field name — flips to agent_008_verified when the substrate code-level rename ships
    "h33_key_verified":       true,
    "h33_attest_verified":    true,
    "root_lineage_verified":  false,   // lights up when scif #41 (Authority Freshness) ships
    "verification_level":     "stage_d_attest_bound",
    "read_attestation_ids":   [ "RA-M1P9TS" ],
    "secret_used_receipts":   [ "8eb2cdcd905640b6…" ],
    "secret_captured_receipts": [ "54d984e449d2f2db…" ],
    "secret_denied_receipts": []
  }
}

Re-derive the verdict yourself.

Every signed artifact above is independently verifiable. Load the agent's public key, recompute the canonical body, check the Ed25519 signature, walk the state machine. ANY tampered field → NO. All hold → YES.

The substrate doesn't trust the chain's narrative. It re-derives the canonical body of every artifact and re-checks each signature. Pseudo-code for a third party (Rust, Python, Go — same logic):

// One verifier. Each signed artifact: re-derive body, check sig.
fn verify(receipt: &SecretDeniedReceipt, pubkey: &VerifyingKey) -> bool {
    let body = receipt.canonical_body();   // deterministic, line-oriented
    let sig  = hex::decode(&receipt.signature_hex);
    ed25519::verify(pubkey, &body, &sig)
}

// Attestations walk the same path + a state-machine check.
fn verify_attestation(att: &ReadAttestation, pubkey: &VerifyingKey) -> bool {
    if !ed25519::verify(pubkey, &att.canonical_body(), &att.signature) { return false; }
    state_machine_valid(att.state, &att.state_history)
}

Audit logs degrade. Receipts don't. The substrate answers — six months later, offline — exactly why each verdict was reached.

This wasn't a one-off.

Delegation fidelity was measured across multiple production models, multiple delegation depths, and multiple failure classes. The pattern is consistent: the chain's recall degrades; substrate verification doesn't.

   Decision Fidelity                                  Vanilla agents          H33-Root
   100% │━━━━━━━━━━━━━━━━━━━━━━━━━━━    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        │╲
        │ ╲
    75% │  ╲
        │   ╲___
    50% │       ╲___
        │           ╲___
        │               ╲_______
    25% │                       ╲_________
        │                                 ╲___________
     0% └────────┬──────────┬──────────┬──────────┬───────────────
                 5         10         20         50    depth

H33 verifies against the Root. It does not rely on memory.

Across the validation sweep so far: no observed fidelity degradation through the swept range. Full methodology, per-condition traces, and per-cell numbers ship with the Delegation Fidelity white paper when the production run completes.