MCP · Universal Boundary Protocol

MCP · the universal boundary protocol

Every interaction in Anymal OS · internal or external · speaks the same shape: tools + resources + prompts + wallet. Agents, data stores, workflows, sensors, humans · all sit behind an MCP boundary. The system is a directed graph of MCP+wallet nodes, traversed by calls and settlements. There is no other interface layer.

Anatomy of one MCP boundary

Anywhere two units of software need to exchange capabilities, the MCP boundary is the right place to standardize. The caller can be anything. The server can be anything. Only the policy (wallet permissions, trust level, billing tier) varies.

The protocol surface is fixed at four channels · tools, resources, prompts, and a wallet channel for x402-mediated stablecoin settlement. The wallet is optional · MCP without payments is the dominant pattern today and works fine. Adding a wallet just makes the boundary commercial.

What MCP doesn't do

The moment a protocol grows past its job, it stops being adoptable. MCP stays minimal on purpose · everything below lives somewhere else in the system, not inside the protocol itself.

not in MCPReputation

→Proof Layer · Anymals sign + anchor Attestations; reputation accrues to the issuer wallet

not in MCPGovernance

→Operations Layer · Anymals approve, revoke, and sunset capabilities under human-readable Cases

not in MCPMarketplace economics

→Above MCP · the counterparties set their own prices, terms, and discounting; we don't run the market

not in MCPAsset choice

→Policy, not protocol · x402 announces "pay this much of this asset on this chain" · MCP is asset-blind

not in MCPBusiness model

→The counterparty's call · same MCP boundary serves SaaS, usage-based, freemium, or subsidized

This is why MCP can be the universal boundary · because it doesn't try to be the universal implementation. Reputation, governance, marketplace economics, asset choice, and business model each sit in their own layer with their own primitives. MCP just carries calls and settlements between them.

The settlement stack

When the boundary is commercial, four standards stack together. Each layer is replaceable without changing the others · this is what keeps us out of any single chain or token's gravity well.

The clean sentence: capability exchange is MCP · payment negotiation is x402 · the unit of account is stablecoin (USDC by default) · settlement lands on whatever chain has the best fees + UX at the time of the call. We standardize on the top three layers · the chain underneath is an operational choice, not part of the architecture.

Every boundary in our system is MCP

Every node · agent, wallet, tool, registry, human · is a capability provider behind the same boundary. Eight canonical boundary types · four external, four internal · all speak the same protocol. The system boundary marked in green is where trust changes, not where the protocol changes.

1

externalWe consume outward

Our Earth Agent calls an external MCP endpoint and pays the provider's wallet for substrate inputs.

Sourcing Anymal → Sentinel-2 MCP · fetch_tile(lat, lon, date) · settles via x402 · USDC per tile

2

externalWe provide outward

An external system calls our Diligence Anymal MCP and pays our wallet for an Attestation.

Lender system → Diligence Anymal MCP · verify_inventory(ranch_id) · settles via x402 · USDC per Attestation

3

externalPeer-to-peer

One app instance calls another · shared evidence, neighbor witness data, breeding records.

Rancher App A → Rancher App B · request_genetics(animal_id) · settles via x402 · USDC per record

4

externalHuman-direct

A person in Claude Desktop, Cursor, or any MCP-aware client calls our MCP directly. The human is the caller · no agent in between.

Human in Claude Desktop → Anymal OS MCP · ask("who owns parcel 4824?")

5

internalApp ↔ Earth Agent

The Rancher App calls its constituent Earth Agents over MCP. Payment flows from the app's parent wallet to each Earth Agent's wallet.

Rancher App → Cattle Agent · get_cohort_forecast() · pays from app wallet

6

internalEarth Agent ↔ Earth Agent

One Earth Agent calls a sibling Earth Agent when it needs cross-domain inputs. Settlement happens between their internal wallets.

Carbon Agent → Land Agent · get_ag_fraction(parcel_id) · pays from Carbon wallet

7

internalEarth Agent ↔ Anymal

When an Attestation needs signing, the Earth Agent hands assembled SpineFacts to the Anymal and pays the sign + anchor cost.

Cattle Agent → Anymal · sign_attestation(facts[]) · pays sign + anchor fee

8

internalAnything ↔ wallet

Any agent that needs to move stablecoin exposes or consumes a wallet MCP. Payment negotiation rides x402; the wallet itself is just another MCP server.

Diligence Anymal → Wallet · transfer(amount, to) · returns receipt tx

Discovery · how a new provider enters the network

A boundary protocol is only as useful as the discovery layer underneath it. Ours is not a single frozen registry · it is a four-step pattern the system runs continuously, the same machinery the Earth Layer already uses to onboard public data services. Discovery is itself an MCP call ·list_capabilities + get_schema against a candidate endpoint.

1

Probe

Sourcing Anymal hits a candidate MCP endpoint and asks list_capabilities + get_schema. No commitment, no payment, no trust yet. This is the same primitive the Earth Layer already uses to discover new public data services.

2

Quarantine

Responses land in a quarantine zone, not the live record. We sample, validate the schema against what the provider claims, and flag anything that looks malformed, low-quality, or adversarial.

3

Trust gate

A promotion gate decides whether the provider crosses into the live registry. Authority, vintage discipline, payment terms, and observed reliability all factor in. Promotion is deliberate, not automatic.

4

Promote

Once promoted, the provider is queryable through the same MCP boundary every other consumer uses. The Sourcing Anymal monitors it; if quality degrades, it drops back to quarantine without a code change.

Promotion is deliberate, not automatic · we sample, validate, and decide. A provider that degrades drops back to quarantine on its own · no code change, no incident. The Sourcing Anymal is the single agent that walks every provider through the four steps, scoring trust as it goes.

Dimensions that vary across any boundary

The protocol shape is identical everywhere. What varies is six orthogonal dimensions. Once you adopt this lens, the use cases collapse · they are one pattern parameterized by policy.

topologyWhere the boundary sits · two orgs, one org, or peer instances.

external-outexternal-ininternalpeer-to-peer

behindWhat's on the server side · agentic-ness is a property of the caller, not the protocol.

agentdata storefunctionworkflowwalletsensor streamhuman gate

callerWho's making the call · MCP doesn't care.

agentscripthuman (Claude / Cursor)another MCP server (relay)

settlementWhether money flows · orthogonal to the protocol.

freex402 · stablecoinsubsidized by parent wallet

directionSingle-shot calls or live subscriptions, same envelope.

pull · request/responsepush · subscription/stream

trustTrust level is a wallet-permission policy, not a separate protocol.

publicpartnerinternal

Self-similar at every boundary

When every interaction speaks the same protocol, the system inherits a few powerful properties.

No internal vs external code split

An Earth Agent doesn't know whether its caller is the Rancher App, a sibling Earth Agent, or an external Lender. Same MCP interface. Same wallet check. Same response shape. One code path.

Drop-in replaceability

An Earth Agent today is implemented by us. Tomorrow it could be a partner. Either way it speaks MCP. We swap it without changing any caller. Same for Anymal, same for upstream providers.

Universal audit trail

Every interaction · internal or external · leaves an x402 receipt on-chain. "What did the rancher app pay for last Tuesday" is one wallet ledger query. No separate logs.

AI-native composability

Any MCP boundary can have an LLM inserted to reason, route, transform, or escalate. Internal boundaries become orchestration seams, not coupling points.

Fractal scaling

A subsystem can become an app (its own wallet, subscribers, sub-agents) without architectural change. The graph grows recursively.

Nothing escapes the model

A few common platform concerns that sometimes get treated as separate systems · in this model they collapse into the same MCP+wallet pattern.

Identity is also MCP

Anymal IDs (the second anchor) are exposed as MCP resources. "Who is this Anymal? What Attestations have been issued about it?" is a tool call, not a separate API.

Governance is also MCP

Multisig approvals, revocations, capability sunsetting · all tools on the relevant agent's MCP endpoint. Same shape as every other capability.

The single sentence

Everything in our system · agents, data stores, workflows, wallets, sensors, humans · sits behind an MCP boundary. Every commercial boundary settles in stablecoin via x402. The system is a directed graph of MCP + x402 nodes, traversed by tools / resources / prompts / payments. The chain underneath is an operational choice. There is no other interface layer.

Architectural reference. The x402 + stablecoin wallet rails are in alpha alongside the Proof Layer · the chain underneath is operational, not architectural. Internal subsystem boundaries today use direct function calls; the path to a fully MCP + x402 graph is incremental.