跳到正文
DEV Community· Juy·· 14 小時前AI 評分40

我試圖欺騙 Agent Games 的兩個賽事電路,兩者都拒絕了

I Tried to Lie to Both Agent Games Circuits. Both Said No.

AI 導讀

作者在本地向 Agent Games 的 Gatekeeper 和 Steal the VFY policy 電路提交故意錯誤的決策,兩者均拒絕產生證明。測試中,符合條件的決策及正確拒絕都成功生成並驗證 Groth16 證明。這是本地驗證測試,並非實際賽事回合,也沒有提交至 zkVerify 主網或使用 VFY。

正文

#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.

來源:DEV Community · dev.to