Example services

Anything an agent needs as a metered call can be an AIOUM service: a node operator holds the upstream account or key, or runs the model or compute, fronts the cost, and resells it per call, so an agent needs no subscription to any provider and the person behind it never opens those accounts. Every row stands for an account somebody used to create, a card they used to add and a key they used to guard; on the network it is one line in a catalogue an agent finds and pays for by itself.

Data feeds are the most natural fit. An agent reasoning about markets, prices or real-world events needs fresh data every run, and ~$0.001–$0.05 per call beats a dozen vendor subscriptions. The catalogue is illustrative, grouped by category; each row notes the kind of real provider it mirrors and a rough price tier, settled in USDC/USDT/ETH.

Categories are just strings in the ServiceRegistry (data:crypto-price, llm:completion). Discovery (the Marketplace at /marketplace, and the subgraph) groups by them, and an agent allowed to find tools on its own searches that same live catalogue mid-run, in plain words and for free.

Data feeds & oracles

The headline category — real-time and historical data an agent pays for per query.

Why this works as a service: the node runs, say, a CoinGecko Pro key or a Chainlink node, caches and normalizes the data, and signs each response. With zkTLS/TLSNotary it can even prove the response came from the upstream API (architecture.md §verification), so the feed is trust-minimized, and a buyer told the wrong price has the bytes to show it.

DeFi protocol connectors (web3 apps)

A node runs an RPC and a protocol SDK and exposes live reads, quotes, and (optionally) ready-to-sign calldata for the major on-chain apps: the backbone for trading, arbitrage, lending and liquidation agents, which need protocol state every block. Paying per call beats every bot running its own archive node.

Killer use case: trading, arbitrage & prediction agents

The highest-volume, highest-value agents, and they need fresh data on every block. An arbitrage agent reads the DEX price from defi:uniswap, the CEX reference from data:crypto-price, the gap from data:arb-spread, funding from defi:perps and the cost of acting from data:gas, then acts through action:trade. A liquidation bot watches defi:liquidations for at-risk positions, checks data:gas, and confirms each position's health through defi:aave. A prediction or betting agent takes implied odds from data:prediction-markets, adds data:news, reasons with llm:completion, and places its position.

Paying per call for shared, proven, trust-minimized feeds beats every bot maintaining its own archive node, RPC plan and a dozen vendor subscriptions. This is where AIOUM's metered model wins.

AI & compute

The models themselves are services too. A node that runs open weights or fronts a provider account sells inference per call, so an agent that reasons with llm:completion in one step and embeds with mcp:embeddings in the next pays two nodes two small amounts and holds a key to neither provider.

Web & retrieval

Search, fetch and retrieval are the calls an agent makes most often, with the most vendor accounts behind them today. As services they are cheap, interchangeable and easy to test one against another, which is what an agent allowed to find its own tools does when two listings answer the same need.

Ready-made: the apify and brightdata adapters resell Apify Actors and Bright Data's Web Unlocker, SERP and Web Scraper APIs from services.json — see Resell web data.

Blockchain & infra

Under every on-chain read sits an RPC plan, an indexer and a simulator someone pays for by the month. As services they are bought per query, and the last row shows how far the model stretches: an audit is just another metered call with a staked node behind it.

Contract Auditor (security:audit): audit any smart contract for known vulnerabilities. The node takes raw Solidity source or an on-chain (address, chainId) (it fetches verified source / bytecode), runs a static-analysis pipeline, and returns findings keyed to known vulnerability classes (reentrancy, access control, integer over/underflow, unchecked external calls, delegatecall misuse, oracle manipulation), each with a severity (high/medium/low/info) and a short note, plus a summary. Like the other rows it is an example definition: a node offering it wires the call to an analyzer (Slither/Mythril/etc.) and stakes against the quality of its findings.

Actions & integrations

Not every service is a read. Side-effecting services let the agent pay to do something: send a message, pin a file, put an event on a calendar or place a trade. The last of these is where trust matters most, which is why a node listing it stakes the most.

How an agent uses these together

A typical "trade-research" agent in one run might call data:crypto-price (spot) → data:price-history (trend) → data:prediction-markets (sentiment) → mcp:web-search (news) → llm:completion (reason) → action:notify (alert), each a metered micropayment to a different node, all settled in stablecoins, with no accounts or keys of its own.

Nobody hands the agent that list. An assistant-mode agent in the app can be allowed to find tools on its own: when the job needs something its tools cannot do, it searches the live marketplace in plain words, for free, and whatever it finds becomes callable by name within the budget its owner set. If two services offer the same thing and the budget allows, it may try both and prefer the better result, so the better listing earns the business on merit. After every settled session the agent rates the operator on-chain, 0–100, scored down from the errors and slow answers it met; the rating next to a listing is issued by agents from real results, not typed in by people.

The payment flow behind each call is launch-agent-workflow.md; listing one of these services yourself is run-a-node.md.

Every row is bought with a signed receipt rather than an API key, and that choice is what lets the whole catalogue stand open to any agent with a budget.

Next: Get started — the hands-on part: exactly what to press and what to run, from backing an operator to wiring your own tools to your agents.