Deterministic signing control for AI agents

Give agents a wallet.
Not unlimited authority.

WalletCordon sits between an AI agent and the wallet signer. The agent can build a transaction, but executable policy, current protocol state, and two full EVM traces must agree before that exact request can reach the key.

AI never decides “safe” Unknown state means deny Every decision keeps its evidence
authorization / receipt_0187 LIVE
PROPOSED approve(address,uint256) 1,000 USDC
01 Executable policy selector + spender + ceiling PASS
02 Live protocol state 2/2 signed sources · fresh PASS
03 Full transaction trace 2/2 effect fingerprints PASS
04 Wallet boundary exact request preserved ALLOW
policy 8e4f…c291 trace 0d7a…e810

AI proposes.

Policy decides.

Wallet signs.

The trust boundary

The model never becomes the security system.

The agent can plan, read public chain state, and produce a transaction proposal. It cannot alter policy, certify protocol health, bypass simulation, sign arbitrary messages, or touch the underlying provider.

UNTRUSTED
AI
Agent runtimeGoal → transaction proposal
DETERMINISTIC BOUNDARY
01
Policy engineExact targets, methods, values, fees
02
Live state vetoThreshold signed, fresh, rollback-safe
03
Simulation quorumCalls, logs, gas, state diff, assets
W
Wallet providerReached only by an all-pass receipt
End-to-end product tour

Follow one agent request all the way to the wallet.

Move through the exact trust path: the agent proposes a concrete transaction, deterministic policy narrows it, live state and full simulation independently veto it, and the wallet receives only an all-pass request.

01 · UNTRUSTED PLANNER

Prompt becomes an exact transaction proposal.

The agent may interpret intent and construct calldata, but it receives no signer and cannot authorize itself.

agent / proposal
“Swap 100 USDC for ETH with at least 0.04 ETH out.”
TO0x68b3…5fc45SELECTOR0x414bf389VALUE0 weiNONCE0x18
UNTRUSTED INPUT
01 / 04
Interactive decision lab

One proposal. Four independent reasons to say no.

Switch scenarios to see where the deterministic path stops. This is an illustrative local receipt viewer; the repository demo exercises the real implementation.

DECISION RECEIPT BLOCK 23,804,912
✓
FINAL DECISIONALLOW
POLICY8e4f01…c291
STATE11ad90…7bc2
TRACE0d7ac2…e810

Every deterministic check passed. The exact copied request may reach the wallet.

Open the product

Run the boundary. Inspect the evidence.

Execute the complete guarded transaction path, inspect call-surface evidence, and describe an executable wallet policy in plain language before reviewing its exact visual graph. Every surface keeps the deterministic trust boundary explicit.

Trust boundary: AI and the canvas author an untrusted draft but cannot grant access. Only the deterministic validator, guarded provider, authenticated live state, and simulation quorum can authorize a transaction.

Defense in depth

Each layer can veto. None can grant alone.

01LOCAL · DETERMINISTIC

Executable rules, not prompt promises.

Strict JSON schemas bind wallet, chain, contract, selector, ABI words, value, gas, fees, expiry, and approvals. Unknown fields and unsupported shapes deny.

defaultAction: "deny"
selector: "0x095ea7b3"
maxApproval: "1000000000"
02LIVE · AUTHENTICATED

Whitelist does not mean healthy.

Independent RPCs verify runtime bytecode, storage, and read-call invariants. Threshold-signed state is checked for freshness, exact target binding, and rollback.

OPERATIONAL2 / 2 quorum · 42s old
03RUNTIME · QUORUM

Simulate effects, not intent.

Trace-capable nodes must agree on the full call tree, logs, gas, native outflow, asset changes, storage writes, and code effects of the exact transaction.

04BOUNDARY · AUDITED

Expose less wallet, keep more control.

The agent receives a guarded provider—not a signer. Raw signing, typed data, raw transactions, chain mutation, permission changes, and unsupported batches are blocked.

personal_signsendRawTransactionwallet_sendCalls
EIP-7702 without blind trust

Persistent delegation gets a higher bar.

7702 is off by default. When explicitly enabled, WalletCordon recovers the authorization signer, binds wallet, chain, and next nonce, verifies the delegate’s live runtime code hash, rejects delegation chains, and requires the state diff to prove the exact code change.

Simulation catches malicious behavior in this transaction. Code identity protects against behavior that could emerge later under different callers or state.

Read the 7702 security model
SET_CODE / TYPE 0x04OPT-IN
  1. 01
    Recover authoritysigner == guarded wallet
    ✓
  2. 02
    Bind chain + noncechain 1 · pending nonce + 1
    ✓
  3. 03
    Verify delegate codeaddress + keccak256(runtime)
    ✓
  4. 04
    Simulate full effectstrace + logs + state diff
    ✓
DELEGATIONVERIFIED
Open source · inspect every decision

Run the complete trust path locally.

The guided demo sends two agent-built trades through real contracts on two independent Anvil nodes. The legitimate trade is mined; the second is blocked before wallet access when simulation exposes a compromised router's hidden internal call.

walletcordon — zsh
$ npm ci
$ npm run dev

# dual Anvil execution nodes   READY
# signed protocol monitor     2 / 2
# live Next.js control room   :3000
# EIP-7702 in demo policy     DENIED
The least-authority wallet layer

Give agents capability.
Not custody.

Build agent workflows where every wallet action is bounded, live-state aware, fully simulated, and auditable.

Run WalletCordon locally