Skip to content
SpendTheBits

Agents · 7 min read

Signed agent decisions: an audit trail you can check yourself

By , Founder, SpendTheBits ·

In short

An ordinary agent log is only as trustworthy as whoever keeps it. Signed agent decisions fix that: each answer an agent got (allowed, ask the owner, or blocked) is signed as EIP-712 typed data, so anyone with the record and the signer's public address can check, offline, that it was not changed. A signature proves who said what, not that the decision was right.

32 bytes
the EIP-712 domain separator that ties a signature to one app and versionSource: Ethereum Improvement Proposals

When an AI agent spends money on a company's behalf, sooner or later someone asks why. Why was that payment allowed? Why was this one blocked? Who agreed to the one in the middle? The usual answer is a log. The trouble is that a log is just rows in a database, and rows can be edited by whoever runs the database.

This piece explains a stronger kind of record: one where every decision carries a digital signature. We cover what such a record should hold, why the EIP-712 standard is a good fit, how to verify a record yourself without trusting anyone's server, and the limits that a signature cannot get past.

A ledger line sealed in gold wax beside a robot hand, illustrating signed agent decisions.

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.

SpendTheBits Spending mandates screen showing a daily limit under active mandates
Spending mandates are signed EIP-712 messages too: rules, not payments.

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.

  1. Open your agents

    Open Settings, then Agent budgets. Each agent has its own key and balance.

    The Agent budgets screen in SpendTheBits
  2. Answer what waits for you

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

    An approval screen for an agent request above its limit
  3. 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.

    A list of orders with their status, including ones paid by an agent

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.

Frequently asked

They are records of each answer an AI agent got about a payment, such as allowed or blocked, with a digital signature attached. Anyone with the record and the signer's address can check it was not changed.

Yes. Rebuild the typed data, compute its digest and recover the signer address locally, then compare it with the published signer. For a plain key no network call is needed; a contract signer needs an EIP-1271 check on chain [3].

No. It proves what was decided and by whom. Check the blockchain transaction to confirm what was actually paid.

No. The standard says it does not include replay protection, so each application must handle a message seen twice [1].

Sources

  1. 1.EIP-712: Typed structured data hashing and signing · Ethereum Improvement Proposals · accessed 2026-11-12
  2. 2.FIPS 186-5, Digital Signature Standard (DSS) · NIST · accessed 2026-11-12
  3. 3.ERC-1271: Standard Signature Validation Method for Contracts · Ethereum Improvement Proposals · accessed 2026-11-12
  4. 4.Units and Globally Available Variables, Solidity documentation · Solidity · accessed 2026-11-12
  5. 5.Ethereum accounts · ethereum.org · accessed 2026-11-12

This article is educational and reflects observed data and public sources on the date shown. It is not financial, legal or tax advice. Digital assets can lose value; yields shown are observed, not promised.

STB Weekly, every tuesday

The short version of pieces like this one, plus what moved in AI in finance and agent payments. What you get

Product updates and release notes. No price calls, no spam, unsubscribe in one click. We email you once to confirm before anything else is sent.