Concept Sketch — stealth.pay
The payment layer
the agentic web needs.
AI agents are becoming autonomous economic actors — buying API access, paying for compute, hiring other agents, transacting millions of micropayments per day. They need a payment rail that works the way they do: instantly, privately, feeless, and without human intervention at every step. That rail is XST.
Feeless
5-second finality
x402 compatible
zk-SNARK privacy
UTXO parallel
Concept — not yet live
Tx Fee
$0.00
always, by protocol
Block Time
5 sec
payment confirmed
Peak TPS
~150k
multi-core parallel
Privacy
zk-SNARK
XSS shielded channel
Agents Need Money. The Existing Rails Don't Fit.
The x402 protocol opens a new paradigm: servers respond to HTTP requests with a 402 Payment Required status, the agent pays automatically, and access is granted. No accounts. No signups. No human in the loop. Elegant — but it has one hard dependency: the payment layer cannot add friction or cost.
An AI agent making 10,000 API calls at $0.001 each is transacting $10/day in value. On Ethereum, those same transactions could cost $50–$20,000/day in gas depending on network congestion. The model collapses before it starts. On Bitcoin, 10-minute confirmation times mean the agent is blocked between every payment. Even "fast" L2s carry fees and require bridging infrastructure the agent must manage.
Problem 1
Fees destroy micropayment economics
Any fee larger than the payment itself makes the transaction irrational. Traditional and most crypto payment rails were designed for human-scale transactions ($10+). Agent micropayments ($0.001–$0.01) require fees of exactly zero to be viable.
Problem 2
Slow confirmation blocks agents
An agent waiting 10 minutes for Bitcoin confirmation, or even 30 seconds for most L2s, is an agent that cannot serve its users. The payment latency must match the API response latency — seconds, not minutes.
Problem 3
Transparent chains expose strategies
On a public UTXO chain, every agent payment is visible: which services it uses, how often, how much, and who it pays. This exposes the agent's task, resource dependencies, and the operator's competitive strategy to anyone watching the chain.
Problem 4
UTXO dust accumulates at machine speed
At human transaction frequency, dust UTXOs are manageable. At machine frequency — thousands of micropayments per hour — the global UTXO set bloats rapidly. Eventually the cost to consolidate dust exceeds the value of the outputs.
Problem 5
Agents can't self-onboard
An AI agent cannot pass KYC, create a Coinbase account, or fund a wallet autonomously. Every existing onramp requires human intervention. This creates a hard dependency on an operator or developer at setup time — a solvable problem, but one that must be explicitly designed for.
Problem 6
Account models serialize agent payments
Ethereum's account-based model means one unconfirmed transaction from an address blocks all subsequent ones. For an agent firing hundreds of payments per second from a shared wallet, this is a critical throughput bottleneck.
The Full Payment Flow
stealth.pay is a platform layer on top of Stealth's XST and XSS infrastructure. It handles wallet management, agent API keys, funding onramps, and operator dashboards — so that neither agents nor the developers who deploy them need to think about blockchain mechanics. The agent just calls a REST endpoint. Everything else is handled.
Payment flow — operator funds → agent spends → payee receives
🧑
Operator
Human funds agent wallet via fiat onramp or XST swap
→
💳
stealth.pay
Custodial wallet + API key + spending policy
→
🤖
AI Agent
Calls REST API to pay. No blockchain knowledge needed.
→
🌐
x402 Server
Receives XST/XSS payment, grants access
→
📊
Dashboard
Operator sees balance, tx history, per-agent spend
Step 1
Operator registers & funds
A developer or company signs up, creates an agent wallet on stealth.pay, and funds it via a fiat onramp (card/bank), a crypto swap (BTC, ETH, USDC → XST), or a direct XST deposit. One-time human action. Sets spending limits and per-agent policies.
Step 2
Agent receives API key
The deployed agent is given a stealth.pay API key as an environment variable at deploy time. It carries spending authority up to the operator-defined limit. No wallet file, no private key management, no blockchain SDK required on the agent side.
Step 3
Agent encounters a 402 response
The agent's HTTP client receives a 402 Payment Required with an x402 payment instruction header: amount, recipient address, and currency (XST or XSS).
Step 4
Agent calls stealth.pay API
A single POST /pay with the payment instruction. stealth.pay verifies the policy, signs and broadcasts the XST transaction, and returns a payment confirmation token within 1–2 seconds.
Step 5
Agent presents proof, gets access
The agent includes the confirmation token in a retry of the original request. The server verifies the on-chain transaction (confirmed within 5 seconds) and grants access. The full round-trip adds under 10 seconds to the agent's workflow.
Step 6
Operator monitors & replenishes
The dashboard shows real-time balance, per-agent spend, transaction history, and low-balance alerts. The operator tops up via the same onramp. Optionally: auto-replenishment from a parent wallet when balance drops below a threshold.
The Human-in-the-Loop Funding Model
An AI agent cannot pass KYC or fund its own wallet — and that is not a flaw to work around, it is a feature to design for. The right model mirrors how companies issue corporate payment cards: a human authorises a spending budget; an autonomous actor spends within it. The operator is the financial principal; the agent is the autonomous executor.
stealth.pay's funding design makes this as frictionless as possible. The operator funds once at deployment time, sets a replenishment policy, and then steps back entirely. The agent runs without further human involvement until the balance approaches a threshold — at which point an alert fires, or an auto-replenish rule tops it up from a parent wallet automatically.
💳 Fiat → XST
Card or bank transfer via integrated fiat onramp. KYC handled once at operator account creation. Converts automatically to XST at market rate. Minimum deposit: $10.
Easiest for new operators
🔄 Crypto Swap → XST
Swap BTC, ETH, SOL, USDC, or USDT into XST via integrated DEX aggregator. Non-custodial swap — funds go directly to the agent wallet. No additional KYC if under threshold.
Fastest for crypto-native ops
📨 Direct XST Deposit
Send XST directly from any wallet or exchange to the generated deposit address. Credited after 1 block confirmation (~5 seconds). Zero fee. Ideal for operators already holding XST.
Zero friction if you hold XST
🔁 Auto-Replenish
Configure a low-balance threshold and a parent wallet or linked fiat account. When the agent wallet drops below the threshold, stealth.pay automatically tops it up. Agents never run dry.
Set-and-forget
XST Wallet
Transparent payments — for most agent transactions
The default agent wallet uses XST on stealthCORE. Payments are fast (5s), feeless, and auditable by the operator. Every transaction is visible in the operator dashboard with full metadata. Suitable for the vast majority of agent-to-service payments where privacy is not the primary concern.
The UTXO model allows multiple agents sharing a wallet to fire payments simultaneously with no ordering conflicts — critical for high-concurrency agent deployments.
XSS Wallet
Shielded payments — for sensitive agent workloads
For agents transacting sensitive data — medical, legal, proprietary research, behavioral data — stealth.pay can route payments via stealthPRIVATE's XSS shielded channel. Sender, receiver, and amount are hidden by zk-SNARK proof. On-chain observers see only that a shielded transaction occurred.
The operator can still see full metadata in their private dashboard. The shield is outward-facing — hiding the agent's payment graph from competitors and observers, not from the operator who is accountable for the spend.
Designed for Agents, Not Blockchain Developers
The stealth.pay REST API abstracts away every blockchain primitive. The agent never touches a private key, never constructs a transaction, and never monitors confirmation status. It simply calls POST /pay and receives a confirmation. Everything else is handled server-side.
Example — agent encounters 402 and pays automatically
const response =
await fetch(
"https://data-api.example.com/prices/BTC")
;
if (response.status ===
402)
{
const instruction = JSON.parse(response.headers.get(
"X-Payment-Required"))
;
const payment =
await fetch(
"https://api.stealth.pay/v1/pay",
{
method
: "POST",
headers
: {
"Authorization": `Bearer ${STEALTH_PAY_API_KEY}`,
"Content-Type": "application/json"
},
body
: JSON.stringify(
{
amount
: instruction.amount,
currency
: instruction.currency,
recipient
: instruction.recipient,
memo
: "BTC price lookup"
})
});
const { txid, confirmed, token
} =
await payment.json()
;
const data =
await fetch(
"https://data-api.example.com/prices/BTC",
{
headers
: { "X-Payment-Token": token
}
});
}
POST /pay
Single payment
The core action — agent pays a recipient
Accepts amount, currency (XST or XSS), recipient address, and optional memo. Returns txid, confirmation status, and a signed payment token the agent can present to the payee. Response time: ~1–2 seconds. Confirmation: within 5 seconds via Stealth's block time.
GET /balance
Wallet balance check
Agent checks available funds before committing
Returns current XST and XSS balance for the agent's wallet. Agents can check balance before entering a workflow to avoid mid-task failures. Optionally: a low-balance webhook fires automatically before the agent needs to check manually.
POST /pay/batch
Batch payments
Multiple recipients in a single API call
Agents distributing payments to multiple services in parallel — paying a translation API, a data feed, and a compute provider in one workflow — can submit all payments in a single batch call. Stealth's UTXO model handles the parallel outputs natively.
GET /history
Transaction history
Auditable payment log per agent
Full paginated transaction history for the agent's wallet — amounts, recipients, memos, timestamps, and txids. The operator dashboard surfaces this with filtering and export. Agents can also query their own history to enforce internal rate limits or spending caps.
Full Visibility. Zero Blockchain Knowledge Required.
The operator dashboard is the human interface to the entire system. It shows every agent registered under the account, their current balances, real-time transaction feeds, spending trends, and policy configurations — all in a single view. Operators never need to touch a blockchain explorer or understand transaction mechanics.
app.stealth.pay — Operator Dashboard
Agent
Balance
Tx Today
Status
research-agent-v2
142.3 XST
8,412
data-fetcher-prod
89.7 XST
3,219
private-agent-xss
31.1 XSS
1,104
test-agent-staging
5.0 XST
112
Property
BARON
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-SNARK
Public
Public
Public
Amount privacy
Visible
Hidden
Visible
Visible
Visible
UTXO parallel payments
Yes
Yes
No (account)
No (account)
Yes
UTXO dust problem
Possible at scale
Eliminated
N/A
N/A
Yes
Viable at $0.001 payments
Yes
Yes
Marginal
No
No
The XSS Advantage for Private Agent Workloads
For most agent payments, XST on stealthCORE is the right choice: transparent, fast, feeless, and auditable. But for agents operating in competitive or sensitive domains, XSS on stealthPRIVATE is uniquely compelling. No other payment layer offers feeless + private + dust-free micropayments simultaneously. That combination does not exist elsewhere in the crypto ecosystem.
An agent making thousands of payments per day on a transparent chain is broadcasting its entire operational fingerprint: which services it depends on, how often, how much. A competitor watching the chain can reverse-engineer the agent's architecture, its data sources, and its cost structure. On XSS, none of that is visible. The agent's payment graph is cryptographically sealed.
Phase 1
Core infrastructure
Wallet API + operator dashboard
Build the custodial wallet backend, the POST /pay REST API, basic operator dashboard (balances, transaction history, API key management), and direct XST deposit onramp. The minimal viable product: an agent can pay, an operator can see it happen.
Phase 2
Fiat & crypto onramps
Remove the XST acquisition barrier
Integrate a fiat onramp (Moonpay, Transak, or similar) and a crypto swap aggregator (Changelly, SimpleSwap) so operators can fund agent wallets from any starting point — card, bank, BTC, ETH, USDC. This is the critical adoption unlock: operators should never need to "find XST" on their own.
Phase 3
XSS shielded channel
Private agent payments via stealthPRIVATE
Add XSS wallet support and shielded payment routing via the stealthPRIVATE sidechain. Operators can designate individual agents to use the shielded channel. The dashboard shows full metadata privately to the operator while the on-chain record reveals nothing to external observers.
Phase 4
x402 middleware library
Drop-in integration for any agent framework
An open-source middleware library (Python, TypeScript, Rust) that wraps any HTTP client with automatic 402 detection and stealth.pay payment handling. Agents built on LangChain, AutoGen, CrewAI, or bare HTTP clients get x402 support with a single import and one configuration line.
"The agents are coming. The question is whether they'll pay with a system designed for them — or be forced to use one designed for humans and break in predictable ways. stealth.pay is the former."
Concept — Stealth R&D LLC
