x402 resurrects HTTP 402 Payment Required — reserved in 1991, never implemented. XST on stealthCORE pairs it with feeless, sub-five-second, UTXO-parallel settlement — already the M2M winner on the basics. XSS on stealthPRIVATE closes the remaining gap: shielded sender, receiver, and amount, so an agent's payment graph is not competitive intelligence for anyone who wants it. No fees. No accounts. No gatekeepers. No behavioural leakage.
Credit cards require accounts. Bank transfers take days. Most crypto rails fail on cost — fees that dwarf the payment itself — and on shape: account-model chains serialise every spend at the nonce, so 10,000 concurrent agent payments queue behind each other. XST on stealthCORE already solves all three of the obvious conditions simultaneously: feeless, sub-five-second finality, and a Bitcoin-descendant UTXO model that lets independent spends clear in parallel. On the basics, stealthCORE is already the M2M winner — it beats almost every rail in existence before privacy even enters the argument.
But a feeless transparent chain is still a transparent chain — it solves cost without solving exposure. An autonomous agent's entire payment graph — which services it calls, how often, how much it pays, and who it pays — is its strategy, and on any transparent ledger it broadcasts that strategy in plain sight to competitors, counterparties, and observers. XSS on stealthPRIVATE closes that last gap: sender, receiver, and amount are cryptographically hidden. XST is the argument; XSS is the moat. Layered together, no other chain in existence satisfies both conditions at once.
x402 is an open payment protocol built on top of HTTP, leveraging the long-dormant 402 Payment Required HTTP status code. Originally reserved in 1991 "for future use", it was never implemented — until now. The concept is elegantly simple: a server responds with a 402 when content or a service requires payment. The client — an AI agent, app, or wallet — pays automatically using crypto. Access is granted. No accounts. No signups. No intermediaries.
A micropayment rail is economically viable only while the per-transaction fee stays meaningfully below the value being moved. At machine frequency — thousands of payments per agent per day — even a small fixed fee crosses that threshold and turns every call into pure overhead.
Bitcoin's 10-minute blocks and Ethereum's ~12-second blocks are designed around human patience. A person waiting a few minutes to see a confirmation is an acceptable user experience for a human-frequency transaction.
An autonomous agent waiting minutes for payment confirmation is blocked — unable to proceed, unable to serve the request behind the payment. Whatever workflow triggered the 402 is frozen until settlement arrives.
Stealth's 5-second blocks and light wallet architecture mean payments are confirmed and usable within seconds. Agents can operate in near real-time, with payment latency that matches API response times rather than fighting them.
| Bitcoin (BTC) | ~60 min | 6-conf standard · 10-minute block target |
| Ethereum (ETH) | ~13 min | 2-epoch finality · ~12s block interval |
| Monero (XMR) | ~20 min | 10-conf standard · 2-minute block target |
| Zcash (ZEC) | ~7.5 min | 6-conf standard · 75-second block target |
| Stealth (XST) | ≤ 5s | Junaeth · single-conf within the 5s block window |
An agent fires hundreds of payments per second. The transaction model underneath — UTXO or account — decides whether those payments run in parallel or stack in a queue waiting for the one in front to clear. This is not a surface-level choice. It is the structural difference between a chain that scales with agent load and a chain that throttles it.
Ethereum's account-based model creates sequential bottlenecks — one unconfirmed transaction blocks all subsequent ones from the same address. Every transaction carries an incrementing nonce; the network will not accept tx n + 1 before tx n is confirmed.
For an agent firing hundreds of payments per second, this is a critical limitation. A single slow payment stalls the entire queue behind it.
Stealth's UTXO model — inherited from Bitcoin — allows fully parallel transaction processing. Each spend consumes specific unspent outputs; there is no global nonce that serialises a wallet's outbound traffic.
Multiple agents sharing a wallet can all pay simultaneously with no ordering conflicts. The chain's throughput is the chain's throughput — it is not capped by any single address.
AI agents autonomously pay for LLM inference, data lookups, translation services, and specialized tools — per request, in real time, without pre-funding accounts or managing subscriptions.
Smart devices pay for bandwidth, sensor data, or compute from neighbouring nodes — creating autonomous microeconomies between physical devices with no human in the loop.
Researchers, agents, and services pay for individual database queries, real-time feeds, or proprietary datasets — per row, per result, per second — without committing to subscriptions.
Video, audio, compute, and bandwidth billed by the second or millisecond. Traditional payment rails make this impossible — transaction fees would dwarf the actual payment. Feeless changes the math entirely.
"The internet was built to move information freely. The next layer moves value the same way — instantly, without gatekeepers, at machine speed."Stealth R&D LLC
XST on stealthCORE already wins the base layer. XSS on stealthPRIVATE is the moat. A feeless transparent chain still broadcasts every agent's payment graph — who they pay, how much, and how often — in plain sight. That is enough to reverse-engineer what an agent is doing, what business it supports, which competitors it depends on, and what its operator is working on. XSS shuts all of that down: sender, receiver, and amount are cryptographically hidden. Outsiders see only that a shielded transaction occurred. It solves the four hardest problems in agent micropayments simultaneously: behavioural privacy, UTXO dust, settlement frequency, and on-chain footprint.
An AI agent operating on a transparent chain broadcasts its entire payment graph publicly — which services it uses, how often, how much it pays, and who it pays. That is enough to reverse-engineer the agent's underlying task, its resource dependencies, the business it supports, and the strategy of the operator behind it. Competitors can profile it. Counterparties can front-run it. Observers can de-anonymise the operator through timing and counterparty analysis.
On stealthPRIVATE, all of this is cryptographically hidden. Agent-to-agent payments reveal nothing — no sender, no receiver, no amount, no frequency. Competitors, counterparties, and observers see only that a shielded transaction occurred. This is the single capability that makes agent economies workable at all — and Stealth is the only chain that is both feeless and shielded by default.
On a transparent UTXO chain, high-frequency micropayments produce a growing set of small outputs — dust — that accumulates in wallets and bloats the global UTXO set. Eventually these outputs cost more in computational overhead to spend than they are worth.
stealthPRIVATE eliminates this entirely. A spend action consumes the input note and creates fresh output notes. An agent can receive 10,000 micropayments and spend them in a single consolidated action with no dust penalty and no ledger bloat.
Because stealthPRIVATE operates as a pool — deposits add to a shared UTXO pool, withdrawals consume from it — agents can accumulate thousands of micropayments internally and bridge back to stealthCORE in a single bulk withdrawal, to any XST address, at any time.
This decouples settlement frequency from payment frequency. An agent making 50,000 micropayments per day can settle once, without any per-payment overhead on the transparent chain and without any on-chain linkage between individual payments and the final withdrawal.
On stealthCORE, every unspent output adds a permanent entry to the global UTXO set until it is spent. Under high-frequency M2M load, this set grows rapidly and adds validation overhead for all nodes.
stealthPRIVATE's nullifier set grows on spend — not on receipt. Unspent notes exist only inside wallets, not in a global set. The on-chain footprint of receiving 10,000 payments is zero until those notes are spent. This is structurally better for high-throughput agent workloads.
Two layers, one chain. XST on stealthCORE already beats almost every rail in existence on feeless, fast, UTXO-parallel settlement. XSS on stealthPRIVATE adds the moat nobody else in the space can match — private and feeless and dust-free micropayments, at machine speed. Every other chain leaks the graph that matters. Stealth is one of a kind.
| Protocol | x402 · HTTP 402 | Payment handshake built on the reserved 402 Payment Required status code — open, transport-agnostic at the HTTP layer, implementable in any web stack. |
| Flow | Request → Pay → Access | Three-step exchange: server returns 402 with amount/currency/address → agent signs and broadcasts → server grants access after confirmation. |
| Block time | 5 seconds | Junaeth consensus. Transactions finalise within the 5-second block window; average ≈ 2.5s mid-window, max 5s single-conf. |
| Fee per transaction | $0.00 | Feework, not fees. Memory-hard proof-of-work per transaction protects against spam without charging the sender. |
| Transaction model | UTXO | Inherited from Bitcoin. Parallel spends — no per-address nonce ordering, no sequential bottleneck for high-throughput agents. |
| Transparent layer | stealthCORE | Public ledger on mainnet since July 2014. Default layer for x402 payments where payment graph visibility is acceptable. |
| Private layer | stealthPRIVATE | Dedicated zk-SNARK sidechain · Halo 2 / Orchard, no trusted setup. Fully shielded sender, receiver, and amount. |
| Dust behaviour | None on stealthPRIVATE | Every spend consumes the input note and creates fresh output notes. No accumulating set of small outputs, no ledger bloat. |
| Settlement pattern | Pool · bulk exit | Shielded micropayments settle to stealthCORE via a single bulk withdrawal. Payment frequency and settlement frequency decoupled; no on-chain linkage between individual payments and the exit. |
| On-chain footprint | Nullifier set · grows on spend | Receipt of 10,000 shielded payments adds zero entries to the global state. Nullifiers are recorded only when notes are spent. |