SperaxOS gives AI agents real tools, real data and enforced guardrails for working with money on-chain, with payments settled over the x402 protocol in Sperax USDs. What: SperaxOS, Sperax's A
SperaxOS gives AI agents real tools, real data and enforced guardrails for working with money on-chain, with payments settled over the x402 protocol in Sperax USDs.
What: SperaxOS, Sperax's AI agent workspace for crypto and DeFi, is now an OpenAI Select Partner.
Why it matters: AI agents are starting to hold, move and pay with money. They need guardrails, real tools and a dollar built for software.
What's live today: the workspace at chat.sperax.io, 7 hosted MCP servers, 327 paid x402 endpoints, a six-layer guard chain and agent bank accounts that earn USDs yield.
Where Sperax is going: bank-style DeFi for everyone, real-world assets, unlimited partner tools through MCP, and the goal of being the number one DeFi copilot.
Try it: chat.sperax.io
First, who Sperax is. Sperax has been a crypto project since 2019. It launched USDs on Arbitrum in 2021, a stablecoin that pays you just for holding it, and it has run on-chain through every market since: the 2022 crash, the bear market and the recovery. Sperax launched Sperax Farms in 2022. It publishes every contract address, run a public bug bounty and let SPA holders govern the protocol. Six years is a long time in crypto. Most projects from 2019 are gone. Sperax is still shipping.
So why is a stablecoin team now an OpenAI partner?
Here's the simple version. Picture asking: "Put my idle dollars somewhere safe that earns something." "Is this token a scam?" "Pay for that data and tell me what it says." The assistant does the research, checks the risk, moves the money inside limits you set, and shows you exactly what it did.
That assistant needs three things that don't exist together anywhere else yet:
A brain: frontier models that can reason, plan and call tools.
A workspace: somewhere to run, with real data, real tools and real guardrails around real money.
A wallet and a currency: a way to pay and get paid by the call, with no human typing a card number, in a dollar that doesn't lose value sitting idle.
OpenAI builds the first. SperaxOS is the second. Sperax USDs, paid over the x402 protocol, is the third.
This article starts simple and gets more technical as it goes. First: who Sperax is, what the partnership means, and why OpenAI and the rest of the industry care about crypto, DeFi and x402. Then what Sperax has built, how the safety systems work, and how agent activity feeds back into SPA. Last, and most important, where Sperax is heading: agent bank accounts, auto-yield for agents and humans, bringing traditional finance and real-world assets on-chain, partnerships through tools and MCP, and Sperax's plan to become the number one DeFi copilot.
It's long on purpose. A partnership announcement is easy to scroll past. The thing behind it isn't.
SperaxOS workspace — Live · chat.sperax.io
OpenAI integrations — Live · chat.sperax.io/openai
Hosted MCP servers — 7 live, 6 on npm · chat.sperax.io/mcp
x402 facilitator — Live on Arbitrum and Base · x402.sperax.io
Paid x402 endpoints — 327 listed · chat.sperax.io/.well-known/x402
Guard chain inspector — Live, read-only · chat.sperax.io/guard-chain
SPABuyback contract — Live on Arbitrum · arbiscan.io
Usage-to-buyback loops — In design · see the flywheel section
USDs and SPA — Live · sperax.io
Co-marketing — In preparation · see the co-marketing section
Sperax has been building on-chain since 2019, and on Arbitrum since USDs launched there in 2021. If you're new here, this is the short version. The full documentation is at docs.sperax.io.
USDs, launched in 2021, is a stablecoin on Arbitrum, fully backed by other stablecoins. Its Auto Yield deploys the collateral into established DeFi protocols and passes the yield to holders by rebase, so a wallet's balance grows with no staking or claiming. The stability mechanism explains how the peg holds.
Sperax Farms, launched in 2022 as Demeter, lets any project start liquidity farms on Uniswap V2 and V3, Camelot V2 and V3, and Balancer V2 on Arbitrum.
SPA is the governance and value-accrual token. Holders stake SPA for veSPA to vote in Sperax governance and earn staking rewards. See SPA tokenomics, the xSPA reward token and the buyback contract.
SperaxOS is the agent workspace this article is about: programmable goals, autonomous yield farming, USDs payments, idle capital deployment and risk controls.
Security is ongoing. Sperax runs a bug bounty program, and every contract address is published in the docs.
To be precise, because precision matters more in crypto than anywhere:
SperaxOS is an independent member of the OpenAI Partner Network at the Select tier. It's a status OpenAI granted after reviewing what Sperax builds on its platform.
SperaxOS runs OpenAI models natively. GPT-5 and the rest of the current OpenAI lineup are first-class providers in the workspace, next to the other model families SperaxOS supports.
It does not mean OpenAI endorses Sperax, USDs, SPA or any token, trade or financial product. OpenAI has not reviewed or approved any DeFi strategy, yield or investment. Nothing in this article is a statement by OpenAI.
SperaxOS is an independent member of the OpenAI Partner Network at the Select tier. This article describes SperaxOS products that integrate with OpenAI platforms; it is not an OpenAI product and is not endorsed by OpenAI beyond the partner designation shown. OpenAI, ChatGPT, and the OpenAI Partner Network badge are trademarks of OpenAI. Learn more at openai.com/business/partners.
With that said, here's why Sperax thinks this matters, and why it's only the beginning.
Sperax won't speak for OpenAI. But you don't need inside information to see why an AI company would care about how money moves. It's on the public record.
In 2025, OpenAI and Stripe released the Agentic Commerce Protocol (ACP), an open standard that powers Instant Checkout in ChatGPT. A user asks ChatGPT for something, and the agent completes the purchase without leaving the chat. PayPal has since adopted ACP too. Checkout inside ChatGPT runs on cards today. The point is the direction: OpenAI is building for a world where agents spend money for people.
An agent that books one flight can use a card. An agent that buys ten thousand data lookups a day at half a cent each can't. Card fees, chargebacks, account sign-ups and multi-day settlement were designed for humans at checkout pages. Stablecoins settle in seconds, cost fractions of a cent and work for any wallet. That's why the conversation about agent payments keeps arriving at crypto.
Coinbase introduced x402 in May 2025: a way for any API to say "pay me" over plain HTTP, and for any agent to pay in a stablecoin and retry, with no account and no API key. In April 2026 it moved to a neutral home, the x402 Foundation under the Linux Foundation. Its premier members include AWS, American Express, Cloudflare, Coinbase, Google, Mastercard, Shopify, Solana Foundation, Stripe and Visa. Stripe added x402 support for USDC on Base in February 2026. The spec is open at x402.org.
To be honest about where it stands, real volume is still early, and press coverage has said so plainly. Standards come first. Volume follows once the tools that agents use accept the protocol by default.
Buying a pair of shoes is a bounded risk. Managing money is not. DeFi markets run around the clock, every position is public, and every action is a transaction that can't be undone. If an agent can be trusted to research a token, size a position and stay inside limits there, it can be trusted almost anywhere. That's Sperax's thesis, not an OpenAI product claim. OpenAI hasn't launched a DeFi product, and nothing here suggests it will.
Frontier models that call tools: OpenAI models native in SperaxOS
Agents that can pay per call: A live x402 facilitator on Arbitrum and Base
A dollar for agent wallets: USDs, which earns yield while it sits
Guardrails around real money: The guard chain, spend limits and the watchdog
Tools any agent can use: Hosted MCP servers and public OpenAPI specs
The rest of this article goes through each of those in turn.
Partnerships follow products. Here's the product.
SperaxOS (chat.sperax.io) is an open-source AI agent workspace built for DeFi. You talk to an agent in plain English. It pulls live market data, reasons about it, shows you exactly what it plans to do, and only then acts on-chain. It's Apache-2.0 licensed, free to use, and self-hostable with one docker compose up. You can read every line that touches your funds.
The workspace ships with over a hundred builtin tool packages. Each one is a real integration with a real data source or protocol, not a prompt pretending to be one:
Markets and data: prices, charts, trending pairs, funding rates, open interest, Fear & Greed, whale-wallet tracking, news and sentiment.
Execution: swaps across aggregators and DEXs (Uniswap, 1inch and more), lending and borrowing (Aave and others), liquid staking, CDPs and savings vaults.
Safety: token audits, honeypot and rug checks, contract risk scoring, liquidity-lock checks.
On-chain intelligence: wallet portfolios, transaction history, gas, cross-chain balances.
Prediction markets, yields and portfolio analytics, all callable by any agent in the same conversation.
A Smart Tool Router sits in front of all of this. When you ask "is this token safe and what's the best place to swap it on Base?", the model doesn't wade through a hundred tool definitions. The router picks the handful that matter, so answers are faster, cheaper and more accurate.
Letting an AI move money only works if the guardrails are real. Every on-chain action in SperaxOS passes through a guard chain before anything is signed:
DeFi Guard and Risk Analyzer: score the action and the contracts it touches.
SpendGuard: enforces per-transaction and per-day ceilings that the agent can't talk its way past.
Slippage and MEV protection: private routing where it's available, so your swap isn't someone else's sandwich.
Deterministic intervention: a human-in-the-loop step that triggers on fixed rules, not on whether the model happens to feel cautious that day.
The model proposes. The guard chain decides. That split is the most important design decision in the product.
Single questions are where people start. Strategies are where they stay. SperaxOS lets you compose multi-step blueprints (watch this, if that, then rebalance) into an executable graph and run it inside your guardrails. Blueprints can be shared in the strategy marketplace. Agents can be minted as on-chain identities under ERC-8004, so an agent's track record and ownership live somewhere verifiable instead of a database row.
The Model Context Protocol is becoming how AI apps connect to tools. Sperax runs seven hosted MCP servers at chat.sperax.io/webapi/mcp/<id>: market, onchain, defi, risk, news, predict and dextools. Point any MCP-capable client at them (an IDE assistant, a desktop agent, or OpenAI's Responses API) and that client gets Sperax's crypto toolset with no integration work. Browse them at chat.sperax.io/mcp. Six are also published to npm as @sperax/mcp-* for anyone who'd rather run them locally.
Since September 2026, Sperax has run its own x402 facilitator at x402.sperax.io. It's the piece of infrastructure that lets an agent pay for an API call over plain HTTP, settled on-chain in seconds, with no account and no API key. More on why that matters below. For now, the headline: SperaxOS can both sell its tools to any agent on the internet by the call, and buy from any other x402 service, with spending limits the agent can't override.
Partner status didn't come from a pitch deck. It came from integration work:
OpenAI models (GPT-5 and the current lineup) and Azure OpenAI are native providers in the workspace.
Sperax's MCP servers are callable straight from OpenAI's Responses API, so a developer building on OpenAI can give their agent live crypto data in a few lines.
SperaxOS publishes a public OpenAPI spec (/api/v1/openapi) and a machine-readable capabilities manifest with an OpenAI-shaped view (/capabilities.json?format=openai), so OpenAI-based agents can discover what SperaxOS offers without reading its docs. The full list is at chat.sperax.io/openai.
A dedicated page at chat.sperax.io/openai lays out every OpenAI integration in one place.
OpenAI is a first-class citizen, not the only one. SperaxOS supports dozens of model providers, including Anthropic, Google Gemini and Vertex, AWS Bedrock, Azure AI, Alibaba's Qwen and NVIDIA NIM, and fails over between them automatically. Your agent shouldn't stop working because one provider has a bad afternoon. Production runs on Google Cloud.
Zoom out from OpenAI and the same pattern shows up across the whole AI industry.
For the first few years of this wave, AI answered questions. The next phase is AI that does things: books the flight, files the expense, renews the subscription, rebalances the portfolio. Every one of those actions ends in the same place: a payment.
Beyond OpenAI's Agentic Commerce Protocol, covered above, card networks, payment processors and cloud providers have all announced their own agent-payment initiatives. The direction is clear: the chat window is becoming a storefront, and the agent is becoming the shopper.
Traditional payments assume a human with a card, a billing address and a reason to sit through a checkout page. Agents break every one of those assumptions:
Volume. An agent might make thousands of tiny purchases a day: a data lookup here, an inference call there. A $0.30 card fee on a $0.005 API call doesn't work.
Speed. Agents operate in milliseconds. Settlement that takes days, with chargebacks possible for months, is a poor fit for software buying from software.
Identity. An agent doesn't have a passport. It needs to pay without opening an account with every service it touches.
Programmability. You want to tell an agent "never spend more than $20 a day on data" and have that enforced by the payment layer itself, not by a promise in a prompt.
Stablecoins on fast, cheap chains solve all four. They move at internet speed, settle in seconds, cost fractions of a cent, work for any wallet without an account, and are programmable by design. That's why you see payment companies building stablecoin rails, and why the conversation about agentic commerce keeps arriving at crypto.
If commerce is where agents start spending, finance is where they're trusted with real responsibility. Managing a portfolio, hedging a position, moving treasury into yield. These are high-stakes tasks where a wrong answer costs money, not just time.
That's exactly the domain SperaxOS was built for. DeFi is the one financial system an AI can operate end to end today, with no bank partnership required, because it's open, programmable and available around the clock. It's also unforgiving, which is why Sperax spent so much of its engineering on the guard chain rather than on the chat box.
Sperax's view: the companies building frontier models will want their models to be useful where the money is, and the teams that make agents safe with money will matter. That's the work Sperax has been doing, and it's the work it will keep doing as a Select Partner.
The web has had a status code for this since the 1990s: HTTP 402 Payment Required. For thirty years it sat unused, reserved "for future use". x402 is an open standard, originally created by Coinbase and now developed in the open at x402-foundation/x402, that finally puts it to work.
Here's the whole flow:
An agent requests a paid API.
The server answers 402 Payment Required with a price, a token and an address.
The agent signs a stablecoin payment and retries the request with the signature attached.
A facilitator verifies the signature and settles the payment on-chain. The server returns the data.
Two round trips. No signup, no API key, no invoice, no monthly minimum. Any agent with a wallet can buy from any service that speaks x402, and any service can sell to every agent on the internet without onboarding them one by one. It turns the open web into a marketplace software can shop in.
Sperax operates its own production facilitator at x402.sperax.io, live since September 2026 and built on the x402 v2 specification. It does three things that matter:
Settles in USDs on Arbitrum. When a SperaxOS tool offers a price, it lists USDs first and USDC at the same price (325 of the 328 paid endpoints today), so buyers can use whichever dollar they hold.
No ETH needed. Normally a buyer needs gas money to approve a token before they can spend it. The Sperax facilitator sponsors that approval, so an agent can start paying with nothing in its wallet but stablecoins.
Works with tokens that don't support gasless transfers natively. USDs doesn't implement the signature-transfer standard (EIP-3009) that USDC uses, so Sperax settles via Uniswap's Permit2. That engineering means any ERC-20 dollar can be an x402 payment token, not just one or two.
On top of that, SperaxOS exposes hundreds of paid endpoints in its x402 catalog (327 listed today), from market data to token audits to DeFi analytics, many priced at fractions of a cent per call. And it works in both directions: SperaxOS agents can pay other x402 services from their own wallets, inside per-payment, per-day and per-seller limits that the agent can't override.
USDs is Sperax's stablecoin on Arbitrum. It's fully collateralised by other stablecoins and it's auto-yielding: the collateral is deployed into established DeFi protocols, and yield accrues to holders automatically, without staking, locking or claiming.
Think about what that means for an agent's wallet. An agent keeps a balance on hand to pay for the services it uses. With most stablecoins, that balance sits idle. With USDs, the balance an agent holds between payments keeps earning. For a human, that's a nice-to-have. For a fleet of agents each holding a working balance around the clock, it adds up.
The plain trade-off: USDs is on Arbitrum only, and its yield varies with market conditions. It isn't a savings account, and nothing here is a promise of returns.
Today x402 is early. Most agents still pay with API keys their developers set up by hand. Sperax thinks that changes fast, for the same reason email beat fax: once both sides speak the protocol, nobody wants to go back. As agent payments grow:
More of the APIs agents call will accept x402 by default.
Agent wallets will become standard features of agent frameworks, with spending limits as a first-class setting.
The stablecoins those agents hold will be chosen for what they do while they sit there.
Sperax is building for that world now: the facilitator, the catalog, the agent-side wallet, and the dollar.
This part matters to a lot of you, so Sperax will be precise about what is live, what is designed, and what it won't promise.
Sperax runs an on-chain SPABuyback contract on Arbitrum (0xFbc0…AFe3). It uses protocol revenue to buy SPA from the market, and the SPA it buys is burned: the contract's reward setting sends 99.99% of purchased SPA to the burn and 0.01% to the caller who triggers it.
Two revenue streams already feed it:
USDs yield. A share of the yield earned by USDs collateral goes to buyback-and-burn, alongside the share that goes to holders.
USDs mint and redeem fees. The USDs vault's fee destination is the buyback contract itself, so those fees end up as burned SPA too.
You don't have to take Sperax's word for any of this. The contract is public, the burns are events on Arbitrum, and anyone can verify them on Arbiscan. As of 24 September 2026 the contract had recorded 756 burns totalling about 9.88M SPA.
The direction for SperaxOS is to connect the workspace's activity to that same burn. The Sperax token flywheel design describes five loops. All five are still in design, not live. The full list and build order are in the flywheel section below. The four that touch revenue most directly:
Pay for compute in SPA, at a discount. Metered agent usage can be paid in SPA, with the SPA routed toward buyback.
A protocol fee on agent commerce. As agents buy and sell through x402 and agent-to-agent payments, a small protocol fee is designed to flow into SPABuyback. More agent commerce means more buyback.
More USDs held, more yield to the burn. Every agent wallet that holds USDs as its working balance adds collateral that earns yield, part of which goes to buyback.
veSPA utility. Locking SPA as veSPA is designed to unlock higher tiers in SperaxOS: more concurrent agents, autopilot, higher spend ceilings, MEV-protected routing, priority tool routing and premium strategy blueprints.
The logic is simple: if agents use SperaxOS, pay in USDs and transact over x402, then real usage turns into real buyback demand, and the SPA bought is burned.
Sperax won't tell you what SPA will be worth. Nobody honest can. A burn is only as meaningful as the usage behind it, and usage has to be earned with a product people choose. That's why the rest of this article is about the product. Nothing here is financial advice or a promise of price, yield or returns.
No one builds an agent economy alone. Here's who Sperax works with, described exactly as it is.
SperaxOS is a member of the OpenAI Partner Network at the Select tier. OpenAI models are native in the workspace, Sperax's MCP servers work with the Responses API, and Sperax publishes OpenAI-shaped discovery endpoints so OpenAI-based agents can find and use its tools. Everything is gathered at chat.sperax.io/openai.
IBM Community published an article on Sperax's work with three.ws, Sperax's sister project, covering the agent infrastructure behind both. It's recognition from one of the oldest names in enterprise computing that this category matters.
DEXTools is built deep into SperaxOS. Its charts are the default across Markets, Trading, Portfolio and the token terminal. Agents can generate DEXTools chart artifacts in chat, run DEXTools token audits and safety scores, and DEXTools has its own hosted Sperax MCP server, so any MCP client can use it.
SperaxOS ships a full ListaDAO integration on BNB Chain: 13 agent tools covering BNB liquid staking, the lisUSD CDP, savings, farms and the peg stability module. Those tools are also available by the call through the Sperax x402 catalog, so any agent on the internet can use ListaDAO data and actions for fractions of a cent.
Alibaba's Qwen models are a native provider in SperaxOS, and Alibaba Cloud is a supported target for self-hosting the workspace. That gives teams in Asia, and anyone who prefers Qwen, a first-class path.
Arbitrum: the native home of USDs, SPA, the buyback contract and the Sperax x402 facilitator.
Google Cloud: where production SperaxOS runs.
NVIDIA NIM: part of the SperaxOS model failover chain, so agents keep working when a provider is down.
The x402 standard: the open protocol the Sperax facilitator implements, started at Coinbase and now maintained at x402-foundation/x402.
SperaxOS integrates with the protocols DeFi actually runs on, including Uniswap, 1inch, Aave and many more, plus the leading market-data, on-chain and security data providers. Each one is a real integration your agent can call, not a link in a list.
To every team that has built with Sperax, integrated with Sperax or written about Sperax since the early days of USDs: thank you. This milestone is yours too.
Every fund-moving action in SperaxOS passes a guard chain, and the chain fails closed. This section explains how that works, because "we have guardrails" is the most overused sentence in crypto AI and Sperax would rather show the mechanism.
SperaxOS has six independent guards. Each one runs from a different place in the runtime and checks something different:
InterventionChecker (the agent's decision loop) checks human approval.
DeFiGuard (tool execution) checks portfolio risk, MEV exposure, dollar caps, destination-token safety.
CapabilityGuard (the tool executor) checks whether the agent holds a capability token for this action.
PermissionGuard (the tool executor) checks the agent's permission level.
SpendGuard (transaction preflight) checks the spend envelope: per-transaction, rolling and daily caps, plus a reserve floor.
X402Hook (the x402 payment path) checks an hourly budget for autonomous payments.
Layering like this is normal in security engineering. It also has a well-known failure mode: when six components each guard their own door, nobody can say what happens to a particular request without tracing six code paths by hand. Silence from a guard is ambiguous. It might mean the guard checked the call and allowed it. It might mean the guard never saw the call.
That ambiguity matters because several of the ways enforcement can lapse look exactly like a clean "allow":
Unregistered tools. If a tool that mutates onchain state isn't in DeFiGuard's registry, DeFiGuard returns early. No risk analysis, no MEV analysis, no caps.
Unresolved dollar values. If a call reaches a dollar cap with no resolved USD value, the cap compares against zero, and zero passes every cap.
Batch dispatch. The capability and permission checks intercept single tool calls. A tool dispatched inside a batch could reach its handler without passing them.
The Sperax team found these by reading its own code with a hostile eye. Instead of patching each one quietly, it built a component whose only job is to make lapses like these visible.
Guard Chain evaluates a single tool call against every enforcement layer in one pass. It answers two questions: which layer would stop this call, and which layers would never look at it.
Layers run in the order they would fire at runtime:
Security blacklist
Intervention (human approval mode)
Capability token
Permission level
DeFiGuard
SpendGuard
The x402 autonomy budget
The chain does not stop at the first block. A partial trace would hide useful facts, such as a call that the spend envelope blocked also carrying critical MEV exposure, or the permission layer never having run. Every layer reports one of six statuses:
pass: the layer evaluated the call and allowed it.
warn: allowed, with a notice.
approval_required: a human has to confirm.
block: the layer refuses.
error: the layer could not finish. This counts as a block, because guards fail closed.
skipped: the layer never evaluated the call.
"Skipped" is deliberately separate from "pass". Merging the two is the exact failure the module exists to expose, so the interface shows skipped layers in grey, never in green.
The final verdict is the most severe status across all layers. Block and error outrank approval, which outranks warn. When two layers tie, the earlier one wins, so the reported reason names the layer that would actually fire first in production.
An "allow" can be a strong statement or a weak one. Each verdict therefore carries a coverage score: the share of enforcement weight that applied to the request and actually evaluated it.
DeFiGuard: 30
Intervention: 15
Permission: 15
SpendGuard: 15
Capability: 10
Security blacklist: 10
x402 budget: 5
Only layers that apply to the request count. A read-only call isn't penalised for skipping the spend envelope, and the x402 layer counts only when there is a payment. An "allow" at 45% coverage says much less than the same verdict at 100%, and the score makes that difference visible.
Coverage only tells you whether a layer ran. It cannot tell you what the layer declined to check. A call with no resolved dollar value can score 100%, because every layer ran, while every dollar cap compared against zero. That is why the chain also reports blind spots.
Blind spots are derived from the shape of the request and ordered most severe first. Each one comes with a remediation that names the specific change that closes it.
VALUE_UNRESOLVED (Critical): A mutating call arrived without an authoritative USD value, so every dollar check compares against $0.
TOOL_UNREGISTERED (Critical): The call changes onchain state, but DeFiGuard doesn't know the tool and skips it entirely.
BATCH_BYPASS (Critical): Batch dispatch bypasses the capability and permission checks, and the batch executor has no concurrency cap.
SPEND_UNSCOPED (Critical): Value leaves the wallet with no spend envelope: no caps, no reserve floor, no destination firewall, no breach latch.
TOKEN_SAFETY_UNCHECKED (Critical or warning): A token-buying call ran without a token safety report. Critical when the destination is a raw contract address.
PROTOCOL_UNVERIFIED (Warning): The target protocol isn't in the audit registry. With an empty registry, every protocol reads as unaudited and the signal means nothing.
CAPABILITY_UNWIRED (Warning): No capability validator on this path.
PERMISSION_UNWIRED (Warning): No permission resolver on this path.
READONLY_UNANALYZED (Info): A read-only DeFi call that is skipped by design. Cheap, but read paths carry no risk telemetry.
Sperax publishes this list for two reasons. If you build on SperaxOS, you should know exactly where enforcement depends on configuration. And if you run agents anywhere else, these are the questions to ask of any agent platform that claims to be safe.
Guard Chain does no I/O. Every outside dependency is injected: the capability lookup, the permission lookup, the wall clock and the timer. The same code serves live preflight, the simulator and the tests, and identical input produces an identical verdict. A guard that throws is caught, reported as an error and treated as a block, so an unavailable validator can never open the money path.
In code it looks like this:
const chain = new GuardChain({ defiGuard: new DeFiGuard(), spendGuard: new SpendGuard({ dailyMaxUsd: 50_000, perTxMaxUsd: 5_000 }), }); const verdict = await chain.evaluate({ apiName: 'executeSwap', arguments: { chainId: 1, fromToken: 'ETH', slippage: 0.5, toToken: 'USDC' }, identifier: 'sperax-swap', valueUsd: 8_400, }); // verdict.decision, verdict.blockedBy, verdict.coverageScore, verdict.layers, verdict.blindSpotsThe /guard-chain page in SperaxOS lets you compose a tool call and evaluate it against your real tier, caps, volume, permissions and capability tokens, then read the full trace. Four presets reproduce the structural gaps described above. The page is strictly read-only: it resolves your real limits but writes nothing. It records no audit rows, adds no volume and uses up no capability tokens.
Sperax thinks every agent platform that touches money should offer something like this. If a platform cannot show you which of its guards ran on a given action, it cannot honestly tell you that the action was guarded.
In one line, x402 means agents that pay their own way. Here is the longer version.
The web never had a native way to pay. HTTP reserved status code 402, "Payment Required", in the 1990s and then left it unused for about thirty years. Paying for an API today means creating an account, adding a card, getting an API key, picking a subscription tier and hoping your usage fits it. That process was designed for humans with credit cards.
An agent has none of those things. It cannot fill in a signup form or pass a card check. It also doesn't want a monthly plan for an API it calls three times. It wants to pay half a cent for one answer, right now, and move on.
x402 is the open standard, started by Coinbase, that finally puts HTTP 402 to work. The flow is short:
The client requests a resource.
The server answers 402 with a PAYMENT-REQUIRED header describing what it accepts: asset, amount, network and recipient.
The client signs a payment and retries with a PAYMENT-SIGNATURE header.
A facilitator verifies the signature and settles the payment onchain.
The server runs the request and answers 200, with a PAYMENT-RESPONSE header carrying the settlement receipt.
There are no accounts, no API keys and no invoices. The payment is the authentication.
A facilitator is the service that verifies and settles x402 payments. Sperax runs one at x402.sperax.io. It is open source, runs on Google Cloud Run, and has been live on Arbitrum and Base since 18 September 2026. The first mainnet USDs payment through it settled in transaction 0x4b95dec2…21d3f2. Sperax also opened a pull request upstream so other x402 implementations can use the same path.
Endpoint: x402.sperax.io
Source: github.com/Sperax/USDs-x402-facilitator
Hosting: Google Cloud Run
Networks: Arbitrum, Base
Live since: 18 September 2026
USDs settlement: Permit2, approval gas sponsored
USDC settlement: EIP-3009 transfer with authorization
First USDs payment: 0x4b95dec2…21d3f2 on Arbitrum
Upstream PR: x402-foundation/x402#3513
Most x402 payments use USDC, which supports EIP-3009, a signature-based "transfer with authorization". USDs doesn't support EIP-3009. Instead of giving up on USDs, Sperax settles it through Permit2, Uniswap's widely deployed signature-based approval contract, and the facilitator sponsors the gas for the one-time approval. For the payer, the experience is the same: sign once and pay.
One detail that matters for builders: USDs is a rebasing token, and smart-contract accounts must call rebaseOptIn() to receive yield. Externally owned wallets earn by default. If your agent uses a smart account, opt it in.
Why go to this trouble? Because USDs earns yield while it sits in a wallet. An agent holding a float to pay for APIs has idle cash by definition, and in USDs that idle cash earns. USDC sits flat. For a fleet of agents holding working balances, the difference adds up.
The live discovery document lists 327 paid resources today. Most cost $0.001 per call and the most expensive cost $0.02. By category:
DeFi: 42
Markets: 27
Agents: 27
Launchpads: 23
Yield: 18
Derivatives: 18
Prediction markets: 15
DEX: 14
On-chain: 13
Sperax: 10
Security: 9
Governance: 8
Three core data endpoints, for a sense of pricing:
Markets: $0.005 per call, paid in USDC on Arbitrum
Yields: $0.01 per call, paid in USDC on Arbitrum
Fear and greed index: $0.001 per call, paid in USDC on Arbitrum
User-scoped endpoints (your profile, watchlist and alerts) are free behind Sign-In-With-X, the wallet-signature login. The billing rules are written to be fair to the payer:
Success: 200 with the data. You are charged.
Handler fails: Error. You are not charged.
Server missing upstream credentials: 503. You are not charged.
Upstream fails: 502. You are not charged.
USDs is listed first in 325 of the 328 paid offers, with USDC on Arbitrum and Base accepted at the same price. The three core data endpoints above take USDC only for now.
Giving an agent a wallet is one thing. Giving it a wallet with sensible limits is what makes autonomy acceptable. In SperaxOS, a limit hook runs before the agent signs any x402 payment. It enforces caps per payment, per day, per seller and per hour. An owner can always tighten these limits, and nothing in the agent's own context can loosen them.
Every payment is written to the x402_payments ledger, which is the record of what the agent bought, from whom and for how much. A server-side request-forgery guard stops an agent from being tricked into paying an internal or malicious address. Owners can pull a USDs statement for any agent wallet.
Once agents can pay, the obvious next step is agents getting paid. SperaxOS has the first version of an agent-to-agent market, with two payment rails:
x402: POST /api/a2a/:agentId/:serviceId, paid in USDs via Permit2 on Arbitrum first, or USDC on Base, Ethereum, Polygon, Avalanche, Sei and Abstract
Prepaid tx hash: POST /api/v1/agent/:agentId/execute, paid in USDC on any supported chain, including BSC; the caller submits the transaction hash
Other agents can find these services through standard discovery surfaces:
/openapi.json, an OpenAPI description of the platform
/.well-known/x402, the x402 discovery document (capped at 500 entries)
GET /api/a2a/directory, a directory of agents and their services
/api/a2a/:agentId/card, a Google A2A AgentCard for each agent, plus a platform-level agent card
The point is interoperability. An agent built on a completely different stack can discover a SperaxOS agent, read its card, pay it over an open standard and get a result, with no partnership deal and no shared account system. That is what Sperax means by agentic commerce: not a walled garden of bots, but open rails where software buys and sells work.
Agent payments will happen whether or not any single company builds them. The question is which rails they run on. Closed rails mean every agent economy is a platform's private store with a platform's fees. Open rails mean an agent anywhere can pay an agent anywhere. Sperax is betting on open rails, and it is making sure a yield-bearing stablecoin is a first-class way to pay on them.
The guard chain is the frame. Three of its parts deserve a closer look, because they handle the failures people actually lose money to: buying a scam token, an agent spending past what its owner intended, and an automated job that quietly stops working.
The single most common way to lose money onchain isn't a sophisticated exploit. It is buying a token you can't sell. Honeypots, hidden owner functions, 90% sell taxes and unlocked liquidity are routine on long-tail tokens. A human trader can at least hesitate. An agent told to "buy the trending token" will not, unless the system makes it.
SperaxOS checks the destination token before any call that buys one. That covers swaps, bridges, swap builders, DCA orders and limit orders. The check combines two independent sources, queried in parallel, each with its own time budget:
DEXTools: the token audit, DEXTscore and liquidity-lock data.
GoPlus: contract-level security analysis.
Before this work, the check ran only in the browser at quote time. If an agent built a transaction without going through that screen, nobody checked anything. Now the check runs on the server and feeds directly into DeFiGuard, so it applies whether a human clicked a button or an agent acted alone.
The result is one of four verdicts, decided by rules applied in strict order:
If any source raises a danger flag, the verdict is danger.
If no source could produce a report, the verdict is unknown. Absence of evidence is never treated as safe.
If any source raises a caution flag, the verdict is caution.
Otherwise, the verdict is safe.
Danger flags include a honeypot (the token can't be sold), being unable to sell the full balance, being unable to buy, an owner who can change balances, a hidden owner, a self-destruct function, airdrop scams, a known potential scam, and a buy or sell tax of 30% or more.
Caution flags include a tax of 10% or more, mint authority that hasn't been renounced, reclaimable ownership, an upgradeable proxy, closed-source code, pausable transfers, blacklist or whitelist functions, trading cooldowns, modifiable taxes, a creator with a history of honeypots, no DEX listing, less than 50% of liquidity locked, liquidity under $10,000, and a DEXTscore under 50.
DeFiGuard turns those verdicts into actions:
danger blocks the transaction.
caution requires human approval.
unknown requires approval when the trade is worth $1,000 or more, or when its value can't be resolved.
Here is a concrete case. An agent builds a swap of 500 USDC on Base into a token contract that GoPlus flags as a honeypot. The verdict is block, and the trace shows the DeFiGuard layer refusing with code TOKEN_SAFETY_DANGER. The agent gets a clear reason, and the user's 500 USDC stays in the wallet.
Native tokens, SPA and USDs are on an allowlist and skip the lookup. GoPlus covers 15 EVM chains. DEXTools covers those plus Unichain, Sonic, Berachain and Solana.
Token safety asks whether a particular trade is a bad idea. SpendGuard asks a different question: regardless of what the agent wants to buy, is it allowed to spend this much right now?
Every agent wallet can have a spend envelope with four limits:
perTxMaxUsd: the most any single transaction can move.
A rolling window cap: the most that can leave over a moving window, 24 hours by default.
dailyMaxUsd: the most that can leave per calendar day.
reserveFloorUsd: a balance the agent can never spend below.
On top of the caps sits a destination firewall. Owners can deny specific tokens or destination addresses, or allow only a specific list. When a deny rule and an allow rule conflict, the deny wins. Strict mode turns the allow list into the only list.
SpendGuard also reconciles against custody. If the actual wallet balance diverges from what the envelope expected, which suggests funds moved outside the agent's normal path, the envelope latches into BREACH and stops all spending until a human looks at it. A latch is intentionally sticky: the agent cannot clear it by retrying.
Every refusal comes with a specific code: CAP_PER_TX, CAP_ROLLING, CAP_DAILY, RESERVE_FLOOR, FIREWALL_DENY_TOKEN, FIREWALL_DENY_DEST, FIREWALL_NOT_ALLOWED or BREACH. The agent and the user both learn exactly which limit applied.
SpendGuard was ported from three.ws, where it was built for the same problem. In SperaxOS the configuration lives in the agent_spend_limits table, scoped to each user, so one account's limits can never affect another's.
Autonomous agents run on schedules: rebalance every morning, check a position every hour, compound rewards every week. Scheduled systems have a quiet way of failing. The job runs, returns success and does nothing. Or the scheduler stops calling it at all, and nothing complains because nothing is running.
The SperaxOS watchdog judges tasks by their side effects, not their status codes. Its question is not "did the endpoint return 200?" but "did the work actually happen?" Three rules cover the common failures:
tasks-overdue (high, or critical if every task is overdue): A task is more than 45 minutes past its scheduled run
executor-silent (high): No executions at all for more than an hour
tasks-failing (medium): A task has failed 5 or more times in a row
Tasks are claimed with a compare-and-set on their next run time, so two workers can't pick up the same task and run it twice. That matters a lot when the task moves money. Schedules use standard five-field cron syntax in UTC.
In the spirit of honesty: the production server doesn't yet have a scheduler installed to drive these jobs. The watchdog, the claiming logic and the task engine are built and tested, but scheduled autonomous tasks don't run on chat.sperax.io until a scheduler is wired in. Sperax would rather say that plainly than let anyone assume a cron job is quietly running their strategy.
SperaxOS has over 100 builtin tools, and a router picks the right ones for each message. That sounds like a convenience feature. It is really an answer to an economic and accuracy problem every tool-heavy agent runs into.
When you give a language model tools, you send it a description of each one: its name, purpose and the exact shape of its arguments. In SperaxOS, a typical tool definition costs about 1,200 tokens. With 72 tools enabled, that is roughly 86,400 tokens on every request before the user has typed a word.
That has three costs:
Money. You pay for those tokens on every turn of every conversation.
Latency. The model has to read all of them before it can respond.
Accuracy. A model choosing among 72 tools makes more wrong choices than one choosing among five. Similar tools blur together, and the right one gets lost.
The usual workaround is to make users enable and disable tools by hand. That pushes the problem onto the person least equipped to solve it. Someone asking about a lending position shouldn't have to know which of a hundred tools reads lending positions.
The Smart Tool Router splits each request into two passes:
Classify. A small, cheap model reads the user's message and picks the IDs of the tools it is likely to need. It sees short tool summaries, not full schemas.
Answer. The main model receives only the schemas for those selected tools, plus a small set of always-on tools, and handles the request as usual.
The main model now reads a handful of tool definitions instead of dozens. Requests get cheaper and faster, and the model chooses among a short list of relevant options.
A router that guesses wrong can hide the right tool. The design accounts for that:
Always-on tools are included on every request, regardless of what the classifier picks.
Fallback on error: if the classifier fails or times out, the request proceeds with the full tool set. A router failure costs tokens, never a broken answer.
Caching: repeated classifications are cached so the extra pass doesn't add cost on every turn.
A deterministic preview endpoint shows which tools the router would choose for a given message, so developers can test routing without spending model calls or signing in.
Two switches control the router. A server-side feature flag, smart_tool_router, is on by default and lets operators turn the feature off for everyone. A per-user lab preference, "Smart Tool Router", is off by default and can be toggled from the chat input's action bar. Both have to be on for the router to run.
SperaxOS ships it as an opt-in lab feature on purpose. Routing changes what the model sees, and users should decide when to accept that trade.
For a chat assistant, a wrong tool choice means a worse answer. For an agent that can move money, a wrong tool choice can mean the wrong action. Fewer, more relevant tools in context is a quality improvement and a safety improvement at the same time. The router narrows what the model can consider, and the guard chain checks what it actually tries to do.
A workspace is useful to the people who log into it. Infrastructure is useful to everyone. A large part of what Sperax built is meant to be used outside SperaxOS: by other agents, other IDEs, other chat products and other developers.
The Model Context Protocol (MCP) is an open standard for connecting AI models to tools. A model that speaks MCP can discover a server's tools, read their schemas and call them, without custom integration code for each one.
SperaxOS has more than 100 tool packages and more than 580 tool APIs internally. The MCP gateway exposes a carefully chosen subset of them to the outside world through seven hosted servers:
market: prices, market caps, volumes, trending assets. npm: @sperax/mcp-market
onchain: balances, transactions, contract and wallet data. npm: @sperax/mcp-onchain
defi: protocol TVL, yields, lending and liquidity data. npm: @sperax/mcp-defi
risk: token and contract security signals. npm: @sperax/mcp-risk
news: crypto news and sentiment. npm: @sperax/mcp-news
predict: prediction market data. npm: @sperax/mcp-predict
dextools: DEX pair, pool and token analytics. Hosted only.
Each hosted server lives at chat.sperax.io/webapi/mcp/ followed by its name.
Together these servers expose 65 tools and 319 read-only APIs. Six of them are published on npm, so you can run them locally as well as use the hosted endpoints: market, onchain, defi, risk, news and predict.
Internal tool packages: 100+
Internal tool APIs: 580+
Hosted MCP servers: 7
Public tools: 65
Public read-only APIs: 319
Tools excluded by the exposure bar: 31
Servers on npm: 6
The important design decision is what Sperax didn't expose. A tool reaches the public gateway only if it meets every one of these conditions:
Public and read-only. It reads data. It never writes, signs, sends or trades.
Explicit arguments only. If a tool needs a wallet address, the caller passes the address as an argument. It never falls back to the session's connected wallet. That way a public tool can't be tricked into acting on a user's identity.
No side effects. Calling it twice changes nothing.
No per-user credentials. It doesn't depend on a key or token tied to one account.
No host access. It can't touch the server's filesystem, shell or environment.
Thirty-one tools failed that bar and are excluded. Each exclusion is recorded with its reason, so the boundary is auditable rather than a matter of someone's memory. Anything that moves funds stays inside SperaxOS, behind the guard chain.
The catalog is public:
GET https://chat.sperax.io/webapi/mcp returns the machine-readable list of servers and tools.
The /mcp console at chat.sperax.io lets humans browse the same catalog and copy connection details.
The servers are listed on the official MCP registry, Smithery, Glama and the Claude Code plugin marketplace. They work with OpenAI's Responses API, IDE assistants and any other MCP client.
The pattern isn't new to Sperax. three.ws, its sister project, runs around 38 MCP servers on the same approach, and the gateway design carries over what worked there.
Not everyone wants to wire up MCP. For people who live in ChatGPT, Sperax built a Custom GPT called Sperax DeFi Analyst. It's ready for the GPT Store and will launch separately from this article, but the design belongs here.
It is read-only by design. It can research, compare and explain. When a user wants to act, it hands them off to chat.sperax.io, where the guard chain, spend limits and approval flow apply. A GPT that can move money from inside someone else's chat product would bypass every protection described above, so it doesn't.
Under the hood, the GPT calls 27 operations:
25 GET endpoints from the Sperax Data API.
listSperaxTools, which lists the available tool catalog.
callSperaxTool, which calls any read-only tool across seven groups, about 320 tools in total.
The OpenAPI specification is public at GET https://chat.sperax.io/api/v1/gpt/openapi, so anyone can build their own GPT or agent against the same surface. Authentication uses an x-api-key header with the intel scope.
A few operating details, because developers ask:
callSperaxTool cost: 2 credits per call. Flat price per call, whatever the tool.
Output cap: 60,000 characters. A single response can't overflow the model's context.
404 or 400: Not charged. You don't pay for a missing tool or bad arguments.
Tool throws: 502. Clients can tell a bad request from an upstream failure.
Suggested rate limit: 120 requests per minute. Suggested for clients.
Auth: x-api-key header, intel scope. Same key as the Data API.
MCP for agents and IDEs, OpenAPI for GPTs and custom clients, and the full workspace for people who want to act. That's the same data and the same discipline across three surfaces.
Every token project has a flywheel diagram. Most of them describe hopes. This section separates what runs today from what is designed, and says plainly what could go wrong.
The buyback. SPABuyback at 0xFbc0…AFe3 on Arbitrum is live. It is funded by USDs yield and USDs mint and redeem fees. When it runs, it buys SPA, burns 99.99% of what it buys, and pays 0.01% to whoever triggered the call, so anyone can keep it running.
SPA-derived guard tiers. SperaxOS already reads SPA holdings to set an account's DeFiGuard tier:
10,000 or more SPA: Silver tier, Basic DeFiGuard
100,000 or more SPA: Gold tier, Pro DeFiGuard
1,000,000 or more SPA: Platinum tier, Pro DeFiGuard
Higher tiers unlock higher limits and more capability in the guard system. Tiers also set how many autonomous tasks an account can run at once, from 10 at the base level up through 15, 25, 50 and 100.
That's the full list of what is live. Router priority by tier and minimum holdings for autopilot are designed but not shipped.
The design ties SPA to agent activity through five loops:
Metered compute in SPA. Agents pay for compute and premium tools in SPA, with a cut routed to the buyback.
veSPA gates capabilities. Locking SPA as veSPA unlocks higher capability tiers, extending what the guard tiers already do.
A take rate on agent commerce. When agents pay each other for services, logged in the agent commerce ledger, a small take rate flows to SPABuyback.
SPA reputation bonds. Agents post SPA as a bond behind an onchain identity (ERC-8004). Bad behaviour can cost the bond, so trust has a price.
USDs as the default treasury. Agent treasuries hold USDs by default, so idle agent money earns yield, and that yield feeds the buyback.
Sperax plans to build them in this order: loop 3 first, then 2, then 5, then 1 and 4. The take rate on agent commerce comes first because it only needs the commerce rails that already exist. It ties the buyback directly to real usage instead of to speculation.
Here is what Sperax thinks this adds up to, in one sentence: SPA becomes the metering, collateral and settlement asset for an agent labour market. Agents use it to pay for work, to bond their reputation and to unlock capability. A share of that activity buys and burns SPA.
That is a claim about design, not a promise about price. It works only if agents actually do paid work through SperaxOS.
Sperax would rather name the risks than have readers find them:
No usage. If agents don't transact, a take rate on zero is zero. The flywheel depends on real activity.
Fees routed around the protocol. If paying through Sperax costs more than going direct, developers will go direct. The take rate has to stay small enough that it isn't worth avoiding.
Gating that drives users away. If capability tiers feel like a toll booth, people will use other tools. Gating has to unlock real value, not hold basic features hostage.
Bond capital efficiency. Locking capital in reputation bonds has a cost. If bonds are too expensive, agents won't post them, and if they're too cheap, they don't mean anything.
Sperax will publish the parameters for each loop before it ships, and it will report usage once there is usage to report.
Partner status gives Sperax a way to reach the people building on OpenAI. Here's what Sperax is preparing. These are Sperax's plans. Joint pieces go out only once both sides sign off, and none of this is an OpenAI announcement.
Step-by-step developer recipes that run end to end, each with working code:
Give an agent live DeFi data by calling Sperax MCP servers from the OpenAI Responses API.
Build an agent that checks a token's safety before it trades, using the same tools as the guard chain.
Pay for an API call over x402 in USDs, from wallet setup to settled transaction.
Build your own GPT on the public Sperax GPT OpenAPI spec.
They'll live at chat.sperax.io/developers, and Sperax will contribute them to community cookbook collections where recipes are accepted.
Sperax DeFi Analyst, described in the developer section above, is ready for the GPT Store. More focused GPTs will follow, for jobs like token safety checks, yield comparisons and learning x402. Every one of them is read-only, and anything that moves money hands off to SperaxOS and its guard chain.
A ChatGPT app and a browser extension are in development. The goal is the same in both: put SperaxOS research and token safety checks where people already are, in the chat and on the pages where they trade, without giving up the guardrails.
Expect joint threads, X Spaces, blog posts and case studies with partners across the ecosystem, showing real agents doing real work with real numbers. Follow @SperaxUSD and @SperaxDAO for each one as it goes out.
Developer cookbooks — In progress · chat.sperax.io/developers
Sperax DeFi Analyst GPT — Ready for the GPT Store · ChatGPT
More Custom GPTs — Planned · ChatGPT
ChatGPT app — In development · ChatGPT
Browser extension — In development · Browser stores
Social and blog co-marketing — Planned · X, blogs, Spaces
Becoming a Select Partner is a starting line, not a finish line. This is the part of the article Sperax cares about most, so here's the whole plan. Every item is labeled Live (you can use it today), Building (in active development) or Planned (designed and committed to, not yet built). Sperax would rather show you a big roadmap honestly than a small one dressed up.
Start with the big picture, because everything below follows from it.
Stablecoins are becoming the internet's dollar. The US passed the GENIUS Act in 2025, giving payment stablecoins a federal framework. Stripe, Visa, Mastercard, Shopify, Google, AWS and American Express now sit on the x402 Foundation alongside Coinbase. Money that moves like data is no longer a crypto idea. It's a payments-industry plan.
Traditional assets are moving on-chain. Treasuries, money-market funds and stocks are being issued as tokens. Robinhood runs its own chain with tokenized US stocks. The line between "a brokerage account" and "a wallet" is starting to blur.
Software is becoming a customer. AI agents will open accounts, pay for services and manage balances on behalf of people. They need rails that settle by the call, around the clock, with no card number.
Most people will never touch a seed phrase. The next millions of crypto users will arrive through apps that feel like a bank, an assistant or a chat window. The chain will be underneath, not in their face.
Sperax sits where all four lines cross: a yield-bearing dollar, an agent workspace, an x402 payment rail and a safety system built for money. Here's what Sperax is doing with that position.
Most people will never read the word x402. What they understand is a bank account. So that's what Sperax built.
The bank page turns your agent wallet on Arbitrum One into an account you already know how to read: a balance in USDs and USDC, an activity feed, and agent accounts. Each agent account is an envelope of your balance that you hand to one agent, with its own spending limit. The money stays in your wallet and keeps earning USDs yield until the agent actually spends it. If an agent tries to pay more than its envelope or its limit allows, the payment is refused before anything is signed.
Where it goes next:
Building: smart-account wallets for agents (ERC-4337, through the SperaxOS Plutus integration), so an agent can hold its own account with rules enforced on-chain, not just in SperaxOS software.
Planned: scheduled allowances ("this agent gets $20 a week"), shared household and team accounts, and monthly statements you can export.
Planned: agent accounts for agents that aren't built on SperaxOS. Any agent framework should be able to open a USDs account, pay over x402 and stay inside limits its owner sets.
DeFi has better yield and better transparency than most bank products. It also has a worse user experience than almost anything people use daily. Sperax is closing that gap.
Live: buy crypto with a card or bank transfer inside SperaxOS through Coinbase Onramp, straight into your wallet.
Live: USDs Auto Yield. Hold it and your balance grows by rebase. No staking, no claiming, no lockups.
Planned: a "savings" view where idle dollars sit in USDs or a vetted yield vault, and you see one number: what you have and what it earned.
Planned: plain-language everything. "Move $500 to savings." "Pay my agents from my checking balance." "What did I earn this month?" The assistant translates that into the on-chain steps, checks them through the guard chain, and shows you the receipt.
The goal is simple: a person who has never used a wallet should be able to earn on-chain yield as easily as opening a savings account, without being exposed to risks they don't understand.
Most of the world's money lives in traditional finance. Most of the best financial infrastructure being built today lives on-chain. SperaxOS is designed to be the translator between the two.
Live: fiat on-ramp, cross-chain bridges, lending markets, yield vaults and a yield optimizer, all available as agent tools behind the guard chain.
Live: tax reporting and paper trading, so people coming from a brokerage can practice and keep records the way they're used to.
Live: prediction-market data from Kalshi, a CFTC-regulated exchange, next to on-chain Polymarket data in the same workspace.
Live: spending crypto in the real world through Bitrefill gift cards and top-ups.
Planned: comparing a bank or money-market rate with on-chain yield side by side, with the risks of each spelled out, so people can make the move into DeFi knowingly instead of blindly.
Real-world assets (RWAs) are the bridge between the two worlds in asset form: a Treasury bill, a stock or a fund, issued as a token anyone can hold.
Live today: SperaxOS agents can already read Robinhood Chain's tokenized US stocks and ETFs (TSLA, NVDA, SPY and more) with live Chainlink prices and staleness checks. Chainlink price feeds are a first-class tool across every chain SperaxOS supports.
Planned: RWA research tools covering tokenized treasuries, money-market funds and equities, with issuer, custody, redemption and liquidity risk shown up front.
Planned: RWA positions in agent strategies, so an agent can split a portfolio between on-chain yield and tokenized real-world yield, with the same guard chain checks as any other trade.
Exploring: how tokenized real-world yield could complement USDs. Any change to USDs collateral is a governance decision for SPA holders, and Sperax will bring it to them in the open.
USDs was built in 2021 on one idea: your dollars should earn while they sit. That idea matters even more for agents.
An agent's budget sits idle most of the time, waiting for the next task. On a card or in a bank, that money earns nothing. In USDs, it earns until the second it's spent. Every agent account on the bank page works this way today.
Live: USDs Auto Yield for every holder, human or agent. USDs payments over x402 on Arbitrum.
Planned: agents that manage idle capital for you: sweeping spare balances into USDs or vetted vaults, and pulling them back when you need them, inside limits you set.
Planned: yield reporting per agent, so you can see which of your agents paid for itself.
This is the part of the Sperax roadmap with no ceiling.
Every protocol, exchange, data provider or app becomes one more thing SperaxOS can do the moment it's wrapped as a tool or an MCP server. Sperax doesn't need a years-long integration project to partner with someone. It needs a well-defined API and a safety review.
Live: 112 built-in tools, covering DeFi protocols, market data, security scanners, wallets, prediction markets, payments and everyday apps.
Live: 7 hosted MCP servers that any MCP-compatible client can plug into, including ChatGPT, Claude and code editors.
Live: 327 paid x402 endpoints. Any partner can sell their service to agents through the Sperax facilitator and get paid per call in USDs or USDC.
Expanding: partnerships. Sperax is actively bringing more protocols, data providers and AI platforms into SperaxOS. Every partner Sperax adds as a tool reaches every SperaxOS user and every agent on its MCP servers on day one, and every partner selling over x402 gets a new channel of software customers.
If you build a protocol or an API and want your product in front of AI agents, this is the fastest way there. Reach out on Discord or X.
Crypto's next wave of users won't come from crypto Twitter. They'll come from the tools they already use every day.
Live: SperaxOS works with Gmail, Google Drive, Notion and Slack next to its on-chain tools. One agent can read your inbox, update your notes and manage a DeFi position in the same conversation.
Live: OpenAI models as first-class providers and a public OpenAPI spec that any GPT can call. The first Sperax Custom GPT, Sperax DeFi Analyst, is built and launches separately.
Building: a ChatGPT app and a browser extension, so people meet Sperax where they already spend their day.
Planned: onboarding that starts with an email address and a card, not a seed phrase, with self-custody available the moment someone wants it.
The people who will use DeFi next don't think of themselves as crypto users. They want their money to work harder and their assistant to handle the busywork. Sperax is building for them.
Agents won't only buy from companies. They'll buy from each other.
Live: agents in SperaxOS can sell capabilities to other agents over x402, priced per call and settled in USDs on Arbitrum or USDC on six other chains, with every sale recorded in a commerce ledger.
Live: ERC-8004 on-chain agent identities and an agent reputation tool, so an agent can check who it's dealing with before it pays.
Planned: reputation that follows an agent across platforms, built from its real on-chain payment and delivery history.
Building: the cookbooks, Custom GPTs, ChatGPT app and browser extension laid out in the co-marketing section above.
Planned: joint social and blog content showing what agentic finance looks like in practice.
Planned: more ways to use SperaxOS tools from OpenAI's platform, and more OpenAI-native capabilities inside the workspace.
Rolling out the designed SPA loops from the flywheel section, transparently and verifiably on-chain, so growth in agent activity is visible in the token's economics, not just Sperax dashboards.
Put it all together and the ambition is clear. Sperax wants SperaxOS to be the number one DeFi copilot, and Sperax to be the DeFi project people trust first when they let software handle their money.
Not the flashiest. The most trusted. The one with the most tools, the safest guardrails, the best yield on idle dollars and the simplest experience, for people and for agents. Sperax has been earning that trust on-chain since 2019. This partnership, and everything on this roadmap, is how it earns that trust at a much bigger scale.
None of this changes the rule Sperax started with. Every new capability, every partner tool and every RWA position goes through the guard chain before it touches money. Growth that skips safety isn't growth.
Follow @SperaxUSD for updates. Each item on this list will ship with its own announcement.
Product
SperaxOS: chat.sperax.io
OpenAI integrations: chat.sperax.io/openai
MCP console: chat.sperax.io/mcp
Guard chain inspector: chat.sperax.io/guard-chain
x402 in SperaxOS: chat.sperax.io/x402
Agent bank accounts: chat.sperax.io/bank
SPA: chat.sperax.io/spa
Developers: chat.sperax.io/developers
Strategy marketplace: chat.sperax.io/strategy-marketplace
ERC-8004 agent identities: chat.sperax.io/erc8004
Developers
MCP catalog (JSON): chat.sperax.io/webapi/mcp
Data API OpenAPI: chat.sperax.io/api/v1/openapi
Custom GPT OpenAPI: chat.sperax.io/api/v1/gpt/openapi
Capabilities, OpenAI view: chat.sperax.io/capabilities.json?format=openai
Platform OpenAPI: chat.sperax.io/openapi.json
x402 discovery: chat.sperax.io/.well-known/x402
Agent directory: chat.sperax.io/api/a2a/directory
Official MCP registry: registry.modelcontextprotocol.io
Glama: glama.ai
npm: @sperax/mcp-*
On-chain
x402 facilitator: x402.sperax.io
Facilitator source: github.com/Sperax/USDs-x402-facilitator
Upstream x402 PR: x402-foundation/x402#3513
SPABuyback contract: Arbiscan
First USDs x402 payment: Arbiscan
Community
Docs: docs.sperax.io
Discord: discord.gg/sperax
X: @SperaxUSD and @SperaxDAO
three.ws: three.ws
Sperax protocol docs
SperaxOS: docs.sperax.io/speraxos
USDs: docs.sperax.io/master
Auto Yield: docs.sperax.io/master/auto-yield
Stability mechanism: docs.sperax.io/master/stability-mechanism
Sperax Farms: docs.sperax.io/sperax-farms-protocol
Staking (veSPA): docs.sperax.io/staking-protocol
Governance: docs.sperax.io/governance
SPA tokenomics: docs.sperax.io/faq/spa-tokenomics
Buyback contract: docs.sperax.io/buyback-contract
Contract addresses: docs.sperax.io/faq/smart-contract-addresses
Bug bounty: docs.sperax.io/bug-bounty-program
Industry
Agentic Commerce Protocol: Stripe newsroom
x402 Foundation: Coinbase developer docs
x402 spec: x402.org
Ecosystem
USDs and SPA: sperax.io
OpenAI partners: openai.com/business/partners
Three ways to start, today:
Use it. Open chat.sperax.io, ask your agent something hard, and watch it show its work before it touches a single token.
Build on it. Plug the Sperax MCP servers into ChatGPT, Claude or your editor, or sell your API to agents over x402.
Partner with Sperax. If you run a protocol, a data service or an AI product, reach out on Discord or X. Every tool Sperax adds reaches every SperaxOS user on day one.
The agent economy is coming. It needs a brain, a workspace and a dollar. Sperax is building two of the three, and is proud to build them alongside OpenAI.
Since 2019, Sperax has earned trust one block at a time. Now it is bringing that trust to the agents. Follow @SperaxUSD and watch each piece of this roadmap ship.
Nothing in this article is financial advice. SPA and USDs are digital assets and carry risk, including smart-contract risk and loss of value. USDs yield varies and is not guaranteed. Do your own research.
