Trust stops being a badge. It becomes a price.
An agent locks USDC against a floor on its own future claim-truth rate. Stay above the floor and the stake comes back. Fall below it and a signed verdict burns it, so nobody is paid by a slash, us included. There is no admin function and no override anywhere in that path.
bond your own agent
From the passkey or wallet that owns it. Every rule the contract enforces is checked here first, from live chain state, so the button only turns on for a send that can succeed.
reading this tab's session…
version 2 · what changed on 10 october and why
Two changes an outside reviewer asked for. Nothing else in the contract moved.
A slash pays nobody. In version 1 a forfeit bond went to our own agent wallet, while our attestor signs the verdicts. So the party deciding a slash was the party paid by it. Assay's review named that as the question a buyer would ask. Version 2 burns a slashed bond to 0x…dEaD, a constant in the bytecode rather than a deploy setting. A claim that does not resolve harms nobody the contract can identify on chain, so there is no buyer to compensate. Burning is the one destination nobody in the decision path gains from.
An agent can bond again. Version 1 allowed one bond per agent, ever, so a team waiting until its agent had claims worth measuring was spending its only slot whenever it posted. Version 2 allows a new bond once the last one is released or slashed. Verdict nonces carry across bonds and every verdict window must start after the current bond was posted, so a verdict signed for an earlier bond cannot be replayed against a later one.
Contract 0xB4d641f016f53C683c409F271eE85e136041FE3f, deployed at block 112,106,633, exact match on Sourcify. Version 1's whole test suite runs against it unchanged, 39 tests, plus 8 for the two changes. Six deliberate breaks of the new code were each caught. A mainnet fork test burns real Circle USDC and re-bonds a real agent. Same attestor, same registry. Our earlier bonds stay on version 1 and are listed below with it.
cast call 0xB4d641f016f53C683c409F271eE85e136041FE3f 'slashBeneficiary()(address)' --rpc-url https://rpc.monad.xyz # 0x000000000000000000000000000000000000dEaD
the current bond on each agent · 3
Read from Sclera on every load. State is the contract's, not an index's, because a window matures when a block number passes and emits nothing. One row per agent, its latest bond across v1 and v2.
0.07 USDC is at stake across these right now. A released bond reads zero because the money went back, which is why the state is shown beside the amount rather than the amount alone.
one complete bond, on mainnet
Posted, held for its full window, released. Not a testnet screenshot and not a plan.
- bond released
- returned in full after the window, block 107719555
- floor committed to
- 8000 bps 80% of decided claims must resolve true
- window
- 216,000 blocks about a day at 400ms
- minimum sample
- 5 below this nothing can slash
Verified by where the money went rather than by an event we emitted. While the bond was open 10252's stake of 20,000 units sat in the contract and the agent was down by exactly that; on release both reversed. The bond now reads state 3, Released, with its amount zeroed and a second release reverts WrongState().
# 10252's own stake, read off its bond rather than the shared balance cast call 0x57aF4e4B482Ab1bb4f9d1aeb5206258a7Def0eaf 'bonds(uint256)' 10252 --rpc-url https://rpc.monad.xyz # state 3 == Released, amount 0, the stake returned in full
What the release does not prove: the window ran with no verdict submitted, so this demonstrates the timelock, the state machine and the return path. It does not show that a measurement fed the outcome. release is callable by anyone on purpose, because the money can only go to the agent that posted it, which keeps a bond from being stranded by an operator who has lost access to the gas token.
The thing that slashes it is a measurement, not an opinion.
The agent picks its own floor, window and minimum sample, then locks the tokens. Only the agent can: the contract reads ownerOf from the ERC-8004 registry and refuses anyone else.
Claim-truth rate over a block range, served at /api/sla/<agentId>. A pure function of the id and the range, so independent nodes computing it agree.
A verdict is signed by an attestor key derived from a passkey. The contract recovers it and compares against one address fixed at deploy.
Above the floor, the stake returns when the window matures and anyone may trigger it. Below it, the bond is burned in the same transaction that decides, so a slash pays nobody.
read by a CRE workflow
A Chainlink CRE workflow reads the bond's terms from Sclera on Monad, then reads the agent's measured claim-truth rate from the Kanmani API and signs the verdict. Simulated with the CRE CLI, which is the deliverable Chainlink judges.
- chain read
- bonds(uint256) on Sclera 0x57aF4e4B482Ab1bb4f9d1aeb5206258a7Def0eaf on Monad mainnet, block LATEST
- external api
- GET /api/sla/<agentId>, run by every node, aggregated by median. check agent 10182 live
measured 1/42 claims true = 238bps (0 undecided, excluded from both sides) OBSERVED agent=10182 rate=238bps sample=42 (no bond, no verdict)
That is 1 true of 42 decided claims, a measured 238 bps. The workflow refused a verdict because this agent has no bond, so there is nothing to slash, which is the measurement without the judgement.
bond read from chain: floor 8000bps, window 107757352..107973352, minSample 5, nonce 1
The same workflow reading a live bond's terms (agent 10256), so the chain half hits a real deployed bond even though the featured run above is observation mode.
This is a successful CRE CLI simulation, which is the bounty deliverable. The chain read and the decision are real. No verdict was issued because no single agent has both a bond and a decided sample yet, the same honesty the panel beside this one states. full recorded run →
why the forwarder is not trusted
The one design decision that keeps this from being a fund-loss bug.
A Chainlink CRE report reaches a consumer through a forwarder. We read the deployed forwarder's source before trusting it: typeAndVersion() returns MockKeystoneForwarder 1.0.0 and its report function is permissionless by design. A contract gating on msg.sender == forwarder would be gating on nothingand this contract holds bonds.
So authorisation travels with the verdict instead. The attestor signs it, the contract recovers the signer and requires it equals 0x358c591aD7D60aC36bC223472B41518A7FA7b44A, fixed at deploy with no setter. The forwarder is a pipe. Anyone may push a report through it and exactly one signature makes it act.
That attestor is a passkey-derived key that owns nothing and can only sign verdicts. How the four keys separate →
what this does not prove yet
No bond has been slashed and we declined to fake one. Two things block it independently. The attestor key is derived from a passkey, so nothing in the repository can author a slashing verdict at all. That is the key separation working rather than a gap. And agent 10252's real claim-truth sample is empty, because our own record asserts no payment claims, so an honest verdict carries a sample of zero and the contract refuses it before computing a rate. Manufacturing a slash would mean signing numbers that are not a measurement or publishing false payment claims about our own agent. Both are the thing this project exists to detect, so the absence stays and the slashing path rests on the contract test suite and fork tests against real mainnet state.
The review that preceded this deployment found a real one and is published with the exploit rather than summarised: postBond originally never checked who owned the agent, so anyone could bond anyone and a stranger could have created an unslashable bond that made an agent read as staked. A badge that costs one atomic unit to fake is the thing this project exists to attack, so the fix is enforced by the registry and mutation-tested. How a verdict is decided →