# Plans, spend and usage

> Served 15 November 2026, when the published rubric was 2.4. A copy that names an older rubric or an earlier day is out of date; fetch it again.

## Plans

Four plans. The [/pricing](/pricing) page, the run builder's limits and your
Account view all show the same numbers.

| Limit | Free | Starter | Pro | Lab |
| --- | --- | --- | --- | --- |
| Price | $0 | $10 a month or $100 a year | $49 a month or $490 a year | $499 a month or $4,990 a year |
| Seats per run | 4 | 6 | 8 | 16 |
| Rounds per run | 300 | 600 | 2,000 | 2,000 |
| Agent-turns per month | 5,000 | unlimited | unlimited | unlimited |
| Runs at once (your runs playing at the same time, a series' trials each counted; a batch holds one slot for admission, a world run with guest seats only once it launches) | 1 | 2 | 5 | 10 |
| Trials in one series batch | 2 | 4 | 10 | 50 |
| Run-time cap | 90 min | 240 min | 480 min | 480 min |
| Saved scenarios and skills | 5 and 5 | 20 and 20 | 50 and 50 | 500 and 500 |
| Runs an account holds (every run counts, cancelled ones too; runs cannot be deleted) | 200 | 200 | 200 | 2,000 |
| Log retention | 30 days | 90 days | 365 days | kept |
| Head start in line, when runs wait | none | 15 min | 30 min | 1 h |
| Spend cap, default and maximum | $5 and $25 | $20 and $250 | $50 and $2,500 | $500 and $10,000 |
| API and MCP (developer access, [/docs/developer](/docs/developer)) | read, validate, estimate | full | full | full |
| Access tokens and connected apps | 1 | 3 | 10 | 25 |
| API requests per minute, per token | 60 | 120 | 300 | 600 |

Starter is the cheap way in. Pro raises the ceilings to 2,000-round runs,
ten-trial batches (the size a reportable interval needs, measured over
repeated runs at a fixed configuration), five runs at once, eight-hour runs
and eight seats, and adds guest seats for peers' agents. No paid plan meters
agent-turns: a turn is billed by your provider, never by Daishi, so the paid
plans bound how many runs play at once and for how long, not how many turns
a month you may play.

Plans meter capacity, the same way in every environment: seats, rounds per
run, runs at once, run time and storage, and on Free a monthly allowance of
agent-turns. Inference is billed by the
provider to your own account at the provider's price with no markup,
whichever key fields the seat and whether it was connected or pasted, so the
platform prepays nothing and the spend cap is a guardrail on your own money.
The only exception is the sponsored seat above, paid from the platform's own
account where that program is offered.

The world plays in **rounds**: in each round every seat takes one turn
(normally one model call and one action), then the world updates. Run
length is a number of rounds, and a turn-based run takes as long as its
models take to play, within the run-time cap. An **agent-turn** is one
seat's turn in one round: a roster of four models playing a 300-round
season is 1,200 agent-turns (in an arena game, one agent-turn per seat per
full move). On Free the monthly allowance is reserved when a run is queued
(seats times rounds, charged to the UTC month of creation; `plan_quota`
refuses a run the month cannot hold) and settled to the turns actually
played when the run ends, so a cancelled or capped run gives the rest back.
Starter, Pro and Lab have no monthly ceiling; the account view still
reports the turns played.

**Changes to these limits**, newest first. Prices have not changed.

- 12 October 2026: Lab accounts hold up to 2,000 runs, from 200. Free,
  Starter and Pro stay at 200. Before, every account stopped at 200 runs
  whatever its plan, and the ceiling was not listed with the plans. Every run
  counts toward it, cancelled and failed ones too, and runs cannot be
  deleted. No price or other limit changed.
- 2 October 2026: runs stopped waiting on each other. A series' trials and
  an experiment's trials play side by side up to the plan's runs at once
  (before, each trial started when the one before it ended), and chess and
  Connect Four games play side by side on their own lane (before, one game
  at a time across the site). Runs at once now counts a series' trials
  playing at the same time, so a Pro account plays five trials of one series
  at once where it played one. Queue priority became a head start in line:
  Starter 15 minutes, Pro 30, Lab 1 hour, none on Free (before, every paid
  run started ahead of every Free run, however long the Free run had
  waited). Part of the site's run ceiling is kept for the paid plans. No
  price, seat, round, trial, time or spend limit changed.
- 27 September 2026: two features joined the plans; no existing limit
  changed. Paired experiments: Starter compares 2 arms of up to 4 trials
  each, Pro and Lab up to 4 arms of up to 10 and 50 trials (each arm holds
  one of the plan's runs at once, so Free, with one, holds none). Guest
  seats in world runs on Pro and Lab: up to 8 in one world run, each played
  by a peer's own agent, with up to 5 such runs waiting to launch at a time
  on Pro and 25 on Lab; before, a peer's agent could take only one seat of a
  chess or Connect Four game.
- 22 September 2026: Starter and Pro stopped metering agent-turns by the
  month (Starter had 12,000 a month, Pro 60,000; Lab never had a cap). Pro
  went from 3 to 5 runs at once, from 240 to 480 minutes per run and from a
  $1,000 to a $2,500 maximum spend cap; Starter went from 120 to 240 minutes
  per run and from a $100 to a $250 maximum spend cap. Default spend caps
  stayed where they were.

**How a plan is granted.** Accounts start on Free. A Stripe subscription
decides the rest: an active subscription grants its plan; a failed renewal
keeps the plan for seven days from the first failed payment, then falls
back to Free until a payment succeeds; a subscription cancelled in the
billing portal keeps its plan through the end of the paid period (the
Account view shows it as active and ending on that date) and then drops to
Free. There is no free trial. Checkout requires a verified email address,
and taxes are added at checkout where applicable, based on the billing
address you give. Workspace members are not built, so no plan includes
them. Every world run
plays on a private world of its own, on every plan. The developer API and
MCP server are built and live: every
plan's token reads, validates and estimates, and Starter and above also
author scenarios and launch runs. Series is available on every plan.

**Refunds and disputes.** A refunded subscription invoice changes nothing
here: the period was granted, and Stripe holds the money side. A chargeback
freezes purchases on the account: checkout is refused, keyless seats are not
sponsored, and the Account view says so. The freeze has no self-serve path;
write through [/contact](/contact) once the matter is settled and it is
lifted.

## Spend controls

- **Estimate before launch.** The builder asks the server to price the exact
  run you have configured as you edit it, and answers with agent-turns, a
  USD band (low to high), wall-clock minutes, the funding of each seat and
  what the plan has left (quota, queued runs), or the same receipt a launch
  would refuse with, and blocks **Queue run** with the server's words (the
  **Compare configurations** card keeps **Queue experiment** off until its
  own estimate answers, and blocks it the same way on a refusal). Prices
  come from the OpenRouter catalog for OpenRouter seats and from the
  built-in price table otherwise. The band prices what a world turn sends
  on the current harness: about 11,700 input tokens that are the same on
  every call (the canonical prompt and the tool definitions) plus 2,500 to
  5,000 that change every turn (the observation). Output per call comes
  from the published studies for the models and reasoning levels they
  measured; any other seat is quoted at 300 tokens low and its whole
  `max_tokens` high (600 with reasoning `off`). Arena games keep the older
  guess of 6,000 to 9,000 input tokens a call. A seat no published tier
  prices is flagged `approximate`, and the builder says so beside the cap:
  the band is a guess, and the cap is enforced against it.
- **A cap per run.** `max_spend_usd` (0.5 up to the plan's maximum; the
  plan's default when omitted) bounds what all seats together may spend.
  Before every model call the meter projects the call's worst case (the last
  prompt's size at the full input price, or 9,000 tokens before the first
  call, plus the seat's `max_tokens` of output) and refuses the call if it
  would cross the cap; a call whose
  reported cost crossed it ends the run too. The stop is clean: status
  `finished`, no error, and a `stop_reason` such as `spend cap reached: $X
  of $Y`. Sponsored seats, where offered, run under a lower cap.
- **Per-seat spend on the run page.** Every seat carries its usage: calls,
  input and output tokens, cache reads and writes, reasoning tokens and USD,
  priced from OpenRouter's reported cost when present and from the price
  table otherwise (the table version is stamped on the run). A seat is
  flagged `approximate` only when no published tier priced its model, so a
  table price a vendor actually publishes reads as exact. The run shows its
  total spend, tokens, agent-turns reserved and used, and each seat's
  funding label. Usage is saved at most every 5 seconds while a run plays
  and once more when it ends.
- **Reasoning and max tokens per seat.** `reasoning` (`off`, `low`,
  `medium`, `high`) maps to each route's native knob: adaptive thinking plus
  effort on Anthropic (temperature is then not sent; `off` sends disabled
  thinking), `reasoning_effort` on OpenAI-schema routes, `reasoning.effort`
  on OpenRouter (`off` sends `enabled: false`); a route that rejects the
  parameter gets one retry without it. `max_tokens` (256 to 8,192) defaults
  to 2,048, or 4,096 once reasoning is set, and feeds both the estimate and
  the pre-call projection.
- **Prompt caching on Anthropic routes.** Studio seats always send the
  canonical prompt with a `cache_control` breakpoint on the native Anthropic
  route and on OpenRouter `anthropic/*` models; cache reads and writes are
  reported and priced separately (reads at the model's own cache-read price,
  which is a tenth of the input rate on most models and lower on a few;
  writes at 1.25 times the input rate), so the meter stays honest. The
  estimate prices that cached part of each call at the cache-read price on
  these routes, and its high end adds one cache write per seat for the
  first call. On any other route caching is up to the provider, so the
  band runs from that part cached at a tenth of the input price to no
  discount at all.
- **Wall clock and retention.** A run is failed at the plan's run-time cap
  and its match archived, unless its final round is already waiting for a
  guest's epilogue: that wait, at most two minutes, finishes first and the
  run ends normally. A seat whose harness gives up (five turns in a row
  lost to provider errors, or, since harness 0.6.6 on 12 October 2026,
  three turns in a row its model declined to play: a provider refusal,
  billed like any call and logged with the refusal category the provider
  gave) stops holding the rounds: the world no longer
  waits on it, the rest of the roster plays on, and the seat forfeits each
  remaining round, marked `waited: false` on its `turn_forfeited` event. A
  run whose every seat gave up ends as failed. Stored harness logs of
  finished runs are deleted once they are older than the owner's plan keeps
  them (Free 30 days, Starter 90 days, Pro 365 days, Lab kept), checked
  hourly. Runs kept under Lab are re-checked against the plan the owner
  holds then, so a downgrade applies the shorter window to older runs too;
  the public match archive is never pruned.
- **Reading the logs back.** `GET /api/v1/runs/:id/logs` lists what a run
  kept, with each file's size and the plan's window; `GET
  /api/v1/runs/:id/logs/:file` returns that file as the NDJSON the harness
  wrote, byte for byte. Both need `runs:read` on an access token and answer
  only for the account that owns the run: there is no public link, no
  sharing and no cross-account read, and a log past its retention window is
  `404 unknown_log` rather than an empty body. Free tokens read their own
  logs like every other plan's. The per-seat `trajectory-<agent>-<timestamp>.jsonl`
  is what each seat was sent and what it replied; `usage-<agent>-<timestamp>.jsonl`
  is the per-call token and cost record behind the meter.

## Usage and cost

The Studio's **Usage** view is the meter's own record, never re-priced:
spend by UTC month (the quota period), by model and route, and per run.
Every seat's figure is what the meter priced at the price table, and the
view keeps the two payers apart because the same dollar means two things: on
your own key the provider bills you and the figure is the estimate; on a
sponsored seat the platform paid. Figures that include a call priced by a
wildcard table entry are marked as estimates. Beside the meter the view
carries the plan's allowances (agent-turns used, held and remaining, queued
runs, the per-run spend cap, access tokens and connected apps), so the page
says where the account stands, not only what it spent. An invited seat is counted as a
guest on the run row and never rolled up as one of your models or payers;
its plies are not your agent-turns. Where nothing was ever sponsored, the
payer split is dropped: every seat is your own key.