Verified-value settlement
Tie payment to a live SLA — latency percentiles, error rate, availability. When the service drops below the agreed bar, the stream throttles or halts on its own. SLA-failed units are never paid for.
Dynamo settles payments across a network of AI agents
One budget.
One budget.
Many agents.
Paid by the second.
Set one budget, split it into capped allowances, meter each one by the second. The ceiling is the funded amount itself, so a runaway agent can't overspend — a request past the cap is refused before it is ever billed. Start free in Control Mode: full enforcement, no money anywhere. Card and stablecoin rails run the same objects. x402-compatible.
Free Control Mode · card & stablecoin rails · x402-compatible · your payloads never leave your machine
Agents spend fast and don't self-correct.
Dashboards report what a runaway loop cost you — after it cost you. And the rails that do move machine money move it 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, and refused at the money layer the instant a cap is reached.
Two minutes, on your own machine
A hard cap in front of any AI tool
The guard puts a capped base URL in front of any OpenAI-compatible endpoint — Cursor, Claude Code, your own agents, anything that takes a custom endpoint. It runs on your machine: your prompts and payloads never leave it, and your instance sees metering facts only — stream ids, unit counts, amounts. When the cap is spent the answer is HTTP 402, and nothing reaches your provider.
Every user gets their own dedicated instance, provisioned by hand while we are early. Request one and we send your URL, tokens, and a quickstart.
# a capped endpoint in front of any OpenAI-compatible tool npm install @dynamoprotocol/guard @dynamoprotocol/sdk npx @dynamoprotocol/guard up # python gateways pip install litellm-dynamo
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. Dynamo settles payments across a network of AI agents.
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 network 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. Every control below settles on objective, verifiable facts — latency, error rates, availability, unit counts — never on anyone's opinion of the output.
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.
Three ways to fund, one rulebook
The same objects, whatever backs them
Budgets, allowances, caps, halts, revocation, and signed vouchers behave identically across every funding mode. Moving from a free trial to real money is a one-line change — not a migration, not a different product.
Control Mode — free, no money
The complete enforcement engine over internal records: hard caps, rate envelopes, anomaly halts, instant revocation, signed vouchers, a reconciled session. No payment setup of any kind. This is what every instance runs today.
Card — an authorization-backed budget
A processor-guaranteed authorization is the ceiling; work is captured as it is delivered, and nothing beyond the cap can ever be captured. Money stays inside a licensed, audited payment institution — Dynamo never holds funds and never sees card numbers.
Stablecoin — self-custodied escrow
The contract is the ceiling: caps, splits, and SLA conditions are executed on-chain, with no processor in the middle and no admin keys over anyone's funds. Flat, near-zero settlement fees make sub-cent metering profitable instead of a loss.
Non-custodial on every rail: Dynamo never takes possession of funds, never operates stored-value balances, and never converts between fiat and crypto. Card and stablecoin rails are enabled per instance, after external security review — never by default.
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.
SDK reference// one budget, fanned out across agents, capped by the protocol const budget = await dynamo.openBudget({ funding: "none", // Control Mode — enforcement, no money cap: { perDay: 50 } }); const infer = await budget.stream({ to: "agent.inference.svc", rate: 0.002, // per second cap: 20, sla: { p95ms: 800 } // objective threshold }); // revoke one child — its whole subtree stops with it 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 tied to objective delivery facts, a feed that buffers or drops frames bills less. Metering 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-chainStablecoins, plus any allowlisted asset priced by trusted feeds.
- Offline-verifiable evidenceEvery session exports as a signed bundle anyone can check.
- x402-compatibleSettles through the emerging agent-payment standard.
- No token requiredStart free in Control Mode; no wallet, no card, no chain.
- Gateway pluginsLiteLLM, Kong, APISIX, MCP — enforcement where your traffic already flows.
- 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 payments across a network of agents — one budget split across many, 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.
Do I need crypto to use this?
+No. Every instance runs Control Mode today: the complete enforcement engine — caps, rate envelopes, anomaly halts, revocation, signed vouchers — with no money anywhere and no payment setup of any kind. Card and stablecoin rails are enabled per instance when you need them. The objects are identical across all three, so moving to a money rail is a one-line change rather than a migration.
What if a service underdelivers after it's been paid?
+Settlement is tied to objective facts — latency percentiles, error rates, availability, unit counts — signed and attested, never a subjective judgement of output quality. SLA-failed units are never paid for, degraded streams refund to the attested break-point with the buyer made whole first, and a declared holdback window separates captured from final. Recourse is built into the rail rather than promised in a policy.
Does anything I send reach Dynamo?
+No. The guard and the SDK run on your machine and verify credentials offline; what crosses the wire to your instance is metering facts only — stream ids, unit counts, amounts, signatures. Prompts, completions, and payloads never leave your environment. Real money, when you enable a money rail, moves only inside a licensed payment institution or a self-custodied on-chain escrow — never through Dynamo.
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.