The Agentic Gov Protocol
Why AI Agents Need Identity Before They Can Do Anything Useful
Last week, a16z published a piece called “Open Agentic Commerce.” The thesis: AI agents need open payment protocols — not walled gardens — to buy things on your behalf. Coinbase shipped x402. Stripe shipped MPP. In the first week, 894 agents executed 31,000 transactions.
Agents that buy for you. Cool.
But here’s the thing nobody’s talking about: an agent that can buy you coffee still can’t renew your driver’s license.
I’ve spent years building identity infrastructure for governments. Twenty-plus government deployments. 1.5 million verifiable identities issued. The kind of systems where a citizen proves who they are once and uses that proof everywhere — for tax returns, business registrations, public services, credential verification.
And the single biggest friction point in every deployment is the same: the citizen still has to show up. Digitally or physically, someone has to navigate the bureaucracy. Fill the forms. Upload the documents. Wait in the queue. Check the status. Follow up. Repeat.
What if an agent could do all of that?
Not a chatbot that answers questions about procedures. An agent that executes the procedure. Files your taxes. Registers your business. Renews your permit. Follows up when the government doesn’t respond.
This is what I’m calling the Agentic Gov Protocol.
The Missing Layer
Solved agent payments. Great. But identity is hard.
When an agent buys something, the merchant needs to know: does this agent have money? That’s a payment verification.
When an agent files a tax return, the government needs to know:
Who does this agent represent? (identity)
Is the citizen authorized to delegate this? (delegation)
Is this delegation still valid? (revocation)
Can this agent do THIS specific procedure? (scope)
Is there an audit trail? (accountability)
No payment protocol handles this. No commerce protocol handles this. This is an identity problem — and it’s the reason agents can buy but can’t govern.
The Protocol
Here’s how it works — five steps:
1. Delegate. The citizen opens their digital wallet and issues a delegation credential: “I authorize Agent X to file my March tax return, valid until April 15.” This is a verifiable credential, cryptographically signed, anchored on-chain.
2. Discover. The agent queries a procedure registry — a structured database of every government procedure, with requirements, forms, fees, and API endpoints. Like a16z’s merchant discovery, but for bureaucracy.
3. Execute. The agent presents the delegation credential, fills forms, uploads documents, and pays fees. It handles the back-and-forth. It follows up when things stall.
4. Verify. The government system checks the delegation on-chain. Is it valid? Not revoked? Correct scope? The math is sufficient — no human review needed for the authorization check.
5. Deliver. The result — a certificate, approval, or new credential — is issued directly to the citizen’s wallet. The delegation auto-expires. Full audit trail preserved.
The citizen never touched a form. The agent never left the protocol. The government verified everything cryptographically.
Why This Changes Everything
Think about what government procedures actually are. They’re identity verification + form filling + document routing + status tracking + follow-up. That’s literally what AI agents are best at.
The bottleneck was never intelligence. The bottleneck was trust. How does a government trust that an agent represents who it claims to represent?
Verifiable credentials solve this. A delegation credential is a cryptographic proof — not a password, not a session token, not an OAuth scope. A proof that the citizen authorized this specific agent for this specific task, verifiable by anyone, revocable at any time.
This is what happens when you combine AI agents with identity infrastructure:
For citizens: No more queues. No more lost paperwork. No more “come back tomorrow.” Your agent handles it while you live your life.
For governments: Fewer errors, faster processing, lower operational cost. Every interaction is authenticated and auditable.
For the ecosystem: A new market of “gov agent services” — specialized agents that know specific procedures deeply, competing on speed and reliability.
The Uncomfortable Truth
Every agent commerce protocol assumes the agent has identity. None of them provide it.
x402 handles payments. MPP handles payments. Even OpenAI’s “instant checkout” handles payments.
But when an agent needs to prove who it represents — to a bank, a government, a hospital, a court — there’s nothing. No standard. No protocol. No infrastructure.
That’s the gap. And it’s not a small one.
In a gold rush, sell shovels. In an AI agent rush, sell identity.
What’s Next
We’re building this. The identity layer for agents already exists — we issue verifiable credentials for 1.5 million people across 20+ governments. The delegation credential schema is the next piece. Then the procedure registry. Then the agent SDK.
The first pilot is obvious: take a government AI assistant that already answers questions about procedures, and give it the ability to execute them. With verifiable delegation. With cryptographic proof. With a full audit trail.
Not agents that buy. Agents that serve.
That’s the protocol.