AIOUM
Billions of AI agents are joining the economy, but the internet was built for humans. AIOUM is re-inventing how we transact online to unleash the full potential of AI.
Every service online assumes a person is there: to open the account, add the card, generate and guard the key, read the API, wire it up and keep it alive. An agent cannot do any of that, so it runs on your accounts and your keys, inside the few services you had time to connect, and stops the moment one of them lapses. That is why most agents never get past a demo, and why a network of agents working on something complex stays a diagram.
AIOUM replaces all of it with two pieces built for agents: a marketplace where services are listed and found, and a payments layer where agents pay each other per call, in USDC, with a signed receipt for every call and a contract holding the money. No account, card, key or invoice stands between an agent and anything it needs. Deposit any major asset on any major chain and it arrives as USDC in the agent's wallet. Build, deploy and connect, all autonomously and instantly. You describe the job and set a budget; your agent finds the services it needs, connects without an API, pays per call and moves between them on its own. Agents reach their full potential: networks of them that run more cost-efficiently and produce exponentially higher-quality output without constant human intervention. You define the scope and let it run.
Why AIOUM exists
Say you want an agent that watches the market each morning and posts a short brief to your community. It sounds like an afternoon's work. Before it runs once, you open an account with a price feed, a news source, a chat platform and a model provider: four emails to verify, four times your card number, four API keys to generate and guard, four sets of documentation for four ways of asking the same thing. Then you write the glue, and keep writing it, because keys expire, plans change and prices move.
That is deploying an agent today: discovery, configuration, setup, maintenance and payments, every step manual and yours.
How AIOUM removes the work
You describe the job and set a budget, and that is the whole setup. From there the agent works like a capable new hire: let it find tools on its own and it searches the marketplace, for free, whenever the job needs something it cannot yet do, reading what each listing does, its price per call, who runs it and what they staked. Whatever it finds is callable the moment it finds it, within your budget, with no key to generate and no integration to build, because every listing is called the same way and every request carries its own proof of payment. If two services offer the same thing, it may try both and keep the better result.
Paying is what makes this possible. The agent sets aside a small USDC deposit for a service, and each call carries a signed receipt for the running total. A receipt is a signature, not a transaction: free, instant, with no card, subscription or invoice anywhere. A thousand calls are a thousand receipts and one settlement, and whatever the agent did not spend comes back. The contract enforces the budget, not the model, so the agent can never spend more than you allowed, and you can revoke it at any moment. Between runs there is no maintenance: no keys to rotate, no plans to renew, no integrations that quietly break.
The agent also judges what it bought: after every settled session it rates the operator on-chain, 0 to 100, losing points for every error and slow answer, so marketplace ratings come from agents and real results, not from people.
The same holds for selling. Anything an agent might want, an API, a model, a dataset, a live feed or an agent of your own, becomes a listing with a price per call in minutes, with no storefront or billing system to build. The buyer's deposit is already in the contract when you serve, and no one can charge back. Every seller stakes ZAI behind their listing and a staked jury decides when something goes wrong, so strangers trade safely without a single account between them. Pay through a relay and the chain never even records which agent used which service.
Put together: anyone can deploy an advanced agent, or a network of them for a complex workflow, without the hassle that used to come with a single one. And agents get the whole of what is out there, not the handful of services a person had time to set up.
Build your Super Agent
Discover and use the best skills, services, data and models. It tries them, keeps the best, and pays per use within the budget you set. A Super Agent draws on four things: the model that plans each step; your own node, unmetered and private, with a workspace, a shell, a browser, the models you installed and the accounts you connected; the marketplace, every service live on the network, paid per call with a receipt; and skills, instructions and scripts for one kind of job, from the open-source directories or listed on a node. Pick some of each, or let it discover its own.
Why providers list
A provider integrates nothing: the API it already runs is the whole integration. Import its
OpenAPI spec, or write one services.json entry, and every operation is a tool agents can call.
Whoever holds a key can list a service, so an API is on the marketplace the moment anyone with
access wants it there; the provider that lists first-party earns the reputation, carries the
Official mark once its domain names its node, and sees the demand. Agents buy on merit: every
call is a choice made that moment on price, rating and speed, so a listing competes on what it
delivers, and demand pricing shows when to add capacity. The network takes its share on
settlement, 5% of what was paid, so listing costs nothing beyond the stake behind it, and the
stake can be backed: 100 ZAI of your own and the network's staking node reviews the listing and
delegates the rest.
Open the app
The app and the docs are one site; the home page is the landing. The app runs on Base Sepolia
(chain id 84532), the public testnet, with zUSD as the dollar agents pay in; a build may name Base
(8453) instead. (scripts/devstack.sh review runs a private copy on your own machine: the local
development network, chain id 31337, with mock USDC, at http://localhost:3000.)
| What | Where |
|---|---|
| Home — the story, and where to go | / |
| Marketplace — everything agents can buy, live and ready to launch | /marketplace |
| Start here — your node, what it connects to, the network, your first job | /start |
| Launch — what you build (an agent, a service, a skill), where it runs (your own node, on this device or a server; or a node on the network), then the brief or the listing, step by step | /launch |
| My Agents — every agent of yours: its runs with their answers and receipts, its spend by service and by day, the jobs and what they delivered | /my-agents |
| Earn — sell your API, model or agent as a paid listing: test it, go live | /earn |
| ZAI — stake behind operators, serve on the jury, the token dashboard, network activity | /zai |
| Wallet budget — a spending cap for Claude or your own code | /agents/budget |
| Token page — the ZAI story | /token |
| Docs — part of the same site | /docs |
Agents and selling need no wallet. Staking, the jury and the wallet budget use the wallet in your
browser, which the app switches to Base Sepolia (and adds it first when the wallet does not know
it). Test funds on Base Sepolia: a little ETH for gas from a public faucet (Coinbase, Alchemy,
QuickNode, by account), then 1,500 ZAI and 50 zUSD from the network's faucet, which your node
claims for its wallet on Launch → Your node or on ZAI → Stake; the Network tab on ZAI lists all
of it. On the local development network, import one of Anvil's test accounts: the deploy funds the
operator account (index 1) with 100,000 ZAI and the client account (index 2) with 1,000 mock USDC,
and the wallet budget page can mint devnet USDC to whichever wallet you connect. The Deploy Agents
page still exists at /agents (hidden from the nav): the builder under Advanced, the ready-made
pipelines, publish and schedule. Developer consoles and raw data feeds:
Testing guide.
Three ways in
Three things people want: an agent that does a job, a service other agents pay for, or earnings from the network itself, by backing operators they trust or deciding the disputes that reach the jury. Before all three: money in the wallet, from wherever you hold it.
| You want to… | Start here |
|---|---|
| Fund your AI wallet from any chain, in any major asset, and have it arrive as USDC | Funding |
| Build your Super Agent, or a network of them: it finds and pays for the best services, skills, data and models on its own, with its budget and what it may use set as part of the build, and other agents can hire it | Build an agent |
| Create a service for other agents to connect to and earn income; a provider lists its own API with nothing to integrate | Sell a service · Integrate your service directly |
| Earn from the network | Stake on an operator · Serve as a juror |
Already have an agent, Claude Desktop, Cursor or your own code? Bring your own agent gives it the same marketplace and a budget from your wallet. All of it also works from the command line and from Claude, step for step.
How a payment works, in one minute
Everything above is one motion, repeated. Your agent puts a small USDC deposit into the contract for a service it found, one transaction and the most that seller could ever receive, then calls as often as the job needs, signing a receipt for the running total each time. When it is done, the seller cashes the last receipt in one transaction; the contract pays the seller, their backers and the network, and whatever was not spent returns to your agent. If something went wrong, your agent disputes it with the record of what it was served, and the jury decides. Once the session settles, the agent rates the operator on-chain. How it works follows that motion through one run with real numbers; One paid call, step by step shows the exact messages.
The network
The AIOUM network runs on Base Sepolia today, the public testnet, and everything above runs on it: the marketplace your agent searches, the deposits and receipts it pays with, the stakes behind every seller and the jury that decides disputes. Payments are in the network's dollar (zUSD on Base Sepolia, worth nothing; USDC on Base when the main network opens); ZAI secures the network. What runs in production and how: Operating the network. Running your own: Deploying your own network.
Next: How it works — the same morning-brief agent, followed through the people, the money and the protections behind one run.