Quality-gated settlement
Tie payment to a live SLA — latency, uptime, token quality. When the service drops below the bar, the stream throttles or halts on its own. You pay for performance, not promises.
On-chain streaming payments
One budget.
One budget.
Many agents.
Paid by the second.
Dynamo streams token payments in real time across a whole fleet of agents. Set one budget, split it into capped allowances, stream each one by the second, and settle on-chain — instantly, across borders, for a fraction of card fees. The rules live in the contract, so a runaway agent can't overspend. x402-compatible.
Stablecoin-native · x402-compatible · settles in seconds, anywhere
Agents spend fast and don't self-correct.
The rails for machine payments exist — over 100M agentic transactions have settled on-chain in under a year. But they move money one payer to one payee, one call at a time. Real workflows fan out: an orchestrator hires a dozen services at once. Dynamo is built for that shape — one budget, many streams, all metered and capped together.
The thing nothing else does
Budgets that fan out across agents
Per-call rails, session rails, and escrow tools all reason about a single payer and a single payee. A real agent workflow is a tree. Dynamo settles the tree.
Split once, enforce everywhere
Carve a parent budget into per-agent allowances. Caps hold at every node — per child, per branch, and across the whole tree at once.
Aggregate back into one session
Dozens of parallel streams reconcile into a single auditable record: what each agent consumed, when, and what it cost — to the second.
Revoke mid-task
Cut any child stream instantly without touching the rest. The orchestrator stays in control of the whole fleet while work is still running.
Streaming changes what controls can mean
Pay for what's delivered — not what was promised
Discrete payments are all-or-nothing. A metered stream can react to reality second by second. That opens controls a per-call rail can't express.
Partial-delivery refunds
If a stream degrades halfway through, refund the seconds after it broke — not the whole thing, not nothing. Refunds shaped like the stream that earned them.
Rate anomaly halt
A spend cap stops the total. Rate detection stops the runaway — halt the moment an agent burns faster than its authorized envelope, before the ceiling is even reached.
Mid-stream integrity
If a long-running stream drops, billing stops at the last settled second with a provable stop-point. Nothing stranded, nothing double-charged.
Why token payments, not cards
The rules live in the contract
Every control above is enforced on-chain — by the contract, not by a dashboard you have to trust. That foundation also unlocks economics card rails can't reach.
Enforced, not promised
Caps, budget splits, and SLA conditions are executed by the contract itself. Trustless and verifiable — no processor in the middle who can fail, freeze, or reverse it.
Built for micropayments
On fast, low-fee chains, settlement is a flat near-zero fee — no 2.9% + 30¢, no chargeback overhead. Sub-cent, per-second billing is finally profitable instead of a loss.
Seconds, and borderless
Settles in seconds on-chain, with no multi-day hold and no chargeback window — and it works the same between any two parties, in any country, with no acquirers or FX hops.
Instant finality is also what makes streaming possible at all — you can't pay by the second on rails that settle in days.
Built for the standard, not against it
x402-compatible by design
x402 is becoming the common language for agent payments, backed by an open foundation and the largest names in payments. Its exact scheme handles discrete per-call billing well. Continuous, high-frequency consumption is where one transaction per request stops making sense — and that's exactly what Dynamo streams. Settle through x402-compatible flows and keep per-second billing. You don't choose between the standard and streaming. You get both.
API reference// one budget, split across agents, capped on-chain const budget = await dynamo.openBudget({ asset: "USDC", cap: { perDay: 50 } }); const infer = await budget.stream({ to: "agent.inference.svc", rate: 0.002, // per second cap: 20, sla: { p95ms: 800 } // throttle if slow }); // revoke one child without touching the rest await infer.revoke();
Where per-second beats per-call
Start with the agent economy — the buyer building today. The same streaming engine reaches much further.
Compute & inference
Bill GPU time and token-by-token inference for the seconds consumed, with a hard ceiling and an SLA gate per job.
Real-time data feeds
An agent on a live market or sensor feed pays while subscribed and stops the instant it unsubscribes.
Agent-to-agent work
One agent hires several others for a long task and streams payment against scoped, capped, revocable allowances.
Metered APIs & compute
Human developers rent APIs, data, and compute by the second instead of committing to a monthly tier.
The same engine, beyond agents
Video
Gaming
It's not only machines that should pay by the second
Pay per second watched
Watch 90 seconds, pay for 90 seconds. Close the tab and the stream stops — no subscription, no cancel-before-you're-billed. And because settlement is quality-gated, a feed that buffers or drops resolution bills less. Streaming that reacts to what was actually delivered.
Play, and get paid, by the second
Pay-as-you-play for server, map, or session access, with instant in-game micro-purchases. Just as important, payouts flow the other way — splitting one pot across players, creators, and the platform with the same budget engine that fans out across agents.
…and live audio, music, tipping, and any service where value should flow only while it's being delivered.
Everything else you'd expect, included
The headline features stand on a complete base — so Dynamo is the whole payment layer, not a piece you bolt onto three others.
- Spend capsPer-stream, session, and day, with automatic halt-on-limit.
- Clean shutoffBilling stops at the last settled second.
- Stream aggregationCombine many streams into one logical session.
- Batch streamsOpen and close a fleet of streams in one transaction.
- Instant start/stopGrant or revoke access mid-task, on the spot.
- Programmable conditionsStreams that adjust to usage and performance.
- SubscriptionsRecurring streams when a flat plan fits better.
- Multi-token & multi-chainStream stablecoins on the networks you already use.
- Auditable trailEvery stream reconciles to a verifiable record.
- x402-compatibleSettles through the emerging agent-payment standard.
- No token requiredStart with stablecoins; the Dynamo chain is optional.
- Open SDKDrop into your stack with a few lines of code.
FAQ
What makes this different from x402 or session-based rails?
+They move money one payer to one payee. Dynamo settles a whole tree — one budget split across many agents, metered and capped together, reconciled into one session. It stays x402-compatible, so it adds the multi-agent and streaming layer rather than replacing the standard.
Why token payments instead of credit cards?
+Three reasons: the rules are enforced on-chain by the contract rather than promised by a processor; settlement is a flat near-zero fee on fast chains, so per-second micropayments are profitable; and it settles in seconds across borders with no multi-day hold or chargeback window. Cards can't do per-second streaming at all.
If payments are irreversible, what if an agent pays for bad output?
+That's what quality-gated settlement and partial-delivery refunds are for. Payment is tied to a live SLA and throttles or halts when the service underdelivers, and you can refund the degraded portion of a stream — so irreversibility protects the provider without exposing the payer.
Do I need the Dynamo token or chain?
+No. The SDK settles in stablecoins on networks you already use. The Dynamo chain is optional, not a prerequisite for streaming payments.
Does this only work for AI agents?
+Agents are the first buyer, but the engine is general. The same per-second streaming and budget-splitting powers pay-per-second video, pay-as-you-play gaming with player payouts, live audio, and metered human-facing APIs.