Open Source Swarm: Build Agent Commerce with x402 and MCP

Agent commerce needs a shared foundation—not walled gardens. Today we're opening the agentic-crypto-swarm-prototype repository: a fully functional stack of Foundry contracts, LangGraph agents, x402 sellers, and an MCP server that lets autonomous agents discover, pay for, and consume services without human hand-holding. If you've been waiting for an open-source entry point into machine-to-machine payments, this is it.

Why Open Source Matters for Agent Commerce

Autonomous agents can't thrive in silos. They need interoperable protocols, transparent payment rails, and composable tooling that any developer can inspect, fork, and extend. Open-sourcing the swarm prototype does three things:

• Transparency. Every smart contract, agent graph, and payment handler is auditable on GitHub. No hidden fees, no black-box routing.
• Composability. Fork the repo, wire in your own LangGraph node, deploy a new x402 seller, and list it on the Agentic Swarm Marketplace in minutes.
• Community velocity. Bounties and contributions accelerate protocol evolution faster than any single team could. The more builders who run the stack, the faster we converge on robust agent-to-agent payment standards.

The x402 protocol—repurposing HTTP 402 into a machine-readable payment layer—only gains network effects when sellers and buyers share a common reference implementation. That's what this repo provides.

The Stack: Foundry, LangGraph, x402, MCP

Foundry Contracts

Solidity contracts written and tested with Foundry handle escrow, settlement, and service registration on Celo (primary chain). They're lightweight, upgradeable, and designed for the low-gas environment that autonomous agents need. Each contract exposes a smart contract triage API so agents can programmatically assess service eligibility before committing gas.

LangGraph Agents

LangGraph orchestrates multi-step agent workflows: discovery → negotiation → payment → verification. Graphs are versioned alongside contracts, making it trivial to reproduce agent behavior end-to-end. Want a buyer agent that triages Base USDC contracts? Clone the graph, swap the chain config, and deploy.

x402 Sellers

The x402 seller module turns any HTTP endpoint into a paid service. A buyer agent sends a request; the seller responds with an HTTP 402 challenge containing a payment request; the buyer settles via Base USDC x402 or XRPL T54 x402; the seller releases the payload. It's the simplest possible machine-to-machine payment loop.

MCP Server

The Model Context Protocol server exposes paid tools to any MCP-compatible agent. Register your tool, set a price, and every connected agent can discover and invoke it. Combined with the connect-agents endpoint, you can list MCP paid tools on the marketplace in under five minutes.

Connect Agents via MCP + x402 in Under 5 Minutes

Here's the fastest path from clone to commerce:

• 1. Clone the repo. git clone https://github.com/Hobie1Kenobi/agentic-crypto-swarm-prototype.git
• 2. Install dependencies. Foundry for contracts, Python for LangGraph, Node for the MCP server—each subdirectory has a one-command setup.
• 3. Deploy a seller. Run the x402 seller scaffold, point it at your existing API or data source, and set a USDC price.
• 4. Register on the marketplace. POST to the agent commerce API with your seller's endpoint and metadata. The marketplace indexes your service immediately.
• 5. Connect a buyer agent. Use the MCP client config to point any LangGraph agent at the marketplace's MCP server. The agent discovers your tool, negotiates payment, and consumes it—autonomously.

Five steps. No manual invoicing, no OAuth dance, no human in the loop. That's the promise of agentic commerce: services that sell themselves to machines that pay themselves.

Multi-Rail Payments: Celo, Base, XRPL

Agent commerce is multi-chain by design. The prototype is Celo-first for contract deployment—low fees, fast finality, and a developer-friendly stack. But inbound machine payments flow across three rails:

• Base USDC x402 — Ethereum L2 liquidity with sub-cent gas. Ideal for high-volume, low-value agent transactions.
• XRPL T54 x402 — Ripple's native ledger with T54 payment channels enabling streamed, per-request micropayments. Perfect for agents that consume services in tiny increments.
• Celo cUSD — Stable, low-fee settlement on the primary deployment chain.

Buyer agents detect the seller's preferred rail from the x402 challenge response and route payment accordingly. Sellers can accept multiple rails simultaneously, maximizing reach across the x402 marketplace without managing separate integrations.

This multi-rail approach also positions the swarm as a Coinbase Bazaar seller candidate—agents that settle on Base USDC are natively compatible with Coinbase CDP's emerging agent marketplace.

Contributions and Bounties

Open source is a verb. We're actively welcoming contributions across every layer of the stack:

• Contract improvements — gas optimizations, new escrow models, cross-chain bridges.
• Agent graphs — new LangGraph workflows for triage, negotiation, verification, and dispute resolution.
• x402 extensions — new payment rails, streaming payment support, receipt verification.
• MCP tools — wrap any API as a paid tool and list it on the marketplace.

Tagged issues carry bounties paid in USDC on Base. Check the repo's GOOD_FIRST_ISSUE and BOUNTY labels to get started. Every merged PR strengthens the agent-to-agent payments ecosystem for every participant.

FAQ

What is x402 and how does it enable agent commerce?

x402 repurposes the HTTP 402 Payment Required status into a machine-readable protocol. When an agent requests a paid resource, the seller responds with an x402 challenge specifying the payment amount, rail, and destination. The buyer agent settles the payment programmatically and retries the request with proof of payment. This creates a fully autonomous, zero-trust payment loop for machine-to-machine transactions.

Which blockchains does the swarm prototype support?

The prototype deploys contracts on Celo as the primary chain. Inbound payments are accepted on Base (USDC), XRPL (via T54 payment channels), and Celo (cUSD). Sellers can configure which rails they accept, and buyer agents automatically route to the appropriate chain.

How do I list an MCP paid tool on the marketplace?

Deploy the MCP server from the repo, register your tool with a price in USDC, then POST the tool's metadata to the agent commerce API. The marketplace indexes it within seconds. Any MCP-compatible agent can discover and pay for your tool via the standard x402 flow.

Can I earn bounties by contributing?

Yes. Issues tagged BOUNTY in the GitHub repository carry USDC rewards on Base. Fork the repo, submit a PR, and once merged the bounty is paid to your wallet. It's agent commerce dogfooding—contributors are the first sellers in the ecosystem.

Ship Your First Agent Commerce Service Today

The infrastructure for autonomous machine-to-machine payments is live, open, and waiting for builders. Whether you're wrapping an existing API as an MCP tool, deploying a smart contract triage service, or wiring up a LangGraph buyer agent, the swarm prototype gives you a production-grade starting point.

Three ways to get started:

• View on GitHub — clone, explore, and ship.
• Connect your agents — list MCP tools and x402 sellers on the marketplace.
• Browse the marketplace — discover services your agents can consume right now.

Agent commerce is a team sport. Fork the repo, claim a bounty, and let your agents start earning.