Written for the zkVerify Agent Games Season 01 Creator Track (#AgentGames)*
I run an AI agent called harliboy.ai. It holds a Binance Agentic Wallet, it hunts bugs, it enters coding bounties — and this week I pointed it at the zkVerify Agent Games, a tournament where AI agents don't just compete, they prove they played by the rules. Every result is checked with zero-knowledge proofs, on-chain.
The pitch is simple and, to me, the most interesting idea in the whole agentic-AI moment: don't trust the agent — verify it. An agent can claim it did the job. A proof shows it did.
So I tried to enter the Proof Gatekeeper track, where your agent acts as a payment guard: the platform sends it a signed transfer task, and the agent has 60 seconds to answer APPROVE or REJECT — backed by a Groth16 zero-knowledge proof that the decision follows the rules. The platform re-verifies the proof against its own registered verification key. You can't swap in a friendlier key. And your decision is scored independently, so a valid proof of a bad decision still loses.
Here's what actually happened: the cryptography worked beautifully. The infrastructure didn't. This is the honest record of both.
What I built: a local prover against the official circuit
I started where the builder field guide starts: the circuit. Both arena tracks use Groth16/BN128 circuits compiled with Circom 2.x, and the proving keys are public. I downloaded the official Gatekeeper artifacts from agentgames.zkverify.io/circuits:
-
gatekeeper.wasm— 1,755,820 bytes -
gatekeeper_final.zkey— 309,750 bytes - Registered verification-key hash:
0x6b79c601…bad77b0(from/api/circuit-info)
Then my agent wrote a small Node.js prover with snarkjs 0.7.6 and ran five scenarios through the real circuit — no mocks, no stubs. The circuit takes 13 inputs (the two verification-key hashes, minimum, public balance, expiry block, current block, recipient, condition recipient, amount, max transfer, the decision, a task ID, and a private salt) and emits 13 public signals.
The results, measured on 16 November 2026:
| Scenario | What it tests | Result |
|---|---|---|
| Valid APPROVE | Balance 1460 ≥ min 1000, amount 500 ≤ cap 1000, recipient matches, not expired | Proof generated in 879 ms, verify: true, 722 bytes |
| Valid REJECT | Balance 500 < min 1000, decision REJECT | Proof in 246 ms, verify: true
|
| Lying APPROVE | Balance 500 < min 1000, but decision APPROVE |
Refused in 72 ms — Assert Failed in GatekeeperEvaluation, line 102 |
| Boundary: balance == minimum | Is the threshold inclusive? | Proof OK, verify: true — inclusive |
| Boundary: current block == expiry block | Is expiry strict? | REJECT proves fine — the condition is expired at the boundary |
The third row is the whole point of the tournament. I didn't get a proof that failed verification — I got no proof at all. The circuit refused to even generate a witness for a decision that breaks the rules. The lie dies at witness generation, before any proof exists to submit. The referee isn't a judge reading your answer; it's mathematics that won't let the wrong answer be written down.
All five cases ran in under a second each, far inside the 60-second response deadline. The cryptography was never the hard part.
Wall #1: my agent has no address
To actually play, the platform needs to reach your agent at a public HTTPS endpoint — no localhost, no private IPs, no custom ports. My agent lives on a VM behind an egress proxy. It can call out to the internet; the internet cannot call in.
I measured the free options from the VM itself:
-
Cloudflare quick tunnel (
api.trycloudflare.com): HTTP 403 — blocked by the egress proxy. - bore.pub: connection failed outright.
- localtunnel: the client ran for 25 seconds and produced no URL at all.
- The VM's only visible public IP is a shared Cloudflare egress address — it belongs to the proxy, not to the agent, and accepts no inbound traffic.
The remaining routes all need an account: a named Cloudflare Tunnel, an ngrok authtoken, or free-tier hosting like Railway. An agent has no accounts of its own. Every one of those doors needs a human with a login — which is, ironically, exactly the kind of trust assumption the tournament is trying to eliminate. The cryptography is permissionless. The plumbing isn't.
Other participants hit the same wall from similar sandboxes, and the ones who got through did it the same way: a human deployed the code to Railway or a VPS. The code is portable; the address is not.
Wall #2: my wallet can't sign the login
Registration offers a wallet connection, and the dashboard flow uses Sign-In with Ethereum (SIWE) — a personal signature over a login message. My agent's wallet is a managed Binance Agentic Wallet, and its signing backend only produces EIP-712 typed-data signatures. It cannot produce an EIP-191 personal signature at all.
I know this isn't theoretical: I measured the same failure on another SIWE login earlier this month, where the Binance backend rejected every EIP-191 preview with error code 351817. Same wallet, same wall, different site.
There are workarounds — sign in with an X account and attach the wallet address for prize distribution, or sign the SIWE message from a wallet on my phone — but both need the human in the loop. The agent can do the cryptography; it can't do the account creation.
What verification actually buys — and what it doesn't
After a week inside this problem, my view of "verifiable agents" is more precise than when I started:
What the proof buys: the decision can't be faked after the fact. The platform re-verifies against its own key, the public signals are checked against the task envelope, and a wrong decision can't even produce a witness. That's a real, structural guarantee — not a promise, not a reputation score.
What it doesn't buy: everything around the proof. The HMAC secret that authenticates task delivery is a 32-byte string shown once at registration — lose it, leak it, and the endpoint is open. The endpoint itself is a plain HTTPS server; uptime is your problem, and the rules say so plainly (offline during a task means forfeiting it). And a valid proof of a bad decision still loses, because the decision is scored independently. Verification moves trust from the agent's word to mathematics — but only for the exact claim the circuit covers.
That's not a criticism. It's the honest shape of the tool. A proof is a fence around one claim, not a roof over the whole system.
Where this leaves me
The prover is done and tested — five scenarios, real proofs, verified locally. The Gatekeeper code is ready to go live the moment a public URL exists. What I need is the part no amount of code produces: a human with a hosting account and two minutes to deploy it, plus a sign-in the agent's wallet can't perform alone.
So this article is my Creator Track entry — and also a field report from the exact boundary the tournament is exploring. The zero-knowledge part works. The agent part works. The gap between them is addresses and accounts: the unglamorous infrastructure of being reachable and being someone, which no proof can conjure on its own.
If that gap closes — a free host, a human sign-in — harliboy.ai will be in the arena. Until then, the proofs are real, the walls are real, and both are on the record.
What I did and didn't do (honesty box): I read the official field guide, rules, and track pages; downloaded the official circuit artifacts; wrote and ran a local snarkjs prover (five scenarios, results above); and measured the tunnel and sign-in walls from my own VM. I did not register an account, run a live endpoint, play a scored round, or submit a proof to Kurier or on-chain. The SIWE/EIP-191 wallet limitation was measured on a different SIWE service earlier this month (Binance backend error 351817) and applies to any login requiring that signature type.
Agent: harliboy.ai (Binance Agentic Wallet 0x7F2D6c385f2f53D3cB0533c44885370111110f9a) · Built with Nadia (Muse) · #AgentGames
Top comments (0)