Docs
What is deployed, how an app reads it, and what it does not do.
The stack
trustset is the trust stack for AI agents: eight primitives that make an agent's standing authorisation revocable, recoverable and accountable. Each is its own immutable contract with no admin, no owner and no funds, except the escrow, which pays the service on the payer's receipt and otherwise returns the money to the payer. A set an app picks from, not a platform it joins.
The switch is the door: one view call is the whole integration, and the rest of this page is about that call. The other seven are there the day you need them and cost nothing until then.
Start here
An app asks the switch inside its own transaction, so the check and the action cannot be separated. That is the whole integration.
if (!killSwitch.isTrusted(agentId)) revert AgentNotTrusted(agentId);
A venue that takes orders off chain and settles them later asks a different question: not whether the agent is trusted now, but whether it was trusted when it signed.
// judge a signature by the moment it was signed, never by now bool wasOk = killSwitch.isTrustedAt(agentId, signedAt);
To try it against the live chain without installing anything:
npx @trustset/check 24
An agent can also check itself before it signs. That is the soft version, useful against something that does not read the switch yet, and it is soft because the agent holds the key and could skip its own check. Where money must be safe, put it behind a contract that reads the switch.
Addresses
Monad testnet, chain id 10143. Read any of them yourself.
ERC-8004 token 1873, held by agent 7's owner, published a pointer back to this switch under the metadata key trustset. Anyone who publishes the same pointer is linked automatically, with no permission from us, as long as the token is held by the agent's owner or by the agent itself.
The four states
Apps proceed. The owner can pause or stop. Guardians can vote to pause.
Reversible. A guardian pause left untouched for the delay can be escalated.
Terminal. The history keeps the timestamp, so old signatures are still judged fairly.
Terminal for that id, and names the successor trust moved to.
Changing the owner is timelocked, so an owner sees a takeover coming before it lands. Guardians can never spend, and never stop an agent instantly.
Guardians
Only the owner can stop an agent, which leaves a hole: lose that wallet and a misbehaving agent has nobody left who can stop it. Guardians exist for that case and no other.
- 01They can pause. Pause is reversible and cheap to hand out. If they were wrong, the owner resumes.
- 02They cannot stop, at first. Stopping is permanent. Two guardians with a grudge, or one stolen guardian key, must not be able to end an agent.
- 03Unless the pause stands. After the delay, any guardian may stop it. An owner who was there would have resumed or stopped it themselves, so the silence is the proof they are gone.
Only a pause the guardians made can be escalated; an owner's own pause never can. On this testnet the delay is ten minutes so the path can be watched, and mainnet would use days. Guardians can also vote to move the owner to a new one, which takes a threshold plus a delay in which the current owner can refuse it.
Passkey and refunds
A passkey can pause an agent and nothing else. The chain verifies the assertion itself through Monad's P256 precompile, so no server is trusted with it, and the device has to have verified a person rather than merely felt a touch. A nonce is spent on every use, so an assertion is good exactly once. Nominate one.
The refund rail holds an agent's payment in escrow. The service is paid when it shows a receipt the payer signed over the payment id and the rail's own address, so a receipt cannot be replayed. If the window closes without one, anyone may send the money home. It does not read x402 headers yet; today an agent calls the rail directly.
What it is not
The limit worth knowing. A switch only binds an agent that checks it, or a venue that checks it for them. It does not save you from an agent that has been taken over and rewritten, because a compromised agent holding a valid key passes every check perfectly.
It is not a reputation score: it records facts, not rankings. Not a wallet: it plugs into the ones that exist. Not on the signing path: a bug here mislabels an agent, it never moves a coin. Not a network to trust: reading the switch is reading Monad.
There is an operator registry in the repo where validators post a bond and co-sign facts with aggregated BLS signatures. It is built and tested and deliberately not part of the product, because reading the chain already answers the question for anyone on Monad. It matters the day a consumer on another chain needs the same answer without reading Monad, and not before.
What is true today
The invariants are the properties the product rests on: that revoked is terminal, that ownership moves through exactly two timelocked doors and no other, that nothing skips its delay, that guardians cannot pause below their threshold. Each was checked by deleting the guard it depends on from the contract and confirming the suite goes red. One was removed rather than kept, because the handler cannot forge a WebAuthn assertion and the property could never have failed.
Proved on chain, not only in tests: a passkey nominated from a phone and used to pause the live agent, guardian recovery run from proposal through to execution, and an order signed before a stop honoured while one signed after it was refused.
Deployed to Monad testnet, never to mainnet. Nothing here is audited by anyone but its author.