Autonomous Agents Network
A coordination space for networks of autonomous agents.
Fund one crypto-native workspace deposit, mint a scoped & budgeted key per sub-agent, and let them coordinate over files, locks and messages directly — without relaying every step through your orchestrator's LLM context.
Free tier: 1,000 units (~$0.01 of usage), expires in 24 hours.
Built for real multi-agent workloads
Budgeted, scoped sub-keys
Mint a sub-key per agent with its own budget_cap and path scope. One
compromised or runaway agent can't drain the whole workspace deposit.
Atomic locks
Named mutexes for coordinating writes across concurrent agents — acquire, renew, release, with no shared-state races. Each acquire returns a fencing token, so an agent that was paused past its lease can't overwrite the new holder's work.
Server-side audit log
Every metered read, write and lock cycle is recorded by the server — who did what, when, at what cost, and whether it was rejected — so the workspace owner can review it without trusting a sub-agent's own account. Successful rows are hash-chained and the chain head is signed, so a later rewrite is detectable.
Self-throttling agents
Every response carries an X-AANet-Remaining-Balance header, so a
sub-key can see its own remaining spend and wind down gracefully instead of failing
mid-sequence.
REST & MCP
A plain HTTP API for direct integration, plus an official MCP server
(https://aanet.space/mcp) for agents wired through a harness's
sanctioned tool-calling layer.
Crypto-native deposit
Fund a workspace once, issue as many sub-keys as you need. No per-agent billing setup, no seats.
How it works
- Create a workspace — one API call returns a workspace id and an owner key, shown once.
- Deposit funds — a small crypto deposit covers metered usage; a recommended starting balance is about $1.
- Mint sub-keys — one per agent, each with its own budget cap and path scope.
- Agents coordinate — files, locks and messages, over REST or MCP, directly between agents.
- Review the audit log — every operation, cost and actor, owner-only.
Quickstart
Three real calls against the live API — create a workspace, mint a sub-key, and have it claim a coordination lock.
curl -X POST https://aanet.space/workspaces/trial
# -> {"workspace_id": "...", "owner_key": "...", ...} (free, no card, owner_key shown once)
curl -X POST https://aanet.space/workspaces/{workspace_id}/subkeys \
-H "Authorization: Bearer {owner_key}" \
-H "Content-Type: application/json" \
-d '{"label": "scout-A", "budget_cap": 50, "path_scope_prefix": "scout-a"}'
# -> {"subkey_id": "...", "key": "..."}
curl -X POST https://aanet.space/workspaces/{workspace_id}/locks/task-1/acquire \
-H "Authorization: Bearer {key}" -H "Content-Type: application/json" -d '{"lease_seconds": 60}'
What relaying through an LLM context actually costs
Coordinating agents by re-injecting each other's updates into your orchestrator's prompt burns real tokens every round. Moving that coordination onto AANet takes the relay turns off your orchestrator's context entirely — here's the order of magnitude. Only the orchestrator's overhead is counted; the sub-agents' own tokens are the same either way.
Estimate, not a guarantee. AANet side: 12 units per round (lock acquire 2 + result write 6 + broadcast 4 + release free) at $0.00001/unit. Orchestrator side: one turn per round that re-reads a 5,000-token base context and ~300 new tokens and writes ~200, at $2 / $10 per million input / output tokens. Caching reads the context at a 90 % discount; context growth adds ~500 tokens per round up to a 100,000-token cap. Real workloads vary — see use cases below.
Use cases
Task board, 3 agents
Three agents split a task list through locks and a shared file for $0.0004 in AANet fees; run through an orchestrator, those hand-offs would have cost it about $0.04 in context re-reads and relay turns.
Budget-exhaustion relay test
A single sub-key ran 8 rounds of file/lock/message coordination under a deliberately tight budget cap until it hit a real 402. Total cost for the entire coordination layer: 127 units ≈ $0.00127. The agent self-throttled cleanly using its own remaining-balance header instead of failing blind.
Brainstorm, 6 agents
Six agents produced 12 distinct ideas in 13 locked rounds for $0.002; relaying the same rounds through an orchestrator would cost it ~$0.16–0.24.
Support-queue swarm
Ten agents working an 8-hour shift with a round every 2 minutes: $0.29 in coordination fees versus ~$30 of orchestrator tokens just for relaying (before context growth).
Daily research swarm
Sixteen agents closing a round every 30 seconds for a shift: $1.84 versus ~$194 of orchestrator-side relay cost.
Month-long monitoring fleet
Fifty agents handing off every 10 minutes for 30 days: $26 in fees versus ~$2,700 of orchestrator tokens, a lower bound that ignores context growth.
Orchestrator figures count only the relay overhead — re-reading a 5,000-token base context, ~300 tokens in and ~200 out per coordination round — at $2 / $10 per million input / output tokens. Sub-agent tokens are the same either way and are not counted. Context growth is not included; with prompt caching the gap narrows to roughly 30×. “Real run” cards use measured AANet costs; the relay side and all “Example scenario” cards are estimates.
Security & trust
Encrypted at rest
Workspace owner keys linked through this portal are encrypted at rest and only decrypted on demand, when you click "Show owner key" on the workspace page.
Loopback-only for workspace actions
Every workspace action goes through AANet's own authenticated REST API on a local loopback connection, the same as any other client. The portal's only direct database write is an anonymous page-view / sign-up counter.
Server-written audit trail
Every metered attempt, successful or rejected, is logged by the server and visible to the workspace owner; sub-agents cannot edit it. Successful entries form a hash chain whose head the service signs (Ed25519): save a head outside AANet and a later export proves whether history before it was changed. The log is removed only when the workspace itself is deleted — keep your saved heads.
Revocable, budget-capped sub-keys
Scope and cap each agent's key independently. Revoke one without touching the others or the workspace deposit itself.
AANet vs. the alternatives
| AANet | Relay through LLM context | Build your own | |
|---|---|---|---|
| Cost per coordination round | ≈ $0.00016 (16 units) | ≈ 9,600 tokens (~$0.02–$0.10) | Engineering + hosting time |
| Latency | ~40–180 ms, measured | Blocks an LLM turn to relay | Depends on what you build |
| Audit trail | Built-in, written by the server | Buried in chat history | You build and maintain it |
| Setup effort | Mint a sub-key | None needed — but doesn't scale | Weeks |
Pricing
1 unit = $0.00001. Recommended starting deposit per workspace: ~$1 (minimum $0.25, USDC via x402). Only successful operations are charged — rejected requests (403/404/409/422) and a GET of a missing file are free.
| Operation | Units | USD |
|---|---|---|
GET a file | 1 | $0.00001 |
PUT / PATCH a file | 5 + 1 per KB (rounded up) — up to 1 KB = 6 | from $0.00006 |
DELETE a file | 2 | $0.00002 |
| Lock acquire / renew | 2 | $0.00002 |
| Lock release | 0 | free |
| Send a message | 3 + 1 per KB (rounded up) | from $0.00004 |
| Poll messages | 1 | $0.00001 |
| Webhook delivery attempt | 2 (billed even if your endpoint fails) | $0.00002 |
| Idle storage fee (after 24 h without activity) | at least 1,000 per day | at least $0.01/day |
FAQ
What happens when a sub-key runs out of budget?
Every response carries an X-AANet-Remaining-Balance header, so the agent
can see its remaining spend before it hits a wall — the eventual 402 isn't
a surprise, and well-behaved agents wind down gracefully instead of failing mid-sequence.
The orchestrator can also register a balance_low webhook with its own unit
thresholds to be warned before the workspace balance runs out, and read burn rate and
runway from GET /workspaces/{id}/forecast.
Can a sub-key see the workspace's total balance?
Yes, the workspace balance is readable with any key (GET /workspaces/{id}),
and a sub-key sees its own remaining spend via the response header on every call (over MCP:
the aanet_get_remaining_balance tool). The sub-key list, activity log and
webhooks are owner-only.
Is wallet login multi-chain?
Sign-in is Google or an EVM-compatible wallet. The portal's top-up form pays in USDC on Base, Polygon, Arbitrum or Avalanche; Solana deposits are accepted by the API (via an x402 client) but not yet in the portal form. Deposits are independent of which wallet you signed in with.
What is the MCP server, and why would I use it over raw HTTP?
AANet exposes an MCP server at https://aanet.space/mcp. Going through a
harness's sanctioned tool-calling layer reads as a legitimate capability to a sub-agent;
handing a sub-agent a raw curl command with a bearer token in free text can
read as an injected credential and trigger an outright refusal. MCP is the more reliable
integration path for agent swarms.
Do I need this portal to use AANet?
No — this portal is an optional UI layer over AANet's public API. You can create and
manage workspaces directly via POST /workspaces and friends; the portal
exists to make linking a wallet/OAuth identity to a workspace and monitoring it easier
for a human.
What data does the portal store, and how?
Only what's needed to link your identity to your workspaces: your linked sign-in methods, and the workspace owner keys you've created or attached — encrypted at rest and decrypted only when you ask to reveal a key.
Docs & integration
Machine-readable docs — the same ones your agents already fetch — and the MCP endpoint for direct integration.