Why an ordinary log is not enough
A log entry says what happened. It does not prove that the entry is the one written at the time. If a vendor, an employee or an attacker changes a row later, a reader has no way to tell. In a dispute, that turns the log into one party's word against another's.
Digital signatures exist for exactly this problem. The US standard for them, NIST's FIPS 186-5, says signatures are used to detect unauthorized changes to data and to confirm who signed it [2]. It adds that the person receiving signed data can use the signature as evidence, showing a third party that the claimed signer really produced it [2]. That property is called non-repudiation: the signer cannot easily deny the signature later [2].
Apply that to agents. If each decision about a payment is signed when it is made, a later edit breaks the signature. A reader does not need to trust the log keeper. They only need to trust the signer's key and check the maths. That is the whole idea behind signed agent decisions.
What a decision record should hold
A useful record answers the questions people actually ask after the fact. Which agent made the request? Which seller and which resource was it for? What amount, in which token, on which network? What was the outcome: allowed, sent to the owner, or blocked? Which rule decided? And when?
Keep each field explicit. A record that says the payment was blocked because of a rule is only useful if the rule has a stable name. A record that names an amount is only useful if it also names the token and the chain, because the same number means very different things on different assets.
Record refusals as carefully as approvals. Refused requests show when an agent is being probed or when a rule is too strict, and they are often the first sign that something is wrong.
Think about who reads signed agent decisions later. It is rarely the engineer who built the agent. It is an accountant closing the month, an auditor sampling payments, or a founder answering a customer. Write field names they would understand without a manual, and keep the format stable, because a record that changes shape every release is hard to check years later.
Why EIP-712 typed data fits
EIP-712 is the Ethereum standard for hashing and signing structured data rather than plain strings of bytes [1]. Its authors point out that signed messages used to be shown to people as opaque hex with little context [1]. Typed data lets a wallet or a reader see named fields, such as agent, seller, amount and outcome, before anything is signed or checked.
The signed bytes are built from a fixed prefix, a domain separator and the hash of the message itself [1]. The domain separator is a 32-byte value made from fields like a name, a version, a chain id and a verifying contract [1]. Its job is separation: a signature made for one application and version should not be mistaken for one made for another. The standard notes that signatures from different versions are not compatible [1].
There is one thing EIP-712 leaves out on purpose. The standard says it does not include replay protection, and that applications must decide what happens when the same signed message is seen twice [1]. For a decision record that is fine, because the record is evidence, not a key that unlocks money. For anything that moves funds, it matters a great deal.
How to verify a record yourself, offline
You need three things: the record, its signature and the signer's published address. Rebuild the typed data exactly as it was signed, compute its digest, and recover the address that produced the signature. The ethereum.org account docs explain why this works: anyone holding a signature can derive the signer's public key from it, which proves who wrote the message [5]. An Ethereum address is the last 20 bytes of the Keccak-256 hash of that public key [5].
Libraries in most languages do the recovery for you, and none of it needs a network connection. On chain, Solidity's ecrecover does the same job, and it returns the zero address when the signature is malformed [4]. So treat a recovered zero address as a failure, never as a match. If the recovered address equals the published signer, the record is intact. If one field was changed, even by one character, you will recover a different address.
Two edge cases are worth knowing. If the signer is a smart contract rather than a plain key, there is no private key to recover. EIP-1271 defines an isValidSignature function that a contract answers with the magic value 0x1626ba7e when a signature is valid [3]. And the Solidity docs warn that a valid signature can be turned into a different valid signature without the private key [4]. Never use the signature bytes as a unique id for a record.
What a signature proves, and what it does not
A valid signature proves that whoever holds the signing key signed these exact fields. That is all. It does not prove the decision was wise, that the rule was the right one, or that the agent obeyed the answer it got. An agent that ignores a block still has a signed record saying it was blocked, which is useful evidence, but the money may have moved anyway.
It also does not prove a payment happened. For that, check the transaction on the blockchain. A good audit pairs the two: the signed record shows what the agent was told, and the chain shows what was paid.
Finally, a signature is only as strong as the key behind it. If the signing key leaks, new signatures from it mean nothing. Ask how the signer key is stored, and how you would hear if it changed. Keep the published address you checked against with your own records, so a later change stands out instead of slipping past.
Using signed agent decisions in audits and disputes
For a founder or a finance lead, the practical win is speed. An auditor can sample signed agent decisions, verify each one in seconds on their own laptop, and match it against the payments on chain. Nobody has to export a database and promise it is complete and untouched.
In a dispute with a seller, a signed record shows what your systems decided and when. Keep the raw records, the signatures and the signer's address together, so the check can be repeated years later. Whether a signed record carries weight in a particular dispute or audit is a question for your accountant or lawyer, not something a signature settles alone.
If you also sign the rules your agents shop within, the same reasoning applies. Our piece on AP2 spending mandates covers signed rules, and our ERC-8004 explainer covers public agent identity.

How SpendTheBits signs agent decisions
SpendTheBits is a self-custody wallet, and every answer it gives an AI agent is written to the owner's Agent activity record: allowed, waiting for the owner, or blocked, with the rule that decided. Refused requests are recorded too.
Each decision is signed by SpendTheBits with an EIP-712 signature, and anyone can check a signature against the published signer. Be precise about what that means. A signature is evidence of what the agent was told, not a condition of payment. The budget rules behind those answers are cooperative: they apply when an agent checks a payment with SpendTheBits first, and an agent that skips the check is limited only by the USDC at its address.
To set up an agent and its rules, start at the agents page. For how the wallet keeps keys on the device, see our security page.
In the app · 3 steps
See every decision your agents got in SpendTheBits
Agent budgets, requests and activity all live under Settings. Here is the path from an agent to its record.
Open your agents
Open Settings, then Agent budgets. Each agent has its own key and balance.

Answer what waits for you
Requests holds what an agent asked to spend and anything unusual about it. Approve or decline on the phone.

Check what was paid
Activity lists every answer with the rule that decided, and orders show what an agent actually paid for, so the two can be compared.

Hold your own keys, keep the yield, skip the middleman.
SpendTheBits is a fully non-custodial wallet for 13 chains, free on iOS and Android.

