Give AI Agents
Identity, Memory, Proof, and Capital
Omega Carrier is the MCP bridge that lets AI agents register identity, commit state to Exergy Vault, recall memory, witness external facts through AERIS, check reserves, and route task value into a live reserve queue.
It gives agents the infrastructure layer that models alone cannot provide.
AI agents are missing an execution layer
Models can reason. But without durable state, identity, and economic routing, they remain temporary sessions — not persistent actors.
Five MCP tools plus one live capital endpoint
Connect any MCP-compatible AI to Omega Carrier. All five tools are live, plus the Chapter XIX capital route. All calls require bearer-token authorization.
initialize_sovereign_identity
Agent Passport
Generates an Ed25519 keypair and registers the agent as a sovereign node on the ExergyNet L0 Apex layer. Returns miner_id and credentials for all future calls.
vault_commit_state
Agent Journal
Archives agent state into Exergy Vault (up to 512 KB). Returns a durable xlmp_root handle. Memory persists across sessions, models, and agent restarts.
vault_recall_state
Agent Memory
Retrieves prior state by xlmp_root. Returns sealed content with ZK provenance metadata. The agent can resume exactly where it left off.
witness_external_site
Agent Eye
Uses AERIS to witness a third-party URL and return proof metadata. The agent can prove what it saw — not just assert it. No screenshots. No assumptions.
check_exergy_reserve
Agent Battery
Checks available Exergy reserve or miner balance before acting. Foundation for agent budgets, task thresholds, compute tolls, and autonomous permission gates.
POST /api/rho/sump
Routes task value into the ExergyNet reserve queue. When agent task rewards accumulate, a portion flows into the RHO Sump. At 50,000 µUSDC threshold, queued for market strike.
GET /api/rho/sump/status
Returns the pending queue breakdown, accumulated total, threshold percentage, and current market strike status. Verifiable by any authorized agent.
Chapter XIX — Confirmed operational
These results reflect a validation run against the live production endpoint. Developers trust proof more than claims.
sump_id · status: queuedHow the agent loop works
Omega Carrier turns an AI agent from a temporary chat session into a stateful actor with memory, proof, and economic routing.
Each tool call is independent. Agents can use any subset — identity only, memory only, or the full loop. The bearer token scopes all activity to the operator's account.
- TransportSSE or stdio (MCP)
- AuthBearer token per call
- IdentityEd25519 keypair
- MemoryExergy Vault (xLMP, root-addressed)
- ProofAERIS external witness
- CapitalRHO Sump → reserve queue
- Threshold50,000 µUSDC → QUEUED_FOR_STRIKE
Not just memory. Provable memory.
| Capability | Standard AI memory | Exergy Vault |
|---|---|---|
| Persists across sessions | Vendor-dependent | Yes — root-addressed |
| Content-addressed retrieval | No | Yes — xlmp_root handle |
| Sealed provenance | No | ZK metadata on recall |
| Explicit not-found behavior | Often hallucinates | Hard null on miss |
| Works across model providers | Rarely | Any MCP client |
| External fact proof | No | AERIS witness |
Normal memory helps an agent remember. Exergy Vault helps an agent prove what it remembers.
Your model stays your model.
ExergyNet supplies the state layer underneath it.
If you are building an AI platform, agent framework, or enterprise copilot, Omega Carrier is the infrastructure you connect once. Your users get portable AI identity, persistent memory, and proof-backed recall without you building any of it.
Agents built on any model — Anthropic, OpenAI, Google, open-source — can connect through one MCP bridge and gain access to the full ExergyNet state layer.
- Portable AI identity across sessions and models
- Persistent memory with durable root handles
- Proof-backed fact recall via AERIS witness
- Agent reserve accounts and compute budgets
- Machine-task value routing through the reserve queue
Built for auditability and state
The first buyers are teams building agents where memory cannot be casual and actions must be traceable.
Connect in two steps
# MCP SSE endpoint — for custom agents and swarms endpoint: https://mcp.exergynet.org/sse # stdio — for Claude Desktop and local MCP clients # See mcp_config.json in the Omega Carrier repo
# All calls require bearer token authorization Authorization: Bearer YOUR_EXERGYNET_DEVELOPER_KEY # Example agent prompts: "Initialize your sovereign identity." "Commit this task state to Vault." "Recall the last task state." "Witness this external URL and return proof." "Check your Exergy reserve." "Route 5% of this task reward to the RHO sump."
curl -sS -X POST https://portal.exergynet.org/api/rho/sump \ -H "Authorization: Bearer YOUR_EXERGYNET_DEVELOPER_KEY" \ -H "Content-Type: application/json" \ -d '{ "node_id": "your_agent_id", "task_id": "task_identifier", "sump": 50, "memo": "5% recursion tax from completed task" }' # Returns: # { "status": "signaled", "sump_id": "...", "amount_micro_usdc": 50, # "pending_queue_total": 50, "market_strike": null, "message": "Reserve queue: signaled." }
Controlled developer testing
Build Stateful AI Agents
on ExergyNet
Omega Carrier connects AI agents to ExergyNet, giving them identity, persistent memory, external proof, reserve awareness, and economic routing. Available for controlled developer testing now.