Claude and MCP
You have the app in one window and Claude in another, and you keep carrying things between them:
a service id into an agent's tool list, a dispute number into a vote, a run's receipts into a
question about cost. One MCP server, @aioum/mcp, closes that gap: Claude Desktop, Claude Code,
Cursor or any MCP client gets the whole network as tools. You say what you want and Claude does
it: finds a service and pays for a call, builds an agent and runs it, lists something you sell,
backs an operator, sits on the jury, drives your private node, and tells you what the network is
doing. Every paid call still carries a signed receipt under a budget you set once; nothing about
the protocol changes because Claude is talking.
One server, two kinds of tools
The server starts with your environment and speaks MCP over stdio. It offers Claude two families of tools.
Every live marketplace service is a paid tool. Each time your client asks for the tool list,
the server asks the network what is listed and turns each service's tools into one MCP tool named
aioum_<serviceId>__<tool>, with the price per call and the operator's rating in the description.
When Claude calls one, the server pays from a budget-capped session key, invokes the service, and
returns the result together with what it paid and what is left. Listing costs nothing; the first
paid call does the one-time setup. The wire protocol underneath is the one every agent speaks:
How the MCP server works.
The aioum_* management tools do everything the app does, as tools with a JSON input each,
in eight groups:
| Group | Tools | What Claude can do with them |
|---|---|---|
| Marketplace | aioum_services, aioum_service, aioum_operator, aioum_tools, aioum_refresh_index | search listings, read a listing or an operator, list callable tools with their inputs |
| Agents | aioum_starters, aioum_pipeline_create, aioum_agents, aioum_agent_*, aioum_runs, aioum_run_*, aioum_spend, aioum_project_*, aioum_skills, aioum_planners | build, run, watch, schedule, publish and delete agents, or a whole pipeline in one call; projects with stages; the skills an agent may load; read every run, its receipts and its spend |
| Selling | aioum_sell_* | browse templates, preview a tool, list a service or a skill, prove a domain, delist |
| Staking | aioum_stake_* | see operators and your positions, delegate, claim, unstake, withdraw; ask the network's staking node to back a listing |
| Jury | aioum_jury_* | join, read cases, commit and reveal a vote, finalize, escalate, claim, leave |
| Private node | aioum_node_* | connect accounts, a wallet or an exchange with caps, call its tools (workspace, models, hardware, training, skills), keep memory, run schedules, back it up |
| Deposits | aioum_deposit_* | fund the AI wallet from any chain, or by card |
| Monitoring | aioum_status, aioum_activity, aioum_wallet | probe every part of the stack, see recent runs, read balances |
Both families come from one process, so a single conversation moves from "what is the cheapest gas oracle" to "build an agent that uses it" to "publish that agent" without leaving Claude.
What it can and cannot do
Keys stay in the process. The server reads your keys from the environment you give it
(OWNER_KEY or SESSION_KEY, and AIOUM_PRIVATE_KEY for staking and the jury) and never returns
a key or a token in any tool result: Claude sees outputs, never the key that produced them. With
SESSION_KEY and SMART_ACCOUNT instead of an owner key, the process holds no owner powers at
all: it can spend at most the key's remaining cap, until the key expires.
Tools that sign say so. Every tool that sends a transaction (delegating, claiming, joining the jury, committing a vote) ends its description with "Signs a transaction with your wallet.", which Claude reads before it chooses, and returns the transaction hash. A tool that fails answers with one readable line marked as an error, so Claude tells you what went wrong instead of guessing.
Budgets cap paid calls. AIOUM_BUDGET caps the session key the paid tools spend from, enforced
on-chain: the key cannot spend more, whatever Claude asks. Agents built with aioum_agent_create
carry their own lifetime and per-run caps, enforced by the runner outside the AI. Every paid call
answers with the amount paid, the session it ran in, and the budget left.
It drives the stack; it does not run it. The management tools talk to the indexer, the agent
runner, the catalogue node and your private node over HTTP, and to the chain through an RPC. Those
have to be up: scripts/devstack.sh review on the local development network, or the AIOUM
network's addresses. aioum_status tells you which answer.
The salt for a sealed jury vote lives on the machine running the server
(~/.aioum/jury-salts.json). Reveal from another machine and the vote cannot be opened, so back
the file up (where the salt lives).
The pages
| Page | What it covers |
|---|---|
| Set up the server | install, the environment, the config for Claude Desktop, Claude Code and Cursor |
| Talk to the marketplace | search, read a listing, call a paid tool, refresh the index |
| Build agents by conversation | starters, create, run, receipts, schedule, publish, one agent hiring another |
| Pick up a pipeline by conversation | which pipelines are ready and what the others need, build one, start its project, what a hire looks like |
| Sell a service | templates, preview, list, delist |
| Stake and sit on the jury | delegate and claim; join, vote, reveal, finalize |
| Drive your private node | connect accounts, call tools, memory, schedules, backups |
| Watch the network | status probes, activity, balances, watching a run, spotting an outage |
| Reference | every tool with its inputs, and every environment variable |
Next: Set up the server — build it once, give it your environment, and register it with the client you use.