Run every part yourself
The chain holds the rules. Everything around it is a program anyone can run: the nodes that serve, the index that finds, the runner that runs agents, the model that plans for them, the services that pay gas and turn deposits into USDC. We run a set of them so the first click works. None of them has to be ours. Point the app, the command line and Claude at your own, and the network is yours to the last part.
Where the network lives
Nothing the network needs runs on a personal machine. The chain holds the record: listings, prices, stake, sessions and the fee split, ratings, paid reviews, disputes, every node's address and certificate pin. A subgraph indexes it for any front-end, and any graph-node that serves the subgraph will do, The Graph's network included. Nodes run on servers, home machines or rented GPUs; their addresses are on chain and every client pins their certificates from there. A directory is a convenience anyone can run: it probes the nodes and keeps the experience records runners sign; the app reads whichever it is pointed at, and reads the chain through the subgraph when it has none. The app is a front-end anyone can run from an RPC, a subgraph and the nodes. Your own private node is the one thing that is yours to run, on your device or your server, and it is the only thing on your machine the network ever talks to.
What there is to run
Every command is npm run … in offchain/, after scripts/devstack.sh setup once. Each part
reads its settings from the environment; Every setting has the full
list.
| Part | What it does for you | Start | Point at yours |
|---|---|---|---|
| Marketplace node (:8546, :8556) | Serves your listings and settles what they earn. One service or a whole catalogue from a services.json. | npm run node, or npm run multinode with AIOUM_SERVICES_CONFIG=services.json, AIOUM_NODE_PORT, AIOUM_NODE_DIR | App: Your selling node (NEXT_PUBLIC_MULTINODE_URL), Catalogue node (NEXT_PUBLIC_NODE_URL). CLI and Claude: AIOUM_MULTINODE_URL, AIOUM_NODE_URL. |
| Indexer (:8549) | The search every agent, page and command uses: it rescans the chain and probes the nodes it is told about. | npm run indexer with AIOUM_INDEXER_SEEDS=http://…,http://… | App: Marketplace directory (NEXT_PUBLIC_INDEXER_URL). CLI and Claude: AIOUM_INDEXER_URL. Other nodes: AIOUM_INDEXER_URL on the node, so it announces itself to yours. |
| Your own runner (:8770/runner) | Builds, runs, schedules and publishes your agents, inside your private node; pays from the wallet connected there, within each agent's caps. | Started with the private node. PRIVATE_NODE_RUNNER=0 turns it off. | App: My own runner under Your network. CLI and Claude: AIOUM_AGENTS_URL (default http://127.0.0.1:8770/runner) with your node's token. |
| Shared runner (a listing) | Runs the agents of people who sign in with their wallets; each person's own account pays, within a cap they sign; the operator earns a fee per run. | AIOUM_AGENTS_MODE=shared npm run agents with AIOUM_AGENTS_KEYS_SECRET and AIOUM_AGENTS_URL; listed with the shared-runner template (A shared runner) | App: Your agent runner under Your network. CLI: aioum runner use <url>. |
| Paid reviewer (a runner) | Reviews the listings the chain draws it for, paid in ZAI (Paid reviews). | AIOUM_AGENTS_MODE=own AIOUM_AGENTS_TOKEN=… AIOUM_AGENTS_REVIEWER=1 npm run agents with AIOUM_REVIEWER_PRIVATE_KEY and AIOUM_REVIEWER_BOND_ZAI | aioum reviewer status. |
| Planner (a listing) | The model that plans an assistant's turns. A marketplace listing like any other: paid per turn, run by anyone. | Add planner-openai, planner-openrouter or planner-ollama from the gallery to your node's services.json (npm run templates -- add planner-ollama --out services.json), with the key in the named environment variable, or a local model and no key at all | The builder's Which model plans?; aioum agent create --planner-service <id>; plannerService in a spec from Claude. aioum planners lists what is live. |
| Facilitator (:8547) | Pays the gas that opens a session, so an agent never holds ETH. Non-custodial: funds go from the payer to escrow, never through it. | npm run facilitator with a funded FACILITATOR_PRIVATE_KEY (or the shared RELAYER_PRIVATE_KEY) | CLI and Claude: AIOUM_FACILITATOR_URL. |
| Bundler (:8548) | Relays a smart account's signed operations to the EntryPoint. | npm run bundler with a funded BUNDLER_PRIVATE_KEY | App: Bundler (NEXT_PUBLIC_BUNDLER_URL). CLI and Claude: AIOUM_BUNDLER_URL. |
| Deposit service (:8551) | Turns what you send from any chain into USDC in your AI wallet, and sweeps it in. | npm run deposits with DEPOSITS_PRIVATE_KEY (pays gas for sweeps, holds no funds), LIFI_API_KEY, AIOUM_DEPOSITS_DIR | App: Deposit service (NEXT_PUBLIC_DEPOSITS_URL). CLI and Claude: AIOUM_DEPOSITS_URL. |
| Staking node (:8552) | Reviews a listing and puts the network's ZAI behind it, so a seller goes live with 100 ZAI of their own; takes it back when the listing degrades. | npm run backer with BACKER_PRIVATE_KEY (the pool: ZAI to delegate, a little USDC for sample calls), a review model (ANTHROPIC_API_KEY, an OpenAI-compatible endpoint, a local Ollama, or a judge listing in BACKER_REVIEW_SERVICE), BACKER_MAX_PER_OPERATOR_ZAI, BACKER_RUBRIC | App: Staking node (NEXT_PUBLIC_BACKER_URL). CLI and Claude: AIOUM_BACKER_URL. |
| Private node (:8770) | Your keys, memory and local connections, on a machine you control. | npm run private-node (Your private node) | App: Your private node. CLI and Claude: AIOUM_PRIVATE_NODE_URL, AIOUM_PRIVATE_NODE_TOKEN. |
| Chain RPC (:8545) | Reads and writes to the chain itself. | Any RPC for the chain; anvil on your own machine | App: NEXT_PUBLIC_RPC_URL. CLI and Claude: AIOUM_RPC_URL. |
| The app | The pages themselves. | cd dapp && npm run build && npm start, with the NEXT_PUBLIC_* addresses above | Its own address. |
On your own machine, scripts/devstack.sh setup builds and starts every one of them at once,
with a local chain and a catalogue of real services: fifty that need no key, plus every gallery
template a key in .env unlocks and, when Ollama is running, the local models and planner.
Nothing simulated: each listing calls its real upstream. On a server, scripts/deploy-network.sh deploy does the same on a chain of your own: one unit per part, TLS from DOMAIN, the app built
with the addresses, and the parts it could not start named with the key each needs
(Deploying your own network).
Point the app at yours
Open Your network at /settings, also linked from the foot
of every page. One field per part, the address we run as the placeholder, and beside each a
Check that shows whether it answers and how fast. Type yours, press Save, and every page
reads through it from then on; Use the hosted defaults puts it back. The choice lives in your
browser only. A whole app built against your own addresses is the NEXT_PUBLIC_* variables at
build time.
Point the command line and Claude at yours
The AIOUM_*_URL variables above, in the shell for the CLI or in the MCP server's env for
Claude. aioum status and aioum_status then probe your parts, not ours.
Who plans
An assistant agent needs a model to plan its turns. Four ways, none of them through us:
- Your own Claude plan. Sign in once under Settings (Claude Code 2 or later on the runner's machine) and every assistant on that runner plans on the subscription you already have: nothing per token or per turn, no API key. Yours alone; never listed on the marketplace.
- A planner listing on the marketplace. Anyone can run one, with their own key or a local model; you pick it in the builder and pay it per planning turn from the agent's budget, on the same receipts as any other call.
- The runner's own key or local model. Set
ANTHROPIC_API_KEY, theAIOUM_AGENTS_OPENAI_*variables or run Ollama beside the runner, and every assistant on that runner may plan there without paying a listing. - No model at all. A fixed-steps agent runs the same calls every time and never plans.
A Super Agent takes the highest model tier live, wherever it runs: a 7B model beside your runner over a 3B listing, a frontier listing over both (Who plans).
What stays shared
The contracts, owned by the Timelock, and the registries they keep: listings, stake, sessions, disputes, ratings. That is state on the chain, not a service anyone hosts, and every part above reads it the same way you can.
Next: Nothing starts from scratch — what is kept through a crash, a reboot and a new network, and how to snapshot, restore and move it.