On July 14, 2026, paying for AI compute without a human in the loop stopped being a Coinbase side project and became something Visa, Mastercard, Stripe, Google, and the Linux Foundation put their name on [1]. That half of the agent economy is basically solved. The half nobody has solved yet: once an agent pays for inference, it still has no way to know the compute it just bought actually happened the way it was told.

Call an API for a named model today and you’re trusting a label, not a fact. The endpoint stays the same. What’s actually serving requests behind it does not have to, and nothing in the API contract obligates a provider to say so when it changes [2].

That gap is no longer just a feeling developers swap on forums. A February 2026 study published in PLOS One ran a ten-week, human-anchored evaluation of deployed transformer services and documented measurable behavioral drift across the window, the kind of shift people had been reporting anecdotally for months, now with a controlled study behind it [3]. Developers have taken to calling the pattern “AI shrinkflation,” the same rate for a model that quietly got worse, and cross-provider pricing comparisons suggest it isn’t confined to any single lab [4].

None of this requires bad faith to explain. It requires only the fact that a model name on an API response has never been a cryptographic claim. It’s marketing copy that happens to be accurate most of the time.

There are exactly two ways to know a specific model produced a specific output on real hardware, unmodified. Run it yourself, on infrastructure you control, and trade the trust problem for the operational cost of hosting weights, managing GPUs, and keeping a serving stack current. Or get a proof from something the provider does not control: hardware that signs its own attestation before the provider gets a chance to just say so.

Almost nobody does the first beyond the smallest models. The second is what the last year of decentralized compute infrastructure has actually been building toward.

Verification isn’t a switch, it’s a ladder, and most AI inference today sits on the bottom rung without anyone questioning it.

Take the provider’s word. The default for essentially every API call made anywhere. The response comes back, the model name matches what was requested, and that’s the entire chain of custody.

Run it yourself. Full control, real verification, and an operational burden that keeps almost everyone off this rung for anything beyond small, self-hostable models.

TEEML, hardware attestation. The model runs inside a hardware-isolated enclave, an Intel TDX-secured CPU paired with an NVIDIA H100 or H200 GPU in TEE mode. The chip generates a signing key inside the enclave at startup and signs every inference result with it before the response leaves. A remote attestation report, cryptographically tied to the hardware itself, lets anyone independently check the code actually ran inside a genuine, untampered enclave. [0G’s](http://pc.0G.ai) Compute Network runs exactly this architecture, branded Sealed Inference, live on mainnet [5].

OPML, optimistic verification. Results are accepted by default and can be challenged and recomputed within a window if something looks wrong, trading upfront cryptographic proof for economic security backed by a bond. Faster than a full proof. Weaker than one [6].

ZKML, zero-knowledge verification. Mathematical certainty with no hardware trust assumption at all, the strongest guarantee on the ladder, and still the most computationally expensive, which is why it isn’t the default for large models yet [6].

0G’s🔗 architecture spans the top three of those five rungs, and which one actually applies depends on what’s being served [6]. Open-weight models, GLM, Qwen, DeepSeek, and 0G’s own in-house models, run TEEML directly: weights inside the enclave, full attestation. Closed frontier models are a different case. 0G doesn’t hold the weights for Claude or GPT-5.6, so what it offers instead is TeeTLS: a broker running inside its own TEE that proxies the request to the real provider over an authenticated connection and proves the request reached the genuine API, not an imposter [7]. That’s a real guarantee. It is not the same claim as “this model ran verifiably inside a TEE,” and the honest version of this story keeps the two separate [8].

The other half of the autonomous-agent story got real on July 14, 2026, when the Linux Foundation formally launched the x402 Foundation: an open-governance body with 40 founding members spanning every layer of payments. Visa, Mastercard, and American Express on the card networks. Stripe, Adyen, and Fiserv among processors. Google and AWS on cloud infrastructure. Circle and Coinbase on stablecoins. The Solana Foundation, Stellar, and Ripple on blockchain rails [1].

Coinbase introduced the underlying protocol in May 2025 to solve a narrow, specific problem: an AI agent cannot fill out a credit card form or wait on invoice approval, and until x402, nothing in the payment stack was built for a buyer that isn’t a person [1][11].

The mechanics are almost aggressively simple. An agent requests a paid resource. The server answers with an HTTP 402 and a JSON manifest specifying price, chain, and destination wallet. The agent signs a gasless USDC transfer authorization under EIP-3009 and retries the request with the signed authorization attached. A facilitator checks the signature and settles on-chain. On Base, the round trip takes two to four seconds and costs about a hundredth of a cent [1][10].

The adoption curve backs up the institutional interest. Base alone carried more than 100 million cumulative x402 transactions through the first quarter of 2026. In the 30 days before the Foundation’s launch, roughly 75 million transactions moved about 24 million dollars, averaging 32 cents each. More telling than the transaction count: payments of a dollar or more now account for 95 percent of total dollar volume, up from 49 percent in early 2025, which is the market sorting itself from speculative noise into something that looks like actual commerce [1].

Cluster already speaks this rail into 0G🔗. Access to 0G-routed inference through Cluster is permissionless via x402: no API key, no pre-registration, pay per request in USDC on Base, with Cluster settling the underlying cost with 0G’s network on-chain [9].

Two primitives now exist in production, both live, both settling on the same chain: verifiable execution with hardware attestation, and machine-native payment over HTTP. What’s missing is the layer that composes them into an actual workflow instead of two separate integrations sitting next to each other, and that’s precisely the orchestration layer for autonomous workflows that Cluster is building.

Concretely, that means:

Route each step to the verification tier it actually needs. A step that just needs an answer goes wherever is fastest and cheapest. A step whose output feeds a financial decision, or that a client will eventually ask to see proof of, routes to 0G’s TEEML-verified models instead. Nobody should pay TEE prices for a step that didn’t need one, and nobody should get default-trust pricing for a step that did.

Gate the payment on the proof, not just the response. Because both the attestation and the x402 settlement are cryptographic, payment can be made conditional on a valid attestation quote coming back with the result, so an agent pays only when the guarantee actually held, not merely when something came back that looked like an answer.

Ship it as an application, not an integration. A prompt-to-deployment surface like [CodeXero](https://x.com/CodeXero_xyz) turns “build me an agent that only pays for inference it can prove ran correctly” into a buildable request instead of an engineering project.

The division of labor is clean. 0G🔗 is the verification and settlement-grade compute layer: hardware attestation where it holds the weights, authenticated routing where it doesn’t. Cluster is the orchestration and settlement fabric deciding which model and which verification tier a given step actually needs. Both already speak x402 natively on the same chain, so the pieces click together without bespoke plumbing between them.

Bitcoin’s entire pitch was never trust the bank, it was verify the ledger yourself. What’s happening to AI compute right now is the same move, a decade later, applied to a different kind of ledger. The payment half of that bet just got Visa’s signature on it. The verification half is still being built, model by model, enclave by enclave, and it’s the half that decides whether “autonomous agent” ends up meaning something that can act on its own, or just something that can spend on its own while hoping the other side of the transaction was honest.

An agent that can pay for anything but can’t verify what it bought isn’t autonomous. It’s just gullible with a wallet.

[1] Tech Times, “Visa, Mastercard, and Stripe Back Open Standard Letting AI Agents Pay Autonomously”🔗 (x402 Foundation launch, 40 members, payment mechanics, adoption stats)

[2] DigitalOcean, “The Silent Versioning Problem in AI Inference”🔗 (model names not implying stable behavior)

[3] Nanonets, “Are OpenAI and Google intentionally downgrading their models?”🔗 (PLOS One ten-week behavioral drift study)

[4] Everpuredata, “Compute is the New Bottleneck for Frontier AI”🔗 (“AI shrinkflation,” cross-provider pricing and quality comparison)

[5] 0G, “0G Introduces Sealed Inference”🔗 (TEE architecture, Intel TDX, NVIDIA H100/H200, live on mainnet)

[6] 0G Documentation, “Compute Network”🔗 and 0G Compute🔗 (TEEML / OPML / ZKML verification mechanisms)

[7] 0G Documentation, “Inference”🔗 (TEEML versus TeeTLS distinction)

[8] 0G Private Computer, model catalog🔗 (Claude and GPT-5.6 availability, which models carry a Verifiable tag)

[9] Cluster Protocol, 0G Compute Network integration docs🔗 (Cluster’s own x402 access to 0G-routed inference)

[10] Coinbase, x402 v2 specification🔗 (EIP-3009 mechanics, facilitator role)

[11] Eco, “x402 Protocol Explained”🔗 (HTTP 402 mechanics, EIP-3009 background)