Stake and sit on the jury

Two things on the network are done with your own wallet rather than the runner's: backing an operator with ZAI, and judging disputes. Both are transactions, so both need AIOUM_PRIVATE_KEY in the server's environment, and every tool that signs says so in its description and returns the transaction hash. Amounts are decimal strings: "500" is five hundred ZAI. What staking earns and risks: Stake on an operator; the commit-reveal mechanics: Serve as a juror.

Who to back

You: "Which operators are live, and how much stake stands behind each?"

Claude calls aioum_stake_operators with {}

You see: every operator on the index, most stake first: the operator address, stakeZai, whether any of their listings is live, and their services with serviceId, category and priceUsdc. Reads only.

Your positions

You: "What have I staked, and what can I claim?"

Claude calls aioum_stake_positions with {}

You see: your address, then one row per operator you back: yourStakeZai, claimableUsdc (your share of what their listings were paid, waiting to be claimed) and operatorTotalStakeZai; plus the network's two floors, minSelfStakeZai (what an operator puts up of their own to list) and minNodeStakeZai (the total, own plus delegated, at which a node is live, so your backing can be what switches one on), and unbondingPeriodSeconds.

Delegate

You: "Stake 500 ZAI on 0xabc…"

Claude calls aioum_stake_delegate with { "operator": "0xabc…", "amountZai": "500" } (signs)

You see: approveTx when the staking contract needed a new allowance, and delegateTx. Two transactions at most, one when the allowance already covers the amount.

Claim, unstake, withdraw

You: "Claim my rewards from 0xabc…, then unstake 200 of it."

Claude calls aioum_stake_claim with { "operator": "0xabc…" } (signs), then aioum_stake_unstake with { "operator": "0xabc…", "amountZai": "200" } (signs)

You see: a tx for each. The claim pays the USDC to your wallet. The unstake starts the unbonding clock; after unbondingPeriodSeconds, aioum_stake_withdraw with the same operator (signs) moves the ZAI back to your wallet.

The jury: where you stand

You: "Am I on the jury? What does it take?"

Claude calls aioum_jury_status with {}

You see: minArbitratorStakeZai, quorumZai, commitPeriodSeconds and revealPeriodSeconds, and under you: your address, your stakeZai on the arbitrator and lockedUntil.

Join

You: "Join the jury with 1000 ZAI."

Claude calls aioum_jury_join with { "amountZai": "1000" } (signs)

You see: approveTx (when needed) and stakeTx. Your stake is your voting weight, and it is what a wrong or missing vote can cost.

Cases

You: "Any disputes open right now?"

Claude calls aioum_jury_cases with { "limit": 20 }

You see: the newest disputes: disputeId, the sessionId in question, client, operator, the bond, status (open, upheld, rejected or timed out), the evidenceURI, raisedAt, the commitDeadline and revealDeadline, the committedWeightZai so far with forFaultZai and againstFaultZai, whether it is resolved, and under you: committed, revealed and saltSaved, whether this machine holds the salt for your vote.

Commit, then reveal

You: "Read the evidence for dispute 3." Claude fetches the evidenceURI and summarises the package (Evidence format).

You: "I find the operator at fault. Commit that."

Claude calls aioum_jury_commit with { "disputeId": 3, "nodeAtFault": true } (signs; the salt is saved to ~/.aioum/jury-salts.json before the transaction is sent)

You see: the disputeId, your nodeAtFault and the tx. Nobody can read the vote from the chain: the commitment binds your address, the vote and 32 random bytes.

You: "The commit period is over. Reveal my vote on 3."

Claude calls aioum_jury_reveal with { "disputeId": 3 } (signs)

You see: the disputeId, the nodeAtFault that was sealed, and the tx. The tool reads the salt from the file; without it, the answer is "no sealed vote for dispute #3 in this salt store; restore the backup you exported when you committed".

Finalize, escalate, claim

After the reveal period, anyone can close the case.

You: "Finalize dispute 3 and claim my reward."

Claude calls aioum_jury_finalize with { "disputeId": 3 } (signs), then aioum_jury_reward with { "disputeId": 3 } (signs)

You see: a tx for each. A case that reached no quorum is settled by escalation instead: aioum_jury_escalate with { "disputeId": 3, "nodeAtFault": true } (signs). Which is allowed when, and what a juror on the losing side pays: finalize or escalate.

Leave

You: "Take 1000 ZAI off the jury."

Claude calls aioum_jury_leave with { "amountZai": "1000" } (signs)

You see: the tx. Once lockedUntil has passed, aioum_jury_withdraw with {} (signs) returns the ZAI to your wallet.

Where the salt lives

A sealed vote is one bit hidden behind 32 random bytes, and only those bytes open it. The server draws them at commit time and writes them to ~/.aioum/jury-salts.json on the machine that runs the server, keyed by chain id and dispute id, with the vote and the time, just before the commit transaction goes out. aioum_jury_reveal reads the same file, and aioum_jury_cases reports saltSaved from it.

Back that file up as soon as you commit. A disk that dies, a laptop that is replaced, or a reveal attempted from a second machine leaves a commit that can never be revealed, and that costs you (juror runbook). The file is shared with the aioum CLI, whose aioum jury salts export <file> and aioum jury salts import <file> move it between machines; there is no MCP tool for that, on purpose, so copy the file yourself.

Next: Drive your private node — connect your accounts, call their tools for free, keep memory, run schedules, and back it all up.