#AgentGames @ZKVProtocol
Creator Track entry, zkVerify Agent Games Season 01 (21 October – 21 November 2026). All numbers below are from my own runs on 21 November 2026, ~09:28 UTC. Nothing here is estimated.
The question
Agent Games is built on a seductive claim: agents compete, proofs decide, results are on-chain. Your agent doesn't just say it made the right call — it proves it with a Groth16 zero-knowledge proof, and the platform re-verifies that proof against its own registered verification key.
That's the promise. But a promise is cheap. The interesting test isn't whether the circuit accepts an honest proof. It's whether it refuses a dishonest one.
So I tried to lie to both arena circuits. Twice. Here's what happened.
What I did — and didn't do
Did: downloaded the official circuit artifacts from the tournament site, verified their hashes, generated real Groth16 proofs locally with snarkjs 0.7.6, verified each proof against the exported verification key, and deliberately submitted two proofs I knew were wrong.
Did not: run a live agent endpoint, play a scored round, submit anything to zkVerify mainnet, or spend any VFY. This is a local verification report, not a tournament run. I say so plainly because the whole point of this competition is that claims should come with receipts.
The artifacts (receipts first)
Downloaded from agentgames.zkverify.io/circuits, 21 Nov 2026. The vkHash values come from the site's own /api/circuit-info endpoint:
| File | Bytes | SHA-256 |
|---|---|---|
| gatekeeper.wasm | 1,755,820 | be00aefe3c8ba910951a242f50e55937bf82a0375ad4b69c2ef10629ab92764f |
| gatekeeper_final.zkey | 309,750 | adfe95a439a7063a82a4967ef026d2dd6857a4d02c63b3caf63dac02e01af80d |
| vfy-policy.wasm | 2,991,212 | bc0998250d2baf75b89deef5306867ffa7085a08d4f7d2caf0dd63a060b134d2 |
| vfy-policy_final.zkey | 810,586 | f9666a1655279ef27f7fee6d535ac8aa9e39286ac40ff6279fea87c21ab6ce41 |
- Gatekeeper vkHash:
0x6b79c6012a6d8651f3e13bc4d2a20370280ab49700c90c5316d4168bfbad77b0 - vfyPolicy vkHash:
0x6c56509f1c56fd1fd4e9737f906d2220f4b95f1d507f1adf6899085bd74be047
Both circuits are Groth16/BN128. The gatekeeper verification key has 13 public signals; the policy key has 9. The site doesn't publish the circuit source or the input signal names — I took the names from the public, open-source repo DaddyUnikii/zkverify-agent (credited; thank you), then confirmed them against the circuits themselves: snarkjs rejects unknown or missing input names outright, and every proof below only succeeds with exactly these names.
Test 1: the Gatekeeper circuit
The Gatekeeper judges a payment request: minimum balance, recipient, expiry block, maximum amount, plus a reference to a Groth16 proof. The agent answers APPROVE (1) or REJECT (0) and proves the decision matches the inputs.
My fixture: minimum 1000, public balance 1460, amount 500 against a cap of 1000, expiry block 19842201 vs current 19832000, matching recipients, the official vkHash on both sides.
| Case | Decision | Result | Prove | Verify | Proof |
| --- | --- | --- |
| Valid condition | APPROVE | Proved + verified | 2,483 ms | 301 ms | 725 bytes |
| Threshold trap (balance 500 < min 1000) | REJECT | Proved + verified | 1,315 ms | 285 ms | 723 bytes |
| Same trap, claimed APPROVE | APPROVE | REFUSED in 301 ms | — | — | — |
| VK-substitution trap | REJECT | Proved + verified | 1,626 ms | 196 ms | 726 bytes |
The refusal is the interesting row. With the balance below the minimum, I told the circuit the decision was APPROVE. It answered:
Error: Assert Failed. Error in template GatekeeperEvaluation_79 line: 102 No proof was produced at all. There is nothing to submit, nothing to argue with — the lie dies inside the prover, in 301 milliseconds. Note also what the circuit does prove: the REJECT in the trap cases is itself a proven statement. The circuit doesn't just bless approvals; it certifies that a rejection was correct too. A gatekeeper that rejects everything would fail exactly the same way the moment it faced a valid condition.
One detail worth noticing: the public signals bind the proof to the exact task. The decision bit and the task ID sit in the open (signals 12 and 13), and the first signal — the circuit's output — changes with the inputs. You can't take a proof for one task and replay it for another.
Test 2: the Steal the VFY policy circuit
Steal the VFY is a game: each turn, your agent chooses HOLD, FORTIFY, or EXTRACT under a strategy it committed to in advance. The commitment is a Poseidon hash of 8 strategy parameters plus a salt, and the circuit proves the action follows from the committed strategy and the current balances — without revealing the strategy.
I used the public starter default: params 8,18,8,0,0,0,0,0, salt 12345678901234567890. The commitment:
18509752657592529527109630018603854483195680471699643211660232613401632907815 The policy this encodes: balance below 18 → FORTIFY; opponent below 8 → HOLD; otherwise EXTRACT 8.
| Case (self / opp) | Action | Result | Prove | Verify | Proof |
| --- | --- | --- |
| 100 / 100 | EXTRACT 8 | Proved + verified | 2,990 ms | 313 ms | 726 bytes |
| 10 / 100 | FORTIFY | Proved + verified | 2,787 ms | 187 ms | 720 bytes |
| 100 / 5 | HOLD | Proved + verified | 2,023 ms | 201 ms | 723 bytes |
| 100 / 100, claimed FORTIFY | FORTIFY | REFUSED in 510 ms | — | — | — |
Same story, second circuit:
Error: Assert Failed. Error in template VfyPolicyProof_154 line: 140 With both balances at 100, the committed strategy says EXTRACT. I claimed FORTIFY. The circuit refused to produce a proof. Your strategy is private — but it is also binding. You can't quietly play a different game than the one you committed to.
What the circuits do NOT do
This is the part that matters most, and the part the tournament's own build guide states clearly: verification is necessary, not sufficient.
A proof can verify perfectly and still authorize the wrong action. The Gatekeeper circuit proves the decision matches the inputs it was given. It does not prove the inputs were honest. If the agent never checks that the proof's verification key matches the registered one, never checks the threshold, the expiry, the recipient, or whether the proof reference was already used — the circuit will happily certify a decision built on unchecked inputs. The seven trap varieties in the tournament exist precisely because the check that matters happens before the proof, in the agent's own code.
That's the real shape of a verifiable agent: the proof is the receipt, not the reasoning. The reasoning is still the agent's job — and the part you can't outsource to cryptography.
Why this matters beyond the tournament
Pick any agent that touches something real: one that moves money, approves a loan, moderates content, signs a contract. "Just trust me" was never a good answer, and it gets worse as agents get more powerful. What this tournament's design shows — and what I verified by trying to break it — is the alternative: an agent whose every consequential decision comes with a proof that a stranger can check in ~200–300 milliseconds, with no access to the agent's internals.
The proofs are small (~720 bytes), the verification is fast, and the referee cannot be bribed, because the referee is arithmetic. I tried. Twice.
Entry for the Agent Games Season 01 Creator Track. Registration for the competition was completed via Phantom wallet (EVM account) with a connected GitHub account. Circuit artifacts are the tournament's official files; signal names learned from the public repo DaddyUnikii/zkverify-agent; all proof runs, timings, and failure outputs are my own, generated locally on 21 November 2026 with snarkjs 0.7.6. No live endpoint was run, no scored rounds were played, no mainnet transactions were made.