DYNAMO — THE AI AGENT FINANCE AND ECONOMIC LAYER
The finance and economic layer for the AI agent economy. Meter any work by the second, settle per signed voucher, and get paid as it delivers. Sub-cent prices, no chargebacks, no billing code.
x402-compatible · non-custodial on every rail · your payloads never leave your machine
A simulated week: a builder monetizing an MCP tool — metered per call, settled per voucher, paid as work delivers.
WHO THIS IS FOR
FOR AI SERVICE DEVELOPERS
Meter anything you ship. Get paid as the work delivers — sub-cent prices, no invoices, no chargebacks, 1% to the rail.
Money moves to you inside each settle — call by call. No invoice, no payout schedule. Signed, final, yours.
≈1.32% all-in on a $0.50 job, vs 62.9% by card. Micro-pricing becomes a product, not an impossibility. 1% to the rail — not a marketplace's 20–25%.
x402 challenges, signed vouchers, scoped agent credentials, budgets that fan out across services. Payment logic on the token level — not a checkout page.
SHOWCASE — BUILT ON DYNAMO
The first businesses built on Dynamo — paid per delivered unit, every job capped at what the user paid. Both code-complete, running the escrow rail on testnet.
Type a few keywords. An LLM pipeline designs, builds, and actually plays the game in a headless browser to verify every promised mechanic — with a capped repair loop fixing what fails.
Type up to ten keywords, pay in stablecoins, get a series of ~30-second episodes. A series bible keeps characters and tone consistent; each shot is rendered, then metered — failed shots cost nothing.
Both run the escrow rail on Base Sepolia testnet today — real contracts, testnet stablecoins. Mainnet rails activate per instance after external security review. Source: codebase-reviewed developer descriptions of both applications.
GET PAID
Your own dedicated instance, provisioned by hand while we're early. You run only the open client; payloads stay on your machines.
One form. A person stands up your isolated instance — own process, database, keys — verified before you get the URL and tokens. takes a minute · instance within about a day
monetize() on an MCP tool, a plugin on LiteLLM/Kong/APISIX, or the SDK in front of any API. Meter by the second, the call, or any unit. one command, or a few lines
Per-voucher settlement to your account, a signed receipt per unit, only 1% between you and your earnings. Card-funded buyers arrive when the card rail opens. the proof is the demo
Capping your own agents' spend instead? Same instance, one command: npx @dynamoprotocol/guard up — a hard spending cap in front of any OpenAI-compatible tool.
FUNDING MODES
Budgets, caps, revocation, and signed vouchers behave identically across every funding mode. Moving to real money is a one-line change.
The complete protocol with no payment setup — develop, test, and prove your integration against the exact machinery the money rails run. Free permanently.
A card authorization backs the buyer's budget; you're paid by split transfer as work delivers. Money stays inside a licensed payment institution — Dynamo never holds funds, never sees card numbers.
Self-custodied contract escrow: sub-cent metering, 1% on the token rail, no chargebacks. Live on Base Sepolia testnet today; mainnet after external review.
Non-custodial on every rail: never holds funds, never runs stored-value balances, never converts fiat↔crypto. Money rails enable per instance, after external review — never by default.
FOR AI SERVICE USERS
You run the agents; Dynamo keeps them inside the budget you set — structurally, not by alerts. A request past the cap is refused before it's billed.
Set the number; your agents spend at most that number. Past it: 402 — the request never reaches the provider. A recreated $47,000 runaway stopped at $63.
Each agent, project, and CI job gets its own allowance and kill switch. One session answers "who spent what."
Agents never hold your master key. Each holds a scoped, capped credential — a leaked key loses at most its allowance.
Every unit is cryptographically signed. The session exports as an evidence bundle — verifiable offline, trusting no one.
One command puts a cap in front of Cursor, Claude Code, or any OpenAI-compatible tool: npx @dynamoprotocol/guard up.
MULTI-AGENT BUDGETS
Per-call rails assume one payer and one payee. Real workflows fan out. Dynamo settles that whole shape — one budget, many streams, capped together. Builders: one customer budget pays your whole supply chain. Users: one budget governs the whole fleet.
Split once, enforce everywhere — per child, per branch, and across the whole network at once.
delivery-gated — degraded units are never paid for.
Revocable mid-task, without touching the rest.
Past the cap: HTTP 402. Nothing reaches upstream.
Carve a parent budget into per-agent allowances. Caps hold per child, per branch, and network-wide under concurrency.
Dozens of parallel streams reconcile into one auditable record — who consumed what, when, to the second.
Cut any child stream instantly; the rest keep working.
STREAMING SETTLEMENT
Builders get paid for exactly what they deliver; users pay only for what was delivered. A metered stream reacts to reality second by second — every control settles on objective, verifiable facts, never anyone's opinion.
Payment tied to verified delivery. Below the agreed bar, the stream throttles or stops on its own — units that miss it are never paid for.
If a stream degrades halfway through, refund the seconds after it broke — not the whole thing, not nothing. Buyer made whole first, from held funds.
A cap stops the total. Rate detection stops the runaway — before the ceiling is even reached.
If a long-running stream drops, billing stops at the last settled second with a provable stop-point. Nothing stranded, nothing double-charged.
USE CASES
Start with the agent economy — the buyer building today. The same streaming engine reaches much further.
GPU time and token-by-token inference with a hard ceiling and a delivery gate per job.
An agent on a live market or sensor feed pays while subscribed — and stops the instant it unsubscribes.
One agent hires several others for a long task and streams payment against scoped, capped, revocable allowances.
APIs, data, and compute by the second instead of a monthly tier nobody fully uses.
Watch 90 seconds, pay for 90 seconds. A feed that buffers bills less — settlement ties to objective delivery facts.
Pay-as-you-play, instant purchases, and payouts the other way — one pot split across players, creators, and platform.
Live audio, music, tipping, bandwidth, energy — anywhere value should flow only while it's being delivered.
PROOF, NOT PROMISES
Client, plugins, and conformance kit are Apache-2.0 and public; the open/closed boundary is machine-verified on the exact published bytes.
A public 12-check suite verifies any implementation — including ours — and emits a signed report. npx @dynamoprotocol/conformance-kit
Every code sample runs in CI against a live core. What you read is what runs.
A recreated $47,000 runaway loop stopped at $63 · an evidence bundle verified offline through 71 checks, with no network · 20+ property suites at 10,000 randomized runs each · decision parity across four plugins in three languages.
FAQ
They move money one payer to one payee. Dynamo settles a whole network under one budget — metered, capped, reconciled into one session — and stays x402-compatible, adding the layer rather than replacing the standard.
No. Every instance runs Control Mode today — the complete engine, no money, no payment setup. Card and stablecoin rails are enabled per instance when you need them; the objects are identical, so the switch is a one-line change.
Settlement ties to signed objective facts — never a judgement of output quality. Units that miss the agreed bar are never paid for; degraded streams refund to the attested break-point, buyer made whole first. Recourse is built into the rail, not promised in a policy.
No. The guard and SDK run on your machine; what crosses the wire is metering facts only — ids, counts, amounts, signatures. Payloads never leave your environment. Real money moves only inside a licensed payment institution or self-custodied escrow — never through Dynamo.
Agents are the first buyer, not the limit. The same engine powers pay-per-second video, pay-as-you-play gaming with payouts, live audio, and metered human-facing APIs.
The finance and economic layer for the agent economy — built for the builders of it.