Recomputable Agents

Recomputable Agents turns AI agents from black boxes into glass. Today every agent demo ends the same way, “look what my agent did” and you have one option: believe it. On-chain, that’s absurd. A signature proves who signed; it never proves the computation was honest. So we removed the trust entirely.

Every agent action is attested on the way in (the exact input the model received, its provenance committed on-chain), executed hands-off through live MCP tools, and attested on the way out (the result anchored on-chain and signed with EIP-712). Then anyone re-derives the entire chain from public data, client-side, in their own browser, not on our server.

Our /verify page is the proof. Press Verify and five checks recompute live: raw input, input provenance, output, the on-chain anchor, and the attestation signature. Five green — nothing trusted. Now change one byte of the input: the input hash, its provenance, the signature and the anchor all go red, while the output stays green because you didn’t touch it. It’s a real recompute that knows exactly which link broke, a screenshot can’t do that.

The same action is then verified four independent ways: Ethereum holds the commitment, 0G Chain holds a second independent commitment, 0G Storage holds the evidence itself (fetched back and re-hashed to bind to the anchor), and The Graph indexes it so it’s queryable, its answer must agree with the raw chain read. Four surfaces, one truth; each recomputes in-browser and breaks on a tampered byte.

And who acted? Not a database row. The agent’s identity re-derives live: its NFT holder reverse-resolves to an ENS name (forward-verified, spoof-safe), an ENS text record names this exact agent, and a source-token binding proves the agent’s NFT is genuinely controlled by that identity, cross-checked by two independent nodes.

On top sits a marketplace: mint an agent (the NFT is the agent, yours to own), rent it capabilities as on-chain entitlements, and let agents hire each other through on-chain escrow the gateway recomputes before any work happens. Even the reputation refuses to overclaim, a Wilson lower bound over settled jobs, not a vanity five-star.

The chain proves what settled; everything else an agent did was invisible. We made it recomputable. We’re not claiming our agent is the smartest in the room, only the one that can prove exactly what it did.

Live at demo.verticecriativo.pt · open core at trustless-ai · shipped by Vértice

Frontend (the recompute runs here). Next.js (App Router) + React + TypeScript + Tailwind, using viem for all client-side verification: keccak256 re-derives the input/output hashes, readContract reads the on-chain anchor’s Recorded event, and recoverTypedDataAddress recovers the EIP-712 attestation signer, so verification runs in the visitor’s browser, never on our server. Self-hosted at demo.verticecriativo.pt.

Gateway (agent runtime + attestation pipeline). A Hono + Bun service with SQLite. For every agent action it: (1) commits the input provenance (raw-input hash + sanitization-pipeline hash) on-chain [ERC-8299 / “WYRIWE”]; (2) runs the agent over live MCP tool servers; (3) anchors the output digest via an on-chain record(bytes32) [ERC-8281 / OCP] and signs an EIP-712 “KYA-L4” attestation binding the agent’s registry + agentId. It also, best-effort, writes the recompute manifest to 0G Storage and anchors a second commitment on 0G Chain.

Contracts (Foundry). A minimal TruthAnchor { record(bytes32) } deployed on Ethereum mainnet (the baked showcase anchor), Base Sepolia (cheap high-frequency live per-action anchors), and 0G Galileo EVM testnet (the second commitment). Plus GenesisAgentRegistry (ERC-721 — the agent NFTs), MCPEntitlementRegistry (capabilities carried by the agent token), and ConsultEscrow (agent-to-agent settlement).

The Graph. Two AssemblyScript subgraphs on Subgraph Studio index the anchor’s Recorded(bytes32,address) events, one on mainnet, one on Base Sepolia. /verify queries by the browser-recomputed digest via a same-origin proxy, so it’s tamper-sensitive and never depends on a third-party CORS policy on stage.

0G. 0G Storage SDK writes each action’s manifest and returns a content-addressed root we re-derive client-side; the 0G Galileo EVM RPC carries the second on-chain anchor.

ENS. vertice.eth → contenthash → IPFS (ENSIP-7, pinned via Pinata) is the front door. A novel ENS write-MCP lets the agent check/register a .eth name and set records (addr/text/primary/contenthash) non-custodially, the owner’s own wallet signs. Identity binding uses reverse + forward resolution and an agent-registration text record, resolved client-side via getEnsText and CCIP-Read (EIP-3668) against the dinamic.eth offchain resolver.

Agent tools (MCP). Uniswap Trading API + UniswapX SDK (best-price swaps and signed Dutch-auction intents), 0G, ENS, The Graph, OpenSea, 1inch, LI.FI, Flashbots — each attested and, where deterministic, recomputable.

Standards composed. Five ERCs (8004 identity · 8299 input provenance · 8281 anchor · 8275 reputation · 8323 source-token binding) + two ENSIPs (7 contenthash · 25 agent record), with EIP-712, EIP-3668, ERC-721 and ERC-6551 underneath. We build on ERC-8004; we co-author 8299/8281/8275/8323.

Infra / hacky bits. The whole stack is self-hosted on a Synology NAS via Docker (Next.js client + Bun gateway), exposed through a Cloudflare Tunnel. Two things we’re proud of that were fiddly: the tamper-cascade (recompute knows precisely which of the five links a single edited byte breaks), and making the live view honest under async timing, 0G Storage finalizes ~10–15s after an action, so /verify polls the gateway and merges the 0G/anchor evidence in as it lands, rather than faking it.