stealthPAY is the control plane for private agent spend. Fund and govern a fleet of AI agents
that pay per call — feeless, in seconds, and privately — without
ever handing us your keys or your money. You set the budgets and the policy; your agents spend within them;
you watch every payment in real time. Your keys. Your funds. Never ours.
Fee Per Call
$0.00
Feeless by protocol
Private Channel
zk-STARK
XSS shielded
Finality
~5s
One block
Custody
0
We never hold funds
01
The Problem
Agents need money. The rails don’t fit.
x402 revived 402 Payment Required: a server asks for payment, the agent pays automatically, access is
granted — no accounts, no human in the loop. Elegant, but it inherits whatever chain settles underneath.
Four ways every existing rail breaks:
Problem 01
Fees kill micropayments
10,000 calls/day at $0.001 moves $10/day — and costs $50–$20,000/day in Ethereum gas. Any fee larger than the payment is irrational.
Need · Exactly zero
Problem 02
Slow confirmation blocks agents
A 10-minute confirmation between every call is an agent that can’t serve its user. Payment latency must match API latency.
Need · Seconds
Problem 03
Transparent chains leak strategy
On a public chain every payment is visible — which services, how often, how much. The agent’s task and your strategy, exposed by default.
Need · Shielded
Problem 04
No governance
An autonomous actor spending with no caps, alerts, or kill-switch is how you wake up to a drained wallet.
Need · Caps + control
02
How It Works
Two faces, one product
You keep the vault. We’re the brain. Stealth’s chain fixes fees, speed, and privacy at the
protocol level. stealthPAY adds funding, identity, governance, visibility, and private routing — without
ever becoming your bank.
PAY
A self-custody wallet
Keys on the device — standalone or a Telegram Mini App. Fund once; agents tap-to-pay per call. We never see a spending key. A tiny proof-of-work replaces the fee. Each agent spends a scoped, revocable allowance.
Self-custody · capped credentials
GOVERN
The console + sidecar
A dashboard driven by viewing keys — it shows everything and is cryptographically unable to move a coin. Plus a sidecar: our signer, in your infrastructure, holding only capped keys.
See everything · spend nothing
03
Wallet Funding
Human-in-the-loop, by design
An agent can’t pass KYC or fund itself — and that is a feature to design for. A human authorises a
budget; the autonomous actor spends within it. Funds land in a wallet you control — we never hold them.
Fiat → XST
01
Card or bank transfer via a licensed onramp partner. KYC happens once, with the partner — never with us.
Easiest for new operators
Crypto Swap → XST
02
Swap BTC, ETH, SOL, USDC or USDT into XST via an integrated DEX aggregator. Credited on the next block.
Fastest for crypto-native ops
Direct XST Deposit
03
Send XST straight from any wallet into your self-custody balance. Credited after one block (~5s). Zero fee, end-to-end.
Zero friction if you hold XST
Auto-Replenish
04
Set a low-balance threshold; an agent tops up automatically from your funding wallet when it runs low.
Set-and-forget
04
The Flow
402 → sign → settle → serve
Step 01
402
Server returns the price and a fresh single-use address.
Step 02
Sign
Wallet or sidecar builds a feeless tx, grinds PoW, signs with a capped key — locally.
Step 03
Settle
Confirmed in ~5s — one block. Private payments route shielded.
Step 04
Serve
Resource + receipt. The console reflects the payment live.
Full round trip · ~5 seconds · $0.00 in fees
05
The Moat
The part nobody else has
XSS · Shielded Channel · Post-Quantum zk-STARKs
Every other agent-payments product settles on a transparent chain. stealthPAY can make the spend graph itselfprivate.
Routed through a zk-STARK shielded channel that hides amount, sender, and recipient — with
selective-disclosure receipts that hand audit and accounting back whenever you choose. Because the
graph stays hidden, an agent’s behavior — which services it calls, how often, at what price — is
neither traceable nor predictable to anyone watching the chain. Feeless and
five-second finality are table stakes. Private, governed agent spend is the product.
Not “we promise not to peek” — can’t. This chain separates viewing from spending: the console holds a viewing key and is mathematically unable to move a coin.
No fiat, ever
We never touch money
We never hold fiat or crypto. Onramps are licensed partners; the spending key lives on your device; the signer runs in your infrastructure.
The console runs on viewing keys it can’t spend with, agents spend capped credentials you issue,
and the signer runs in your environment. We never hold or move your funds. You’re not trusting us
with money — there’s no money of yours to trust us with.
07
Why XST / XSS
Not USDC, not ETH, not BTC
XSTXSS
The payment layer is the hard constraint. It must be feeless, fast, and private at the same
time. No other chain satisfies all three today.
Property
XST
XSS
USDC (L2)
ETH
BTC
Transaction fee
$0.00
$0.00
$0.01–$0.50
$0.10–$50+
$0.50–$50+
Confirmation time
5 sec
5 sec
10–30 sec
~12 sec
10 min
Sender privacy
Transparent
zk-STARK
Public
Public
Public
Viable at $0.001 payments
Yes
Yes
Marginal
No
No
Parallel agent throughput
UTXO
UTXO
Account
Account
UTXO
Every other rail forces the agent to compromise. USDC has small fees and semi-fast finality but full
on-chain transparency. ETH adds state but at unpredictable gas. BTC is private-adjacent but
10-minute blocks break the x402 loop. Only XST and XSS hit all three constraints at once — because that
is what the chain was designed for since 2014.
08
Use Cases
Anything an agent pays for
01
Pay-per-call APIs
The canonical x402 loop — 402 → pay → data, in ~1 second. Gate the route, govern the spend.
02
Telegram pay-per-stream
A bot streams its answer only after a confirmed micropayment — the loop finishes before the user feels a delay.
03
Agent-to-agent marketplace
An orchestrator routes a query to a specialist agent and pays it automatically, with a markup.
04
Private consultations
Health, legal, financial questions answered by a bot — the on-chain record revealing nothing about who paid whom.
The stealthPAY SDK abstracts the chain work — the agent never builds a transaction by hand. It hits a
402, the sidecar signs locally with a capped credential, and the payment settles feeless in
~5s. No spending key ever leaves your infrastructure.
Server SDK — drop-in middleware (Node, Python) that turns any route into a paywalled x402 endpoint.
Sidecar — the self-hosted signer + policy engine. Runs in your infra, holds only capped keys.
Console — viewing-key dashboard for balances, spend, receipts, and policy.
x402 quickstart
x402 flow
// Step 01 · Agent hits an x402-gated endpointconstres = awaitfetch("https://data-api.example.com/prices/BTC");
if (res.status === 402) {
// Step 02 · Read the payment instruction (price, single-use address, rail)constask = JSON.parse(res.headers.get("X-Payment-Required"));
// Step 03 · Sign + settle LOCALLY — the sidecar holds a capped key, in YOUR infra.// stealthPAY never sees a spending key. Feeless, ~5s finality.const { txid, receipt } = await sidecar.pay({
to: ask.address, // fresh single-use addressprice: ask.price,
rail: ask.rail, // "XST" transparent · "XSS" shieldedagent: "research-agent-v2"// scoped, revocable credential
});
// Step 04 · Retry with the on-chain receipt — access grantedconstdata = awaitfetch("https://data-api.example.com/prices/BTC", {
headers: { "X-Payment-Receipt": receipt }
});
}
Signs via sidecar.pay() in your infra · settles in ~5s · $0.00 feeAlso in Python, Rust
Agents reach x402 endpoints through the stealthPAY hub, over stealthCORE (XST, transparent)
and stealthPRIVATE (XSS, shielded) — feeless, settling in ~5 seconds across both rails.
Live
Agent networkLive
Live settlesLive
Session TX0
Fees paid$0.00
Supply20.94M XST
Packet legend
TransparentXST
ShieldedXSS · zk-STARK
Shielded packets reveal nothing on chain. You see them because you hold the viewing key.