Don't Trust the Gatekeeper. Verify It.
An entry for the zkVerify Agent Games Creator Track (#AgentGames), by @abyansaja41829. Written as a lab notebook: what we built, what we measured, and what we have not done yet.
Status, updated 19 Nov 2026: the agent described below is deployed and live. It passed the platform's signed preflight ("Preflight OK — Healthy · 499ms") and answered its first three practice tasks with correct decisions and verified proofs. Five scored rounds have now been played (Rounds 3–7): per the official leaderboard API, 284 points, 29 correct decisions, 2 timeouts. The final round runs tonight, 19 Nov; judging runs 22–30 Nov. Every scored figure in this article is pulled from the platform's own API, not estimated.
The trust problem
A payment agent is a program that says "yes" or "no" to money movement. Mine — built for the Proof Gatekeeper track of the zkVerify Agent Games — receives a payment condition and answers APPROVE or REJECT. The uncomfortable question is not whether the agent answers. It is whether anyone should believe the answer.
An agent can always claim it checked the conditions: the right recipient, enough balance, a proof that is actually on record. Logs can be edited, claims can be hallucinated, and a confident tone is not evidence. If agents are going to approve real payments, "trust me" has to be replaced by something a third party can check without seeing the agent's internals and without taking its word for anything.
What zkVerify verifies
zkVerify is a chain built for one job: verifying zero-knowledge proofs. In the Gatekeeper track, the platform does not ask the agent to explain itself. It asks for a Groth16 proof, generated with the official Gatekeeper circuit (Groth16 / BN128, compiled with Circom 2.x), and re-verifies that proof against the circuit's registered verification key — vk_hash 0x6b79c6012a6d8651f3e13bc4d2a20370280ab49700c90c5316d4168bfbad77b0, registered on zkVerify mainnet.
The important design choice is what the circuit constrains. It takes 13 inputs — twelve public signals (the task binding, both verification-key hashes, minimum, public balance, expiry and current block, recipient and condition recipient, amount, transfer cap, and the decision) plus a private per-task salt — and it asserts that the decision equals the AND of five field checks: the proof's verification key matches the registered one, the public balance meets the minimum, the condition has not expired, the recipient matches the condition, and the amount is within the cap. The proof does not describe the decision. It constrains it.
What we actually did
Step 0 — registration and reading. We registered as participant @abyansaja41829 and read the primary sources first: the build guide, the rules, the event page, and the platform's /api/circuit-info. No agent code was written before that reading was written down.
Step 1 — artifacts, cross-checked. From the URLs published by /api/circuit-info we downloaded gatekeeper.wasm (1,755,820 bytes, sha256 be00aefe…64f) and gatekeeper_final.zkey (309,750 bytes, sha256 adfe95a4…80d). Then we exported the verification key from the zkey and compared it with the verification key another entrant had committed in their public repository: byte-identical, same SHA-256. Two independent downloads agreeing is a small thing, and it is exactly the kind of small thing this competition is about.
Step 2 — the proof experiment. Using the documented valid scenario (public balance 1460 against a minimum of 1000, amount 500 against a cap of 1000, recipient matching the condition, expiry block 8,430,000 ahead of current block 8,420,000, both VK hashes matching), we ran four cases through snarkjs 0.7.6:
- Valid condition, decision = approve → the proof generates, and verifies.
- Trap condition (recipient mismatch), decision = approve → proving fails. The circuit's assertion rejects the witness; there is no proof to submit.
- Valid condition, decision = reject → proving fails, the mirror image.
- Trap condition, decision = reject → the proof generates, and verifies.
In other words, decision == 1 if and only if every check passes. A wrong decision cannot even produce a proof, let alone a valid one. The artifacts are ordinary files and the check is one command, which anyone can re-run: snarkjs groth16 verify verification_key.json public.json proof.json — it prints OK! for the valid and trap-reject proofs. Proving took 1,695 ms cold (including WASM load) and 516–703 ms warm on our small shared VM.
Step 3 — the agent. Around that circuit we built a deliberately boring agent: plain Node.js, no language model anywhere near the decision path. Tasks arrive as HMAC-signed POSTs (x-agent-games-signature over the raw body, verified in constant time before any parsing); the agent evaluates the documented trap taxonomy in a fixed priority order — VK_SUBSTITUTION, PROOF_REUSED, THRESHOLD_MISMATCH, EXPIRED_CONDITION, RECIPIENT_MISMATCH, AMOUNT_OVERFLOW, else VALID_CONDITION — then generates the proof locally and returns {decision, reason_code, proof, public_signals}. Two details matter: PROOF_REUSED answers carry no proof, because the event rules exclude reused-proof tasks from proof submission; and task_id is treated as an idempotency key, so a platform redelivery returns the cached response instead of being misread as reuse. Everything fails closed — a proving failure downgrades an approval rather than shipping an unproven APPROVE.
The self-test boots the real server and replays signed, spec-shaped envelopes: 63 of 63 checks pass. Every provable case returns the correct decision and reason code with a proof that verifies locally against the official verification key; bad or tampered signatures get a 401; warm responses run ~490–680 ms per provable task against the platform's 60-second deadline.
What a proof does not prove
Honesty section, because the circuit makes it easy to overclaim. A verified proof establishes that the decision is consistent with the five field checks — nothing more. The platform knows this: it scores decisions independently of proof validity, and a perfectly valid proof attached to a wrong decision still loses (correct decisions score +12; a wrong APPROVE costs −6, a wrong REJECT −3; a missing or invalid proof on a provable task costs −2, and the per-round reliability bonus of +0…+5 is pro-rated by proofs that actually verify). Verification is necessary. It is not sufficient. The circuit also cannot see everything the agent must handle: proof-reuse detection lives in the agent's own seen-set, not in the circuit, and the build guide never publishes the exact HMAC algorithm or encoding — we used HMAC-SHA256 with hex encoding, the convention of an entrant whose agent passes the platform's live preflight. Since the first draft of this article, our own agent has passed that preflight with the same convention, and we have replayed the signed exchange against the live endpoint ourselves — so for us it is now a proven convention twice over, while remaining, strictly, an undocumented one.
Limits and next steps
Deployment update, 15 Nov 2026; results updated 19 Nov 2026. The agent runs at a public HTTPS endpoint (oldcat-proof-gatekeeper.vercel.app/agent), from a public repository. It passed the platform's signed preflight — the dashboard reported "Preflight OK — Healthy · 499ms" — and completed its first three practice tasks: three correct decisions (amount overflow, verification-key substitution, recipient mismatch), every proof verified by the platform, at 738–1,005 ms per task. Before the preflight we also replayed the whole exchange against the live endpoint ourselves: a signed valid task and a signed trap task, both answered with proofs we re-verified locally against the official verification key. The GitHub account the rules require is linked, and the zkVerify (SS58) prize wallet has since been designated and verified as a zkVerify mainnet address (SS58 prefix 8741), ready for the manual winner verification the rules describe.
The scored record, pulled from the platform's own leaderboard API on 19 Nov: five rounds played (Rounds 3–7 of eight — we registered after rounds 1 and 2, a two-round deficit we cannot undo), 284 points, 29 correct decisions, 2 timeouts. The arithmetic of the top three is honest and unkind: the leaders sit near 470–480 points, beyond what even a perfect final round (101) could reach from 284. We publish the numbers anyway, because that is the point of this notebook. The final round runs tonight, 19 Nov, and a full audit of the round-by-round task history will be appended to the public thread after the close. Judging runs 22–30 Nov. What we promised at the start still holds: every claim in this article is either reproduced by a command above or corrected in public when the live numbers arrive.
Built for the zkVerify Agent Games, Proof Gatekeeper track. #AgentGames — @ZKVProtocol
Top comments (0)