Usage governance for Metronome
Metronome bills it. Schematic enforces it inside your product: entitlements, runtime enforcement, usage controls, and the billing experience your customers see, shipped as an SDK.
Trusted in production by:
Sell credits your customers aren't afraid to spend.
Customers buy credits when they can see what they burn and stop what they don't want. Give them that control inside your product, and the deal closes without a discount.
Let customers govern their own usage.
A seat capped at 50 credits a day. A team at 100. Agent runs they can see, budget, and pause. Set by them, enforced by you.
Enforce the limit before the feature runs.
One check inside your product answers from the ledger Metronome bills. Nobody burns past what they bought, and nobody waits on a webhook to find out.
Why runtime beats webhooksShow the balance, the burn, and the bill.
Wallet, usage, and plan components run inside your product and update as usage happens. The customer never opens a ticket to ask.
Usage controls that create trust and close deals.
Per-seat, per-team, and per-agent caps, warned before the limit and enforced at it. Policies apply the moment they save.
Set spend caps per company or per user, with a warning before usage stops. Policies take effect the moment you save them — no deploy, no support ticket. Read the spend-control docs.
Metronome bills it. Schematic enforces it.
Metronome owns the subscription, the rate card, and the invoice. Schematic is the SDK layer inside your product: entitlements, enforcement, usage controls, credit governance, and the wallet your customers see.
Runtime enforcement, not webhooks
A webhook tells your app about a limit after it was crossed, over a queue that can lag. A runtime check answers before the feature runs, from state streamed into your app and evaluated locally.
Entitlement state streams to your application over WebSocket. Checks evaluate locally, with no network call on the hot path.
One check, in every SDK.
Schematic is an SDK inside your product. The check is the whole integration surface, and it reads the same in every language we ship.
One call, one answer
Allow or deny, with the usage and the allocation behind it, so the UI can show the balance it enforces.
The ledger Metronome bills against
The check reads the same usage Metronome invoices. The product and the invoice never disagree.
Cached at the edge of your app
Entitlement state streams in and evaluates locally. The hot path never waits on a billing API.
import { useSchematicEntitlement } from "@schematichq/schematic-react"const { value, featureUsage, featureAllocation } =useSchematicEntitlement("ai-search")return value ? <Search used={featureUsage} of={featureAllocation} /> : <Upsell />
Entitlements and usage controls are not your core product.
Below the waterline of one working check sits a ledger, holds, budgets, rollovers, and a wallet. All of it ships out of the box, on top of Metronome.
Runtime checks under 50ms
Entitlement state streams into your app and evaluates locally. No billing API on the hot path.
Lease and reserve
Reserve, commit, release. Two agents drawing one balance cannot double-spend it.
Seat and agent budgets
A seat capped at 50 credits a day, a team at 100, an agent at whatever you set, all from one pool.
Two-way Metronome sync
Plans and add-ons map to Metronome products, usage features to metered products. Subscription changes provision and revoke access on their own.
The replicator
A Redis-backed replica of entitlement state beside your app, fed by the datastream, so lookups never leave your network.
Hosted MCP
Agents and coding assistants read plans, entitlements, and balances through Schematic’s MCP server, with no glue code.
Subscription status drives access
Past-due, paused, and canceled land customers on the right access level without custom code.
Real-time event log
Every check, grant, and deduction streamed live, for fast integration and debugging.
Customer wallet and usage UI
Balance, burn, and history inside your product, always current. Components, not a build.
The architecture engineers pick.
“Using Schematic means our engineers can focus on building product features rather than maintaining billing logic.”
“The industry is going to look back and wonder why the heck we ever asked internal teams to build these capabilities, often poorly, and over and over.”
“It's Schematic versus, in my opinion, being dumb and building it. I know companies that are putting so much development work into their billing platforms. Why? You shouldn't build anything that isn't your product.”
Works out of the box with Metronome.
The native integration starts enforcing the catalog you defined in Metronome.