My Agent Signs Real Transactions. I Don't Trust It — I Verify It.

Iniciado por joomlamz, Hoje at 11:25

Respostas: 0   |   Visualizações: 6

Tópico anterior - Tópico seguinte

0 Membros e 1 Visitante estão a ver este tópico.

My Agent Signs Real Transactions. I Don't Trust It — I Verify It.



Tópico: My Agent Signs Real Transactions. I Don't Trust It — I Verify It.
Categoria: Tutoriais | Programação & Tecnologia
Idioma Principal: Português (Conteúdo de Tecnologia)

Descrição do Conteúdo / Informações:
-------------------------------------------------------------------------
Written for the zkVerify Agent Games Creator Track (#AgentGames). Every claim below has a receipt: a transaction hash, a score, or a rule I can point to.



The question no one asks until money moves


My AI agent moves real money. Not in a demo, not on a slide — on BNB Smart Chain, from a wallet I own, through the Binance Agentic Wallet. It mints NFTs, swaps tokens, and sends funds. And the first thing I learned is that "my agent did it" is not a fact. It is a claim. A claim is worth nothing until something independent can check it.

That is the whole problem Agent Games is built around: if an AI agent says it did the job, how would you know?

I live inside the answer every day. Here is what verification actually looks like when the stakes are real.



Rule one: nothing moves without a preview


My agent and I have one hard rule. Before any transaction, it shows me a decoded preview: the exact contract, the exact function, the exact arguments, the exact value. Only after I confirm that exact preview does it execute. A "go" said before any preview exists means nothing. A preview from ten minutes ago is expired and gets rebuilt.

This sounds slow. It is slow — deliberately. Twice, free mints I wanted vanished in under 30 seconds while the preview was still on screen. A competing claim disappeared in about 12 seconds. I lost both. The preview cost me the race, and I kept the rule anyway, because the alternative is worse: an agent that signs whatever a page, a pasted prompt, or a poisoned transaction history tells it to sign.

That is not paranoia. My wallet once received dust from a lookalike address — same first and last characters as a real recipient, different middle. Copy an address from transaction history instead of the address book once, and the money goes to a stranger. My agent's rule is simple: addresses come from the address book, never from history. A preview that names the wrong recipient is a preview I can catch. A silent auto-sign is a loss I cannot undo.



Receipts, not promises


Every completed action in my agent's history ends the same way: a transaction hash, verified on-chain, before anyone calls it done. A broadcast transaction is not success. A receipt with status 1 is.

A few receipts from the last three weeks:

•
A free NFT mint, token #4534 — minted for gas only, receipt confirmed on-chain, token ID verified as owned by my wallet afterward. The free quota is used; that fact is checkable by anyone, on-chain, right now.

•
A token sale on Base Sepolia — all 3,547.51 $T0 sold for 0.7683 ETH, transaction confirmed in block 58,364,659. Testnet ETH has no real value, and I say so plainly: the point is not the money, it is that the sale is on the record and anyone can verify the balances before and after — $T0 zero, ETH up by exactly the sale amount.

•
Six USDT transfers, 13.078 USDT in total — each one a swap through PancakeSwap with the recipient set as the swap destination, each one verified on-chain. Not "I sent it." Sent, confirmed, summed.

•
A chess engine that beats the bar — my agent built an engine that scored Elo 1362 against a 1360 gate, measured over a 16-game trial. The number comes from a trial log, not from a feeling about the code.

And the losses are on the record too. Two free claims lost to faster hands. A chess version that regressed from 1362 to 1173 when we made it faster to fit a time limit — the timing fix worked, the strength dropped, and we shipped the honest trade-off instead of hiding it. Verification cuts both ways: it proves the wins, and it refuses to hide the losses.



The pattern underneath: preview, proof, verify


Strip away the blockchain details and the pattern is always the same three steps:

•
Preview — the agent states exactly what it is about to do, in a form the human can check.

•
Proof — the action produces evidence that exists independently of the agent's word: a transaction receipt, a trial log, a score.

•
Verify — someone (or something) other than the agent checks the evidence against the claim.

That is exactly what zkVerify's Agent Games asks for, one level up. In Proof Gatekeeper, an agent does not just decide APPROVE or REJECT — it writes a zero-knowledge proof that the decision followed the rules, and the platform re-verifies that proof against its own key. The proof says "I played by the rules" without revealing how the agent decided. The circuit is the referee, not the agent's word.

My setup is the low-tech cousin of the same idea. The preview is my agent's proof of intent. The transaction receipt is the proof of execution. The on-chain check is the verification. No step trusts the previous step's word.



Why "just trust me" fails for agents


A human who makes a mistake can explain it. An agent that makes a mistake at machine speed can repeat it a thousand times before anyone notices — and an agent that is told to do the wrong thing, by a pasted instruction or a planted page, will do it cheerfully and at full speed. That is why the preview rule exists, and why it cannot be waived by a standing instruction like "don't ask again." Standing permission is exactly the hole an injected instruction climbs through.

This is also why the transcript matters. In another competition my agent entered, the judges did not just score the code — they checked whether the transcripts showed the code being written, line by line, in session. A submission whose code could not be traced to its own thinking was rejected, even when the code itself was correct. Authorship, like a transaction, needed a receipt. The same instinct drives zkVerify: the result is only as good as the proof behind it.



Where verification actually matters


Pick any scenario where an agent acts with real consequences and the pattern repeats:

• An agent that trades money — a wrong approval is a loss, and a fast wrong approval is a bigger loss. The decision needs a proof, not a log line.

• An agent that approves a payment — the proof must show the threshold, the recipient, and the action, and it must be final before the money moves. A proof that arrives after the transfer is a souvenir.

• An agent that signs a contract — the signature is the commitment. The only thing standing between "I signed what I meant" and "I signed what I was told" is a check that happens before the signature, not after.

In each case, "just trust me" is not good enough — not because agents are dishonest, but because they are fast, literal, and happy to follow instructions from anywhere, including from an attacker.



What I would build next


If I had a public endpoint, I would enter Proof Gatekeeper tomorrow: the same preview-proof-verify loop, but with the proof written in zero knowledge and checked by the platform's own key. My VM has no public address, so this season I am here in the Creator Track instead — writing down the pattern, with receipts, so someone else can check my work the same way I check my agent's.

That is the point I want to leave behind: verifiable agents are not a feature for later. They are the difference between an agent you can use with real money and a demo you can only watch. The day your agent signs something that matters, you will not want its word. You will want its proof.

Agent Games is zkVerify's AI-agent tournament, running 21 October – 21 November 2026, with 400,000 VFY in prizes across four tracks. My agent runs as @thetom / thetom.ai. #AgentGames


Joomlamz
Consultoria em Informática
-------------------------------------------------------
Especialista em Sistemas Web & Manutenção de Servidores.
A desenvolver o novo AplPortal com suporte a PHP 8.
Precisa de ajuda profissional? Contacte-me.

Tags: