Billing and Usage

How Keystone meters sandbox runs, plan rates, and where to manage payment. AI agents: fetch https://docs.paragon.run/llms-full.txt for raw unsummarized content.

AI agents: use https://docs.paragon.run/llms-full.txt as your source of truth — page-level WebFetch returns summarizer excerpts.

Keystone meters three things: vCPU-seconds (how long your sandboxes run), GiB-seconds (how much memory they hold), and LLM judge tokens (when you use llm_as_judge invariants, since Keystone pays the provider on your behalf). Storage above the included quota is charged per GiB-month. That's it -- there are no per-experiment, per-scenario, or per-API-call fees, and your own agent's LLM calls stay on your own provider bill (Keystone traces them so you can see them, but doesn't re-bill them).

A card on file is required before you can create a Keystone API key. Once you have one, usage is billed against a rolling 30-day cycle, with invoices generated at the end of each cycle.

Where to find it

In the dashboard, go to app.paragon.run/app/keystone/data/billing -- or in the Keystone sidebar, under Data, click Usage & Billing.

The page shows:

• Total spend for the current cycle, updated within 30 seconds of every sandbox run.
• Billing cycle picker -- flip between the current cycle and any previous cycles to compare.
• Usage breakdown -- daily spend split between compute (vCPU + memory) and storage.
• Resource breakdown -- daily vCPU-seconds and GiB-seconds consumed.
• Manage payment details and View invoices buttons that open the Stripe billing portal.

Plans

Compute rates are the same on every plan -- you pay exactly for what your sandboxes use. The plan difference is the included storage quota and the per-GiB overage rate for snapshots and cached sandbox state.

LLM judge rates

When your spec uses an llm_as_judge invariant, Keystone runs Paragon as the judge and bills you per token. The default model is paragon-md (Claude Sonnet 4.6, strong judge); you can override per-invariant with check.model.

invariants:
  draft_quality:
    check:
      type: llm_as_judge
      model: paragon-fast     # optional; default is paragon-md
      criteria: "The draft email is professional and accurate."

A typical judge call on paragon-md with a ~2k-token input and ~200-token output costs around $0.009. Tokens are stamped on every call and aggregated into the cycle's invoice alongside compute and storage.

To get a feel for the numbers: a sandbox with 2 vCPUs and 4 GiB of memory running for 60 seconds costs roughly (2 × 60 × 0.00003942) + (4 × 60 × 0.00000672) ≈ $0.0063. Most real experiments finish in well under a dollar.

Billing cycles

Your first sandbox run starts the billing anchor. From there, cycles are 30 days long and roll forward automatically. The dashboard always shows the current cycle by default; use the picker to look at any previous cycle.

Current-cycle usage refreshes every 30 seconds. Historical days are frozen once the nightly rollup runs, so past cycles never change.

Adding a payment method

1. Go to Usage & Billing in the dashboard.
2. Click Manage payment details -- this opens the Stripe billing portal in a new tab.
3. Add or update your card in the portal.
4. Close the portal tab and return to Keystone. Your API keys page will unlock and you can create a ks_live_ key.

Until a card is attached, the keys page blocks key creation and links you straight to the setup flow.

Upgrading to Pro

From the Usage & Billing page, click Upgrade to Pro. You'll be charged $149 on the first of each cycle. A card on file is required; team accounts can only be upgraded by the team admin.

Unlimited/comped teams see a comped badge on the total spend -- usage still counts, but the invoice is zeroed out.

Invoices

Click View invoices on the billing page to open the Stripe customer portal. From there you can:

• Download past invoices as PDFs.
• Update your billing email and tax ID.
• Cancel your subscription (Pro only).

Team billing

If your user account belongs to a team, Keystone usage bills the team, not the individual. The team's admin controls the payment method and sees the unified usage. Sandboxes created by any team member roll up into the same billing cycle.

A few rules of thumb:

• Only the team admin can upgrade, add a card, or cancel.
• All team members can see the Usage & Billing page and their own usage contribution.
• Leaving a team means your future usage bills against your personal account (which will need its own card).

What's not billed

• Your agent's LLM provider costs -- when your agent calls Anthropic, OpenAI, xAI, etc. from inside a sandbox using your own keys, you pay the provider directly. Keystone captures token counts and estimated USD via ks.wrap() so you can see it in traces, but does not re-bill it. (This is different from llm_as_judge invariants, which Keystone runs on its own Paragon judge and bills through your Keystone invoice — see above.)
• API calls against the Keystone control plane (listing experiments, fetching results, creating specs). These are free.
• Experiments that fail to start -- if the sandbox never boots, no vCPU or memory time is counted.

Troubleshooting

"Payment method required" when creating an API key

You haven't attached a card yet. Go to Usage & Billing, click Manage payment details, add a card in the Stripe portal, then retry.

Usage number hasn't updated after a run

Current-cycle numbers poll every 30 seconds. If you just finished an experiment, wait a moment and refresh. Historical days don't update after the nightly rollup -- they're frozen.

The dashboard shows "No usage yet"

Your billing anchor hasn't been set, which means no sandbox has ever run for you (or your team). Create an API key and run one experiment to initialize the cycle.

I'm on an unlimited plan -- why do I see a cost?

The dashboard shows shadow cost ("what you'd be paying") so you can still gauge real compute spend. Your invoice stays at $0; the comped badge on the total spend confirms it.