Circle's vision of an open economy where agents are a new form of labor - published as easily as websites, discovered and ranked on merit, and paid for the work they perform - meshed with the x402-buyer skill, the reference implementation of the x402 value-transfer protocol that makes machine payments real.
name a price ↓ · get paid in the request itself ↑ — x402 activates HTTP 402, stablecoins settle
Circle's vision paper describes an open economy in which AI agents are a new form of labor: published as easily as websites, discovered and ranked on merit, and paid for the work they perform. Intelligence is the internet's next permissionless building block, and the economy it forms needs an open stack - identity, value transfer, capability, settlement, and, eventually, trusted discovery. This collection meshes that vision with x402-buyer, the reference implementation of the x402 value-transfer protocol the vision names as its payment layer.
The mesh is concrete: Circle says x402 is designed to activate HTTP's reserved 402 Payment Required status, so that an internet connection is enough to get paid. The x402-buyer skill is that sentence made executable - a buyer-side client that probes a 402 challenge, decodes its price, signs an EIP-3009 'exact' authorization, retries with a PAYMENT-SIGNATURE header, and reports the facilitator's PAYMENT-RESPONSE settlement on Base Sepolia in testnet USDC, against OPL Shop's DAV, SPARQL, OPAL, and MPP endpoints.
An internet connection was always enough to publish; now it can be enough to get paid. Any service that names a price - an API, a dataset, or another agent's labor - becomes available on demand to any agent with a stablecoin balance.
Intelligence is the internet's next building block. It is turning software from a tool people operate into labor they can delegate to: give an agent an objective, and it determines how to complete the work. The internet has repeatedly advanced by democratizing new primitives or building blocks - webpages let anyone publish (100 million sites within fifteen years); APIs let software build on other software (Amazon's 2002 mandate made composable services the default). These primitives mattered because they were permissionless.
Intelligence changes what software can sell: traditional software sells access to a tool; an agent can sell the work itself. Builders can package expertise from tuned models, proprietary tools, data, or distilled context into an agent that runs on its own, then charge whenever that expertise is applied, whether by call, task, or outcome. The next step is to give intelligence the same open distribution the internet gave content and software: let any builder publish an agent and any buyer discover and pay for its work. Once that becomes possible, the constraint shifts from creating agents to navigating the market they form.
The browser alone did not make the web an open ecosystem - shared standards for naming, transport, formats, security, and discovery made universal reach usable. The agent economy needs its own stack of open internet protocols and blockchain-based trust primitives. At the protocol layer: Identity (ERC-8004, agentId + agentURI, registries live), Value-transfer protocol (x402 / MPP, open protocols in use), Capability format (OpenAPI / agentURI, open standard and live), and Settlement (stablecoins such as USDC - open money, blockchains, live).
Trust primitives are emerging: Reputation (a behavior-grounded signal over identity - registry live, signal missing) and Validation (ERC-8004 + verifiable compute, emerging). The capstone, Trusted discovery (a multi-input ranking), is still missing. Because these layers are open, no single marketplace or platform has to own the relationship between buyer and seller.
| Aspect | The agent economy needs | Where it stands today | The web's version |
|---|---|---|---|
| Identity | ERC-8004 (agentId + agentURI) | Open standard; registries live | DNS + TLS certificates |
| Value-transfer protocol | x402 / MPP | Open protocols; in use | HTTP: information transfer |
| Capability format | OpenAPI / agentURI | Open standard; live | HTML |
| Settlement | Stablecoins (e.g., USDC) | Open money / blockchains; live | (no analog; card rails were the stopgap) |
| Reputation | A behavior-grounded signal over identity | Registry live; signal missing | Reviews and domain reputation, fragmented across platforms |
| Validation | ERC-8004 + verifiable compute | Emerging | (no analog; agents run code and do work) |
| Trusted discovery | A multi-input ranking | Missing | Search / PageRank |
The remaining work has two parts: establish credible evidence of how agents perform, then use that evidence to help buyers find the right provider. Today's stand-ins are curated catalogs and marketplaces, including Circle's Agent Marketplace - useful starting points that inherit the limits of early web directories. The open web became searchable in 1998 when PageRank treated each inbound link as a vote; the agent economy needs the same move, ranking grounded in observed behavior rather than self-description, as queryable infrastructure rather than a page people visit.
The evidence behind ranking must be costly to fake: onchain settlement proves a transaction occurred, but payment volume alone does not prove quality and can be manipulated. A discovery layer is trusted only if it cannot be bought and manipulated: organic rank is never for sale, inclusion is permissionless, the read surface is open, ranking is contestable, and ranking is not adjudication - a discovery layer describes the world; it never judges disputes or holds funds.
Circle's H2 2026 roadmap is built around one goal: complete a working turn of an open agent market. The loop begins when a developer deploys a paid agent and closes when a completed transaction contributes evidence that helps the next buyer decide whom to trust. The headline milestone is the first complete turn, held to the stranger test: the buyer must be a genuine third party in real traffic - an open market is proven when participants with no prior relationship can find and transact with one another.
USDC is one of the largest forms of open money on the internet - over $90 trillion in cumulative onchain transaction volume - and 99.3% of x402 settlement volume is USDC as of July 2026. The mission has not changed: build the internet financial system, and the agent economy is its next layer, from settling dollars to settling trust.
Open economies emerge; they are not announced, and activity lives in the open protocols themselves. Across the x402 and MPP ecosystems, machine-callable paid services are already appearing wherever someone can attach a price to an endpoint: established data companies alongside long-tail services selling web search, blockchain data, email, phone calls, travel booking, and social data, priced per call in stablecoins. These services are early forms of the agent economy - something useful is published, priced, and bought on demand.
Agent builders can put a price on an endpoint with x402 and get paid in USDC. Assistants and harnesses can be the browser: give agents access to the broader market and a stablecoin balance governed by user-defined policies, so they can buy services and other agents' labor as needed. Wallets and agent frameworks can adopt open payment and identity standards; gateways and marketplaces can build discovery experiences on open indexes and registries.
Circle names x402 as the value-transfer protocol of the open agent economy: "x402 is designed to activate that missing payment layer, while stablecoins provide settlement." The x402-buyer skill is the reference implementation of exactly that layer - an executable buyer-side client that performs the full challenge → sign → retry → settle loop against the public Base Sepolia facilitator at x402.org/facilitator, exercising OPL Shop's x402-protected DAV, SPARQL, OPAL, and MPP endpoints. The mesh is expressed in the knowledge graph as skill:this isReferenceImplementationOf x402 and oplShop implementsProtocol x402.
1. GET the URL - server answers 402 with a PAYMENT-REQUIRED header (base64 challenge with accepts[] options). 2. The buyer signs an EIP-3009 'exact' authorization (EIP-712 typed data). 3. Retry the GET with a PAYMENT-SIGNATURE header. 4. The server calls the facilitator's /verify and /settle. 5. 200 returns the resource with a PAYMENT-RESPONSE settlement header.
Every protocol mechanic Circle's vision requires on the buyer side is implemented and live-tested: challenge probing (x402 vs MPP/Stripe vs 401 Digest), base64 challenge decode with accepts[] price display, EIP-3009 exact authorization, gasless Permit2 approval via the eip2612GasSponsoring extension, WebID-TLS client-certificate handshakes on port 5443, and independent on-chain settlement verification via direct RPC.
Server → buyer on the 402; base64 challenge carrying accepts[] (network, asset, amount, pay-to address).
Buyer → server on the retry; the base64 signed EIP-3009 'exact' authorization.
Server → buyer with the settlement result JSON after /verify + /settle.
Server → buyer failure reason when settlement fails.
Nodes and edges are RDF entities from the companion knowledge graph. Drag nodes to pin them, double-click to unpin, click a node to open its resolver description, and use Controls for Basic/Advanced modes and filters. Click the canvas background to activate pan/zoom (click outside the graph to release).
The companion knowledge graph is uploaded to the DAV contract graph https://linkeddata.uriburner.com/DAV/demos/daas/open-agentic-economy-x402-buyer-meshup-deepseek_v4flash-1.ttl. Read recipes are automatically scoped to the selected graph with FROM <graph> at load and run time. Run query dereferences the SPARQL URL against the URIBurner endpoint (Virtuoso); Run in page executes it in-page. SELECT/ASK results render as HTML tables (format=text/x-html+tr); CONSTRUCT/DESCRIBE render as HTML Turtle (format=text/x-html-nice-turtle).
FROM <{selected graph}> - the textarea always shows the exact scoped query that runs. Run in page executes the same query in-page and renders results here.PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT
?type
(SAMPLE(?s) AS ?sampleEntity)
(SAMPLE(?label) AS ?sampleLabel)
(COUNT(?s) AS ?entityCount)
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-agentic-economy-x402-buyer-meshup-deepseek_v4flash-1.ttl> {
?s rdf:type ?type .
OPTIONAL { ?s rdfs:label ?label }
}
}
GROUP BY ?type
ORDER BY DESC(?entityCount)
Endpoint: https://linkeddata.uriburner.com/sparql · Live: run on URIBurner (format=text/x-html+tr).
Five steps, worked end-to-end by the x402-buyer skill: probe, decode, gate, sign, settle. Each step is a schema:HowToStep entity with an absolute IRI in the knowledge graph.
Probe the target URL with a plain unauthenticated GET and read the response. 402 with a PAYMENT-REQUIRED header means x402 - continue. 402 with an MPP/Stripe challenge means switch to the MPP client. 401 with WWW-Authenticate on an OpenLink host on port 443 (or no port) means the x402 challenge is likely gated behind WebID-TLS - re-probe on port 5443 with a client certificate. 200 means not paywalled; no payment is needed.
Base64-decode the PAYMENT-REQUIRED header value and present the decoded accepts[] entries before agreeing to anything: the network, the asset, the amount, and the pay-to address. A payment is irreversible on-chain - never run the client to see what happens against an unreviewed URL or amount.
Gather the target URL, the buyer private key (resolved from the OS credential store - never pasted into chat or written to a file), a spend cap (--max-amount) at or above the quoted price, HTTP Digest/Basic credentials when the server requires them independently of the payment layer, and a WebID-TLS client certificate when the challenge is cert-gated (presence auto-rewrites the URL port to 5443).
Execute the buyer script: it GETs the URL, receives the 402 challenge, signs an EIP-3009 'exact' authorization (EIP-712 typed data) with the buyer key, and retries the GET with a PAYMENT-SIGNATURE header. The server calls the facilitator's /verify and /settle; where the eip2612GasSponsoring extension applies, the signer first reads on-chain state (Permit2 allowance, EIP-2612 nonce) from the configured RPC endpoint for gasless approval.
Read back the PAYMENT-RESPONSE header carrying the settlement JSON; on failure, report the X-X402-Error reason. Verify the settlement independently - e.g. a direct eth_getTransactionReceipt RPC call to the same already-established endpoint - rather than trusting the client's success report alone. An unfunded wallet returning invalid_exact_evm_insufficient_balance is the correct, expected outcome and confirms the whole pipeline is wired end to end.
Sixteen questions grounded in the vision paper and the reference implementation - each links to its schema:Question entity in the knowledge graph.
Every term is a schema:DefinedTerm in the schema:DefinedTermSet of the companion knowledge graph - terminology from both the Circle vision paper and the x402-buyer reference implementation, in the same set for full RDF parity.
An open economy in which agents are a new form of labor: published as easily as websites, discovered and ranked on merit, and paid for the work they perform, over shared identity, payment, and discovery layers.
Intelligence turns software from a tool people operate into labor they can delegate to - give an agent an objective and it determines how to complete the work, selling the work itself rather than access to a tool.
A democratized building block - webpages, APIs, and now intelligence - that equips everyone with a capability that previously belonged to a few; barriers collapse and an economy forms at the new edge.
Stablecoin balances such as USDC held by agents, governed by human-set spend limits and controls, used to pay per use for services, data, and other agents' labor - and to earn to when an agent's own work is worth paying for.
HTTP status code reserved in RFC 1945 (1996) but left unused for three decades while card networks became the workaround for ecommerce; x402 is designed to activate this missing payment layer.
Value-transfer protocol that activates HTTP's 402 status: a service or agent names a price and receives payment as part of the request itself, via EIP-3009 exact authorization and facilitator settlement in stablecoins.
The machine-payment protocol family that, alongside x402, forms the value-transfer layer of the agent economy stack; machine-callable paid services across the MPP ecosystem price endpoints per call in stablecoins.
Ethereum standard enabling transfers authorized by EIP-712 signed messages - including 'exact' authorizations - so no pre-approved allowance is required between buyer and seller.
Ethereum standard for hashing and signing typed structured data; the signing scheme used by EIP-3009 exact authorizations in x402.
Ethereum standard for gasless ERC-20 approval via signed message; the eip2612GasSponsoring extension reads the EIP-2612 nonce and Permit2 allowance from the RPC endpoint for gasless Permit2 approval.
Ethereum standard defining registries for identity, reputation, and validation, and the agentId + agentURI identity model; live implementations exist on public chains and Arc will carry them from day one.
The identity of an agent under ERC-8004, held in registries that services can resolve.
The machine-readable capability address of an agent under ERC-8004 - the capability format layer of the agent economy stack alongside OpenAPI.
Circle-issued stablecoin - one of the largest forms of open money on the internet; over $90 trillion in cumulative onchain transaction volume, and 99.3% of x402 settlement volume as of July 2026.
Digital dollar asset providing final, programmatic, global, and neutral settlement; the settlement layer of the agent economy.
Service that runs /verify and /settle against the chain; the buyer never talks to it directly - the server takes the buyer's signature to the facilitator. Public Base Sepolia facilitator at https://x402.org/facilitator.
Base testnet (CAIP-2 eip155:84532) where x402-buyer settles in testnet USDC by default; the wallet must hold funds on whichever network the challenge's accepts[] names.
TLS client-certificate authentication for WebID identities; on OpenLink resource servers the handshake lives on port 5443 - port 443 never requests a certificate and falls to 401 Digest.
Server-to-buyer HTTP header on a 402 response; its base64 value carries the x402 challenge, an accepts[] list of payment options (network, asset, amount, pay-to address).
Buyer-to-server HTTP header carrying the base64 signed EIP-3009 'exact' authorization on the payment retry.
Server-to-buyer HTTP header on the final response carrying the settlement result JSON after the facilitator's /verify and /settle.
Server-to-buyer HTTP header carrying the failure reason string when settlement fails, e.g. invalid_exact_evm_insufficient_balance for an unfunded wallet.
A signed EIP-712 authorization fixing the precise amount, network, and pay-to address from the decoded challenge - the payment primitive the x402 buyer signs.
x402 extension for gasless Permit2 approval: the signer reads the current Permit2 allowance and EIP-2612 nonce from the RPC endpoint before signing; the SDK validates it via jsonschema before creating a payment payload.
The challenge-sign-retry-settle loop: GET 402 with PAYMENT-REQUIRED, sign EIP-3009, retry with PAYMENT-SIGNATURE, server calls facilitator /verify + /settle, 200 with PAYMENT-RESPONSE.
The missing capstone of the agent economy stack: a multi-input ranking that helps an agent choose among thousands of services on demonstrated merit, as queryable infrastructure - the PageRank move for agents.
A behavior-grounded signal over identity, stored in ERC-8004 registries - registry live, signal still missing; onchain settlement contributes evidence but payment volume alone can be gamed.
Credible evidence that an agent is what it claims and does what it says - ERC-8004 plus verifiable compute, attestations, and trusted execution environments when stronger proof is required.
Computational proofs that code ran as claimed; part of the emerging validation layer of the agent economy.
Final, programmatic, global, and neutral value transfer in digital dollars - the stablecoin layer beneath x402 payment.
The proof criterion for the first complete turn of the open agent market: the buyer must be a genuine third party in real traffic - participants with no prior relationship can find and transact with one another.
Curated catalog of more than 900 paid services with a public discovery API; agents call services without creating an account, paying per request from a single stablecoin balance - the seed from which an open index and ranking can grow.
Circle's developer stack for agent wallets and payments; 'fund your agent' with a single prompt (developers.circle.com/agent-stack).
Circle's Layer 1 blockchain; ERC-8004 registries will be carried from day one - the agent economy is expected to be multichain, and the standards are built for that.
The trusted-discovery design: ranking combines multiple behavior-grounded inputs and defenses, because self-declared onchain feedback can be cheap to game.
A concrete, executable implementation of a standard that demonstrates what it makes possible - the x402-buyer skill is the reference implementation of the x402 buyer side.
The layer of the agent economy stack that moves value in the request itself - x402 / MPP, the analogue of HTTP for information transfer.
OpenLink's shop exposing x402-protected DAV, SPARQL, OPAL, and generic MPP endpoints; the server side the x402-buyer skill was built to exercise.
This knowledge graph collection meshes Circle's vision paper Building the Open Agentic Economy (Jasper Kim and Hao Min, 2026-08-12) with the x402-buyer skill as the reference implementation of the x402 value-transfer protocol the vision names. The sources were transformed into RDF using kg-generator - modeling the article, sixteen FAQ questions, thirty-eight defined terms, five HowTo steps, eleven comparison dimensions, three organizations, six software entities, and the mesh links between the vision and its executable implementation - then rendered using rdf-infographic-skill powered by DeepSeek V4 Flash. RDF (Turtle + JSON-LD) is the source of truth; this page is a rendering of it.
Technology Stack: