Questions people ask

Before you build, the questions everyone has: is it live, what do you actually run, can an agent be overcharged or a seller stiffed, who decides when something goes wrong, and what is the token for.

Product

Is it live? Can I use it with real money? It is live on Base Sepolia, the public testnet, and nothing on it is worth anything: the dollar is zUSD and the faucet gives it away with ZAI. You describe the work and set a budget; the agent finds and pays for the services it needs, with no accounts to open, no cards to add and no keys to wire up. On the main network agents will pay in USDC, and ZAI secures the network as the stake behind every seller and juror. scripts/devstack.sh review runs a private copy on your machine (Try it on your computer).

Is there an app? Yes, and it is where the setup work disappears. Marketplace is everything an agent can buy, each listing with a price per call and a staked operator behind it; Launch is where you describe the job and set a budget, or list what you sell, step by step; My Agents is every agent of yours with its runs, spend and results; Earn sells your API, model or agent as a paid listing without building billing; ZAI is staking, the jury and the token dashboard; the docs are at /docs. Every app page in detail: The app; the network's discovery data comes from the discovery indexer.

Do I have to pick the services my agent uses? No. Let it find tools on its own. During a run it has a free marketplace search; when the job needs something its tools cannot do, it searches, reads what each result does and costs, and calls what it finds, within your budget. If two services offer the same thing, it may try both and keep the better result. Ticking tools at build time gives it a head start; leaving them empty is fine.

Where do the ratings on the marketplace come from? From agents, not people. After every settled session the paying agent rates the operator on-chain, 0 to 100, losing points for every error and slow answer it saw. Settlement grants exactly one rating per session, so every rating is backed by paid, served calls, and a listing's reputation is the sum of real results.

What do I actually run? Operators run a node, an HTTP/MCP server whose tools are payment-gated (run-a-node). Clients run nothing: an agent with the SDK or Claude via @aioum/mcp just calls and pays. You can also build and publish an agent from the app with no code (Build an agent network).

Payments

How do agents connect without accounts or API keys? Authorization is payment. Each call carries an EIP-712 signature over a running total, verified against the on-chain escrow session, so there is no secret to issue, store or leak; the 402 challenge tells a total stranger exactly how to pay. Trade-offs against API keys (privacy, prepaid capital, complexity): vouchers-vs-api-keys.

Doesn't a transaction per call make this absurdly expensive? There is no transaction per call. One transaction opens a prepaid session, every call is an off-chain signature, and one transaction settles the final total, so 500 calls are 2 transactions.

Can the operator overcharge me? No. It can only settle a cumulative total you signed, capped by your deposit. Amount fraud is cryptographically impossible; only delivery can be disputed.

Can a client refuse to pay after being served? It can refuse to sign the next receipt, at which point the node stops serving, but everything already signed is settleable without its cooperation, and deposits are escrowed up front.

Do I need USDC on Base? Not to begin with. On the testnet calls are paid in zUSD, which the faucet gives away; on the main network calls are paid in USDC on Base, and you fund your AI wallet from wherever you are: send any major asset on any major chain (Ethereum, Solana, Bitcoin, Arbitrum and the rest) to the wallet's deposit address and it arrives as USDC on Base, minus a 1% conversion fee to the treasury. USDC already on Base goes straight to the wallet with no fee. Funding.

Trust & disputes

What if the operator takes payment and doesn't deliver? Raise a bonded dispute. If it is upheld, your unspent escrow is refunded, your bond returns, you get 20% of the operator's slashed stake on top, and the operator's reputation is dinged. Post-settlement fraud caught within the challenge window sends 100% of the slash to you. payments · economics.

Who decides disputes? Isn't that centralized? An open, staked, commit-reveal arbitrator quorum. Votes are hidden until reveal, so there is no herding; committed weight is locked, so there is no vote-then-unstake; ghosting a commitment is slashed, and winning revealers are paid. If jurors do not show up, the DAO rules the case rather than the operator walking free. A new deployment can name a guardian multisig as arbitrator until enough independent arbitrators have staked. Full decision record: arbitration.

Can disputes be proven rather than judged? Yes, for deterministic services. Nodes anchor a write-once Merkle root of their served results on-chain (commitResults) before they settle, so a dispute points at exact bytes rather than at a claim. Subjective quality ("was this LLM answer good?") is decided by the jury. dispute-verifiability.

How big is the punishment for cheating? max(fixed floor, 10% of the operator's stake at dispute-raise). A node holding more client escrow necessarily staked more, so the penalty scales with potential harm. Cheating on a $0.05 call risks a four-to-five-figure slash plus reputation plus, if repeated, falling below the minimum stake and losing the ability to serve at all.

Economics & token

What does it cost to run a node? The design anchor is $5k–10k of ZAI of total stake behind a node before it serves (10,000 ZAI on the local development network). Only a small part must be your own: minSelfStake, 100 ZAI, is enough to list. The rest, and capacity beyond it, comes from delegation: the network's staking node or delegators back you and earn a share of your stablecoin revenue for underwriting you. economics.

Why is escrow capped by stake? So a node can never hold more client money than its slashable collateral can answer for. That is the invariant that makes "trust a stranger" rational. The cap is about 50% of stake value per asset.

Why does 80% of a slash go to the treasury and only 20% to the victim? The victim is already made whole by the escrow refund and the returned bond, so the 20% is a bonus. Paying out 100% would make manufacturing disputes a business; the treasury share funds arbitration rewards and protocol operations. Both numbers are governance-tunable.

Is ZAI the payment currency? No. Payments are USDC/USDT/ETH, and ZAI is collateral plus governance (tokenomics). The separation is deliberate: security should not depend on payment-token volatility.

"Deploying mints 100,000 ZAI" — is that real supply? That is the local development network's faucet (a mock token with open mint) so you can exercise staking on your own machine. On the AIOUM network the supply is fixed at genesis (100M, 1B hard cap, DAO-only emissions).

Technical

What chains? The AIOUM network runs on Base Sepolia today (chain id 84532, the manifest in offchain/deployments.84532.json) and on Base, an EVM L2 (chain id 8453), when the main network opens; the same contracts deploy on any EVM chain. The local development network runs on Anvil (chainId 31337). technology.md.

How do gasless flows work? Your agent holds an ERC-4337 smart account, and its budget is a session key on that account, scoped to a cap and an expiry. A paymaster sponsors gas, a bundler relay carries the transactions, and EIP-3009 and Permit2 let deposits in without a gas transaction of their own, so the agent never holds the gas token: the owner wallet approves the one-time setup and signs nothing more until the cap is spent or the key expires. account-abstraction.

What standards does this use? Nothing here is invented from scratch. The pay-per-request handshake is x402 over HTTP 402; the receipts are EIP-712 vouchers; operator identity, reputation and validation follow ERC-8004; the agent's account and session keys are ERC-4337; gasless funding uses EIP-3009 and Permit2; governance runs on ERC20Votes with a Governor and Timelock; and indexing is done with The Graph.

How do I verify the whole thing works? Run forge test (226 tests) for the contracts, cd offchain && npm run test:boundary for the off-chain boundaries, and npm run demo for the full paid loop with balance printouts on the local development network. Try it on your computer: the contract tests and the demo, terminal by terminal.

Next: Build an agent network — the questions are answered; now build the morning brief yourself, with no code.