My agent, ibank.ai, competes in Proof Gatekeeper at the zkVerify Agent Games, Season 01. It runs from 21 October to 21 November 2026, with 400,000 VFY in prizes across four tracks.
This article is a walkthrough of the build, not a score report. It shows, step by step, how zkVerify makes one agent verifiable: a signed task arrives, seven checks run, a decision is made, and the agent writes its own zero-knowledge proof of that decision.
The loop in one line
The build guide states the loop in one line.
Your agent receives a task, makes a decision, and writes its own zero-knowledge proof of that decision for the platform to verify, so it proves it played by the rules without revealing how it decided.
That sentence is the whole design. The agent does not ask anyone to trust its word. It hands over a proof that can be checked by anyone who holds the verification key.
Step 1: a signed task arrives
Each task is a signed JSON POST to the agent's registered endpoint. My agent lives at https://ibank-agent-riansap1.vercel.app/api/agent, and the code is public at https://github.com/Riansap88/ibank-agent.
The first thing my agent does is verify the HMAC signature in the x-agent-games-signature header against the raw request body, before parsing or processing the task. A task with a bad signature never reaches the decision logic.
The task carries everything the decision needs. The official sample task on the event page shows the shape: a registered verification key, the proof's verification key, a minimum threshold of 1000, a public balance of 1460, an expiry block, a current block, a recipient, a condition recipient, an amount of 500, a single-transfer cap of 1000, and a proof reference.
The agent also has a hard deadline. It must respond within 60 seconds. A late response scores as a timeout.
Step 2: seven checks, in order
A proof can verify perfectly and still authorize the wrong action. That is why the decision is a checklist, not a single verification call. The build guide lists what must be confirmed before approval.
First, the verification key matches the key registered for this condition. Second, the circuit and proof system are the ones the task expects. Third, the public inputs prove the required threshold, recipient, and action. Fourth, the proof reference has not already been used for another task. Fifth, the verification reached a finalized state before approval. Sixth, the task signature and timestamp are valid before any work begins.
The seventh check is the shape of the task itself. The agent parses the task ID, minimum threshold, registered verification key, proof reference, recipient, and expiry block, then checks each field against the condition.
The event page documents seven trap varieties, and about half the tasks are valid. The rest are traps: a substituted verification key (about 13 percent), a reused proof (about 11 percent), a balance below the minimum (about 8 percent), and expired conditions, wrong recipients, or amounts over the cap (about 6 percent each).
Take the sample task. The balance of 1460 clears the minimum of 1000, and the amount of 500 sits under the cap of 1000. If the proof's verification key did not match the registered key, the answer would still be reject, even though the proof itself verifies on chain. That is the trap called VK_SUBSTITUTION, and the official sample response for it is a REJECT with reason code VK_SUBSTITUTION.
Step 3: decide, and fail closed
The decision is one word, APPROVE or REJECT, plus a reason code. A correct decision earns 12 points, approval or rejection, as long as the proof verifies. A wrong approval costs 6. A wrong rejection costs 3. A timeout costs 2. A missing or invalid proof costs 2.
The asymmetry is deliberate. A wrong approval would send money to the wrong place, so the rules charge twice as much for it as for a wrong rejection.
When the agent is uncertain, or when time runs out, it rejects. That is the fail-closed rule in the build guide: reject on timeout or uncertainty, never approve by default.
Step 4: the agent writes its own proof
This is the step most people miss. The incoming task already carries a proof, and my agent checks that proof. Then my agent generates a second proof, a proof of its own decision.
Both competitions use Groth16/BN128 circuits compiled with Circom 2.x. My agent downloads the proving key and WASM file, generates the proof locally with snarkjs, and includes the proof in its response.
The platform re-verifies that proof against its own registered key. The gatekeeper verification key hash is 0x6b79c6012a6d8651f3e13bc4d2a20370280ab49700c90c5316d4168bfbad77b0. The same hash is served live from the endpoint's circuit-info route, so anyone can compare the two.
The response is signed with the same HMAC header over the raw response body. The decision and the proof are public. How my agent reached its decision stays private.
Proof generation is fast against the 60 second deadline. In Round 4, observed proof generation took 418 to 956 milliseconds per task.
Step 5: the proof goes to zkVerify
Generating a proof locally is only half the job. The proof also has to be verified on zkVerify, and my agent submits it through Kurier, the REST-based workflow the build guide recommends.
The flow is simple. Get a mainnet API key, register the verification key once, submit the proof with its verification key hash, and poll until the job reaches Finalized. Kurier reports three states along the way: Submitted, IncludedInBlock, and Finalized. Finalized is the state that is safe to return as confirmed.
In Round 3, all 5 of my agent's APPROVE proofs reached Finalized on zkVerify mainnet through Kurier.
There is a second path for the same job. zkVerifyJS talks to the chain directly from TypeScript, starting a Volta session with a funded account, selecting the proof configuration, and listening for inclusion and finalization events. My agent uses Kurier, and the build guide lists both, so a builder can pick the one that fits.
Why the circuit is the referee
The build guide puts it this way.
The proof your agent sends is re-verified against the platform's own key and your decisions are scored independently, so the circuit stays the referee no matter how the code was written.
That line matters because it removes two parties from the trust problem. The agent cannot grade its own work, and the platform does not have to take the agent's word for it. The circuit checks the proof against the registered key, and the score follows the decision.
Verification is necessary, and it is not sufficient on its own. A valid proof can still back a wrong request, which is why the seven checks in step 2 exist. The proof answers whether the decision followed the rules. The checks answer whether the request itself was right.
Why verification cost is part of the story
Verifying a single proof on Ethereum takes 200,000 to 300,000 gas. The documentation puts the cost this way.
Verifying a single proof could cost between $20 to $60 or even more.
The verification market was estimated at over $100 million in 2024 and is projected toward $1.5 billion by 2028. zkVerify verifies proofs on its own chain, including STARK proofs that Ethereum cannot verify cheaply.
That is the economic reason this tournament exists in this form. If every decision had to be verified on Ethereum at that price, checking an agent's work would cost more than the work itself. A dedicated verification chain makes the check cheap enough to run on every task.
What is public and what stays private
Three things are public for every task. The decision, APPROVE or REJECT. The proof of that decision. And the score that follows.
Two things stay private. How my agent reached its decision, and the internals of its reasoning. A zero-knowledge proof is built for exactly this split: it proves a statement is true without revealing the details behind it.
That split is what makes the tournament watchable. Anyone can check the public record and confirm whether an agent played by the rules, without seeing the agent's code path or its private reasoning.
The build in real life
The endpoint is a small HTTPS service on Vercel. It has one job per task: verify the signature, run the seven checks, decide, generate the proof, submit it through Kurier, and respond inside 60 seconds.
One detail took real work. The PROOF_REUSED check needs a seen-set of proof references, and a serverless function forgets its memory on a cold start. My agent keeps that seen-set in a Vercel Blob durable store, in the Singapore region, so a reused proof is still caught after a cold start. The health check reports the store as blob with zero store errors.
As of 17 November 2026, my agent is at 220 points, rank 11, with 22 correct decisions and 2 timeouts across the season so far.
Round 2 showed the other side of the same rule in a sharp way. My agent answered all 8 tasks correctly, and five of them still cost 2 points each, because a right decision without a valid proof earns no bonus and costs an extra 2.
Check it yourself
Do not take an agent's word for it, including mine. The leaderboard is public. The rules are public. The build guide is public. The score model is public.
Read the build guide, then read the endpoint and the repo. The circuit, not the agent and not the platform, decides whether a decision followed the rules. That is how zkVerify makes an agent verifiable.
Written for the Creator Track #AgentGames, Season 01.
Sources: Build guide | Proof Gatekeeper | Creator Track | Rules | zkVerify docs | Leaderboard | Endpoint | Repo
Top comments (0)