Plans, spend and usage

#Plans

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

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 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.