Verifiable Debate Ledger (VDL)

The VDL is a hash-chained decision log that makes every agent decision — acted or declined — tamper-evident and replayable.

Design

Decision N-1                    Decision N                      Decision N+1
┌────────────┐                 ┌────────────┐                 ┌────────────┐
│ plan_hash  │────prev_hash───▶│ plan_hash  │────prev_hash───▶│ plan_hash  │
│ prev_hash  │                 │ prev_hash  │                 │ prev_hash  │
│ timestamp  │                 │ timestamp  │                 │ timestamp  │
│ verdict    │                 │ verdict    │                 │ verdict    │
│ ...        │                 │ ...        │                 │ ...        │
└────────────┘                 └────────────┘                 └────────────┘

How It Works

Every decision produces a plan — the structured data representing what the agent decided
The plan is canonicalized (deterministic JSON serialization)
plan_hash = sha256(canonical(plan))
Each record links to the previous record's hash → hash chain
Any tampering breaks the chain — downstream hashes won't match

Record Fields

Field	Description
`plan_hash`	SHA-256 of the canonical decision plan
`prev_hash`	Link to the previous record (chain integrity)
`timestamp`	When the decision was made
`verdict`	`executed` or `declined`
`acted`	Boolean — did the agent take action?
`action`	`allocate`, `deallocate`, or `null` (stood still)
`reason`	Human-readable explanation of the decision
`net_edge`	The computed net-edge value at decision time
`tx`	Transaction signature (if acted)
`signal_receipt`	Pay.sh receipt (tx sig, amount, payee) if signals purchased

Replay Guarantee

Given the same inputs at the same point in time, the same plan_hash is reproduced. This means:

An auditor can take the recorded inputs and verify the agent's logic would produce the same output
If the plan_hash doesn't match on replay → something was tampered with
The hash chain prevents selective deletion or insertion of records

What Gets Recorded

Everything. Not just allocations:

Event	Recorded
Agent allocates into venue	✓ (with tx, amount, net_edge)
Agent deallocates from venue	✓ (with tx, amount)
Agent declines (net_edge ≤ 0)	✓ (with reason, computed costs)
Signal purchased	✓ (receipt attached to decision)

Storage

VDL records are stored per-chain, per-vault in the backend's data directory:

app/backend/data/
  history-solana-{vault_address}.json
  history-arc-{vault_address}.json
  history-giwa-{vault_address}.json

TEE Binding

When a decision runs inside an AWS Nitro Enclave, the plan_hash is bound to the attestation document:

Enclave produces plan_hash
  → plan_hash embedded in attestation user_data field
    → Attestation signed by AWS Nitro hardware
      → Anyone can verify: this plan came from this code on real hardware

API

The VDL is exposed via the backend API:

GET /api/ledger?chain=solana&wallet=...
→ Returns the decision history for that vault

Each entry includes the plan_hash, verdict, reason, and any associated transaction or signal receipt.

Net-Edge Gate TEE Attestation