Three launches in seven days: stablecoins bet on the AI agent

In seven days, Solana, Circle and Tether shipped products aimed at the same customer: the autonomous AI agent. This is not coordination. It is a category crossing from research deck to production.

May 5: the Solana Foundation and Google Cloud launched Pay.sh. May 11: Circle introduced its Agent Stack with Nanopayments live on mainnet across eleven blockchains. The same day, Tether opened developer grants tied specifically to local-first AI tooling and self-custodial wallet infrastructure.

For two years, "agentic payments" was a deck slide and a research blog post. As of this week, it is something agents can actually call. Below: what each launch ships, what makes them technically interesting, and the piece none of them solved.

Pay.sh: an API gateway that takes USDC instead of API keys

Pay.sh sits in front of Google Cloud services — BigQuery, Gemini, Vertex AI, Cloud Run — and presents them as priced endpoints. There are no accounts, no API keys, no monthly invoices. An agent makes a request, the server returns HTTP 402 Payment Required, the agent signs an EIP-3009 transferWithAuthorization (or its Solana SPL equivalent), retries with the payment header, and the gateway forwards the call once a facilitator confirms settlement on-chain.

This is x402, the open payment protocol Coinbase released in May 2025 and donated to the Linux Foundation on April 2, 2026. The Solana Foundation built Pay.sh on top of it because x402 made one design choice that matters: the payment is the credential. There is no separate identity layer to provision, no rate-limit token to mint, no quota table to keep in sync. The signed authorization is the auth, the meter, and the receipt in one round trip.

Pay.sh is also built on MPP — the Machine Payments Protocol, originally pushed by Stripe and Paradigm's Tempo chain — for higher-throughput session flows. The combination is deliberate. x402 covers single-shot, agent-pays-API calls; MPP covers persistent agent-to-agent interactions where opening a fresh 402 dance on every request would be wasteful. The protocols are complementary rather than competing, and Pay.sh ships both because real agent traffic looks like both.

Launch partners include PayAI, Crossmint, Merit Systems, Corbits, MoonPay, Sponge Wallet, ATXP and Tektonic. The community API roster — over fifty endpoints today — covers data (Dune Analytics, Nansen, Helius, Alchemy, QuickNode, The Graph, Allium), e-commerce (Rye, BigCommerce), search (Exa), and infrastructure (AgentMail, StablePhone). The facilitator registry is open-source at github.com/solana-foundation/pay; publishing an endpoint is a pull request.

That last detail is what distinguishes Pay.sh from a closed marketplace. The registry's gravity comes from being open, not curated. Google's role is to put weight behind the standard and to ship the largest first-party endpoint set; the protocol is what competing clouds — and projects like this one — can adopt without asking permission.

The volume already supports the bet. As of March 2026, x402 had processed more than 119 million transactions on Base and 35 million on Solana, with roughly $600M in annualized volume across both. Pay.sh is the layer that turns those raw rails into a service registry that an agent can browse, query, and consume without a contract.

Circle Agent Stack: payments that have to round down

On May 11, Circle shipped its Agent Stack at agents.circle.com. Four pieces: a Circle CLI, Agent Wallets (permissionless and policy-controlled), an Agent Marketplace, and Nanopayments powered by Circle Gateway — gas-free USDC transfers from $0.000001, settling across eleven blockchains.

The $0.000001 floor is the headline number, and it is the one worth dwelling on. At that resolution, a payment is no longer a payment; it is a unit of cost-of-goods. An agent fetching a single token from an inference provider can pay per token. An agent buying one row from a queryable dataset can pay per row. The assumption baked into SaaS pricing — that you pre-commit to a tier because rounding to the cent at runtime is too expensive — collapses.

Two things make this work. First, the gas-free transfer rails: the agent's wallet never has to hold the underlying chain's gas token, which is the single largest source of friction in any onchain payment flow today. Second, the move toward Circle's own Layer 1 — Arc — which raised $222M in a private sale at a $3B fully-diluted valuation, backed by a16z and BlackRock, and is targeting mainnet beta in 2026. Arc is what makes sub-cent transfers economically sane at scale: a stablecoin-native chain where the unit of account, the gas model and the settlement guarantees are all aligned to USDC rather than imported from a general-purpose L1.

Read the product names. Not "Circle Pay for Apps" or "Stablecoin SaaS Suite." Agent Wallets. Agent Marketplace. The customer is named. Circle's bet is that the agent is the new economic actor, and the developer is the operator configuring the agent — not the one being billed.

Tether developer grants: a bet on the opposite stack

Also on May 11, Tether opened a developer grants program at tether.dev. No cap on total payouts. Individual grants of $1,500–$4,000, paid in USD₮ or BTC, tied to specific deliverables. The four focus areas are unusual: QVAC (Tether's local-first AI runtime), MDK, the Wallet Development Kit (WDK), and Pears (P2P / decentralization research).

The contrast with Pay.sh and the Circle Agent Stack is the point. Where Solana and Circle assume the agent talks to APIs in the cloud and pays for them with stablecoins, Tether is funding the agent that runs locally on the device, signs with keys held locally, and may never need an API gateway in the first place.

This is not a contradiction; it is a hedge. If the agentic economy converges on cloud inference billed per call, the gateways win. If it converges on local models — driven by edge silicon, regulation, latency, or privacy — the wallet SDK that ships inside the application wins. Tether is funding the second leg. It is the only one of the three willing to bet that a meaningful share of agents will never phone home.

WDK is the most concrete piece of that bet. A self-custodial wallet that an application embeds — generating keys, signing transactions, moving funds across mobile, desktop and embedded environments, without routing through a hosted API — is the right shape for an agent the operator never wants on someone else's server. The grant sizes are small on purpose. This is not about hero projects; it is about populating the long tail of components that has to exist before local-first agents become anything other than a thought experiment.

What the three share

Three companies, three positionings, one underlying claim: the financial primitives that AI agents need are not the ones humans use. KYC bottlenecks, monthly subscriptions, virtual cards on a statement cycle — these are legacy artifacts of a world where the buyer is a person with a job and a bank. The buyer is now a process. The right rail is a stablecoin transfer that settles in seconds, signs without a human in the loop, and prices per call rather than per month.

Once you accept that framing, x402 stops looking like a curiosity and starts looking like the new SSL. Per-request payments stop being a micropayments fantasy and start being the only billing model that survives contact with autonomous spend.

What none of them solved

All three launches are payment rails plus wallets. None of them is the layer the agent actually spends most of its tokens in: model inference, tool use, retries when the provider is degraded, failover when the provider is down, the assembly of a heterogeneous set of capabilities behind a single OpenAI-compatible surface.

That layer remains the part that doesn't want to be married to one chain, one stablecoin issuer, or one cloud. An agent that pays Pay.sh for BigQuery, Circle Gateway for a marketplace listing, and a local WDK transfer to its operator's treasury still needs something deciding which LLM to call, which tool to invoke, when to retry, when to give up, and how to bill the result back to its own balance.

Pay.sh, Circle and Tether built the rails. The orchestration layer on top — multi-provider, chain-agnostic, OpenAI-compatible — is a separate problem, and a deliberately neutral one.

Where we fit

At LLM4Agents we have been building exactly that layer: an OpenAI-compatible gateway with multi-provider failover across Anthropic, OpenAI, Google, Meta and others, unified MCP tools (headless browser, Google Search, image generation), and a balance funded by USDC or USDT on Solana or Polygon — non-custodial, gasless, no card, no KYC. We are adopting x402 natively and joining the Pay.sh registry this week.

If you are building agents that need to think and act, not just pay, we are happy to talk. The docs are at api.llm4agents.com/docs.