A jargon-light primer for compliance officers, hedge fund operations leads, and DeFi treasury managers. What these three primitives solve, why they belong together, and how to evaluate them in 30 minutes.
You give an AI agent authority to act on your behalf. The agent acts. Maybe it bought a $50,000 bond contract. Maybe it rebalanced your DeFi treasury. Maybe it pulled a research dataset for $0.50.
Who actually signed it? Can you revoke that signature without revoking every signature the agent ever made? Can you audit it in eighteen months when compliance asks? Can you tell another platform "this is my agent, here's its scope" without giving them custody of anything?
This primer is about the three primitives that make those questions answerable.
ERC-8004 is a draft Ethereum standard that defines a passport for an autonomous agent: a tamper-resistant record linking the agent's cryptographic identity to a human or organisational operator. The operator can revoke the passport, scope what it's allowed to do, and prove (to a counterparty, regulator, or auditor) that the agent's actions were authorised at the time they were taken. Think of it as a signed permission slip that the agent carries with it — different from a session token because it's revocable independently of the underlying account, and different from a smart-contract allowlist because it travels with the agent across platforms.
The HTTP standard reserves status code 402 Payment Required but never defined what should be in the body. x402 fills that gap: when an agent calls an API that costs money, the server responds with payment requirements; the agent attaches an X-402-Payment header with proof of payment (a USDC transaction hash, an ecash token, a Lightning preimage), and the call proceeds. The agent never holds a credit card or a long-lived API key. Payment happens at the granularity of a single HTTP request — sometimes for fractions of a cent — which makes pay-as-you-go agent infrastructure economically feasible for the first time.
A zero-knowledge proof lets an agent prove a fact without revealing the data behind it. The agent can prove "I am authorised to trade on behalf of Operator X" without revealing Operator X's identity to a counterparty. It can prove "I am compliant with jurisdiction Y's transfer limit" without revealing the actual transfer amount. You get to keep the audit trail without leaking the data that makes the trail damaging. Crucially for treasury and compliance teams, this isn't theoretical anymore — production SDKs exist that emit proofs in tens of milliseconds.
Why these three belong together. ERC-8004 says who the agent is. x402 says how they pay. ZK proofs say what they can prove without leaking the rest. Pick any two and the third becomes the load-bearing weak point. Pick all three and you have an agent that can transact on the open web with the same auditability your treasury team expects from a bank statement — and with revocability your bank account doesn't actually offer.
If you've authorised agents to act on your behalf before, you've probably used one of these patterns:
| Approach | Auditable | Revocable per-agent | Cross-platform | ZK-compatible |
|---|---|---|---|---|
| Long-lived OAuth token | Partial | No | No | No |
| AWS IAM role | Yes | Yes | No (AWS-bound) | No |
| Smart-contract allowlist | Yes | Yes | No (chain-bound) | No |
| ERC-8004 + x402 + ZK | Yes | Yes | Yes | Yes |
OAuth tokens and IAM roles work fine when all your agents live on infrastructure you control. The moment an agent has to transact across platforms — say, your hedge-fund agent placing trades on three exchanges, or your compliance agent pulling data from four sanctioned-list providers — the surface area gets uncomfortable: every platform wants its own credential, none of them know about each other's revocations, and you're one breach away from a fan-out incident.
Smart-contract allowlists fix the cross-platform part but only inside one chain. ERC-8004 + x402 + ZK is the first design where the agent itself carries the identity, the payment ability, and the privacy primitives — the platforms don't need to coordinate.
You're a compliance officer at a regulated brokerage. Your firm runs twelve AI agents that draft client communications, prioritise inbound research, and triage trade tickets. A regulator asks: "For each action this agent took between Q1 and Q3, who authorised it, on what basis, and when was that authorisation revoked?"
Without this stack: you sift through CloudWatch, Splunk, and three internal logs. You build a spreadsheet. You hope nobody changed an IAM policy mid-quarter without writing it down.
With this stack: each agent's actions emit a ProofOfDelegation chained to a single ERC-8004 passport. Querying the proof log returns: the operator who authorised, the cryptographic timestamp, the scope of authority, and whether revocation happened (and when, and by whom). The output is a single signed file that can be handed to the regulator without engineering ceremony.
You operate a quantitative fund. You run a hundred specialised agents — market scanners, news classifiers, signal generators, execution agents — all transacting through a single corporate treasury wallet. One of those agents gets compromised. Maybe a model was prompt-injected. Maybe a vendor's SDK got backdoored.
Without this stack: revoking that one agent means rotating the whole wallet, redeploying every other agent with the new credentials, and explaining the operational pause to your investors.
With this stack: the compromised agent's ERC-8004 passport is revoked. Its scope (and only its scope) goes dark immediately. The other ninety-nine continue operating with their own passports and their own per-call x402 payment proofs. The blast radius is one agent, not one wallet.
You manage a DAO treasury. The DAO has voted to authorise an agent to rebalance the treasury within risk bands, but the vote needs to remain enforceable — the agent shouldn't be able to do anything outside the bands even if the codebase changes upstream.
Without this stack: the agent runs from a multisig with manual approval steps for any non-trivial action; the "automated" part is mostly theatre.
With this stack: the agent's passport scope encodes the risk bands as enforceable predicates. A ZK proof attached to each rebalance proves the action is within bounds without revealing the position sizes to the public mempool. The DAO gets enforceable automation without giving away its trading strategy.
You don't need to deploy anything. Browse the service catalog, pick one of the 10 endpoints, copy the sample curl with the X-402-Payment header, and run it. The whole cycle — payment, response, proof emission — happens in under a second.
If you'd rather start with the discovery JSON:
curl https://craigmbrown.com/.well-known/agent-services.jsonIf you'd rather see the on-chain treasury before you commit anything:
curl https://api.craigmbrown.com/a2a/treasury/balancesIf you'd rather email a human: [email protected]. We answer.
What we are not. BlindOracle is not a wallet, not an exchange, not a custodian. We don't hold your funds. We're the identity, payment, and audit layer that lets your agents transact safely on the open web. If you need custody, use Coinbase Prime or Fireblocks. If you need a model, use Anthropic or OpenAI. We sit between them.
The three primitives in this primer are independent of BlindOracle. ERC-8004 is a public Ethereum standard. x402 is being shepherded by Coinbase and is openly specified. Zero-knowledge proof SDKs are open source from Midnight, Polygon, RISC Zero, and others. You can build this stack yourself if you want to. We've already built it, and our prices for the equivalent compute are public on the service catalog.
What we'd want to know in your seat: is this stack mature enough to put real money through?
Our answer is calibrated: yes for sub-$10K daily volume against verifiable on-chain destinations; yes-with-monitoring for $10K–$100K daily; not-yet-at-scale for the volume a tier-1 brokerage runs. Live treasury is on BaseScan. We publish a MASSAT security audit. You can verify everything we claim before you wire a dollar.