Spend and models

What counts as spend, the caps that hold it, which model a run uses, and the model connections that pay for it.

Your keys, your bill

Runs use model connections you add: your own Claude, OpenAI, Grok or OpenRouter credentials. The model provider bills you directly. Zero Human does not resell model usage, and a cheap model is not a budget: caps are.

What counts as spend

Spend is the cost of model calls: every step of a run, and every chat reply. Tool calls are not spend. Each call is priced once, and the same figure is used by every cap, by the run's Cost, by today's total on Spend, and by an execution's total.

Connection What a call costs
OpenRouter API key What OpenRouter reports it billed, plus the provider's own charge when you bring that provider's key to OpenRouter.
Claude Console API key The model's list price for the tokens used, cache reads and writes included.
Claude Pro/Max seat A share of the seat's price: the seat's weekly price, times the share of its weekly limit the calls used, spread across them by what they would have cost on an API key. A seat never costs more than an API key would. Usage past the seat's limit is priced at API rates.
OpenAI API key, xAI API key The model's list price for the tokens used, cached prompt tokens at the cache price. A model with no published price is recorded at no cost, and its cost source says unpriced.
ChatGPT seat A share of the seat's price, worked out as for a Claude seat, from the weekly limit ChatGPT reports with each reply.
SuperGrok seat A share of the seat's price. Grok does not report how much of the plan is used, so each call is charged the most it could have cost: never more than an API key would have, and less the more the seat runs.

The seat's plan comes from the provider where it says (Anthropic, and ChatGPT when you sign in), or you set it on the connection (Seat plan and Monthly price (USD)). A SuperGrok plan is always set by hand. Until a seat has a price, its calls are costed at API list price.

A run's Cost is at the top right of its page. Hover it for the split between API and seat usage and the tokens in, out and cached.

Caps

Settings → Spend holds your caps. A cap sits on one layer: the enterprise, a team, a member, a role, or a task. Amounts are in US dollars.

Limit What it holds
Day $ Money spent today (UTC).
Runs / day Runs started today.
Run $ What one run should cost. See Per-run budgets.
Max model tier The most capable tier a run may use.

A run is held by every cap that applies to it: the enterprise's, and those on its teams (every team its member sits on or leads), its member, its task and its member's roles. The tightest one wins.

Today's spend and today's runs are counted for the whole enterprise. A day cap on a team or a task is compared with everything the enterprise spent today, not only that team's or task's share; the Spend page says so on each row.

Your enterprise has no caps until you add one. A new team or member copies the enterprise's Day $ onto a cap of its own when it is created, with the enterprise cap's Max model tier and no other limit; while the enterprise has no Day $, it gets none. It is a copy, made at creation: later changes to the enterprise cap do not flow into it, and you can change or clear it like any other cap.

A team adopted from the catalog gets the daily cap you choose when you adopt it, and so does a teammate created when you adopt a role. On the Catalog, the clone form's daily spend cap starts at the enterprise's Day $ ($10 while the enterprise has no Day $ or it cannot be read, and never above the form's $10,000 limit), and you can change it before you clone: the cap saved is the one the form shows. With none chosen (over the API), each copies the enterprise's Day $ the same way, or gets $10 a day while the enterprise has no Day $. Whenever the enterprise has a cap, the adopted team's or teammate's cap carries the enterprise cap's Max model tier, whichever Day $ it starts with. The teammates a team adoption creates copy the enterprise's Day $ like any new member.

When a cap is reached

The caps are checked when a run is about to start, before its first model call. If today's spend (with room for the next call) is at a day cap, or today's runs are past a Runs / day cap, the run does not start. It is parked as paused_spend:

  • It keeps its place: its task and its member stay busy, so later starts of that task wait or are skipped.
  • It appears on Blockers under Paused spend, with Raise cap.
  • A run already under way is not stopped by a day cap. It carries on to the end.

Paused runs start again when you raise a Day $ cap to a higher amount (every paused run in the enterprise is queued again and checks the caps afresh) or turn spend limits Off. Changing Runs / day or Run $ does not queue them again, and nothing restarts them at midnight: raise a day cap, turn limits off, or cancel them. Once spend reaches 80% of the tightest day cap, Spend and Enterprise warn you and Spend in the sidebar shows a badge.

Chat replies count toward today's spend too. Before each reply, the day caps on the enterprise and on that member are checked; at a cap the member says so and does not reply. See Chat and plans.

Per-run budgets

A task's Spend USD / run, and Run $ on a cap, set what one run should cost at most; the tighter of the two applies. It is only partly enforced today. On an OpenRouter connection, each model reply is kept short enough for the run to stay within it, and a reply that the limit cuts off fails the run (llm_max_tokens). On a Claude connection it is not enforced during a run.

Turning spend limits off

The switch at the top of Spend turns spend limits On or Off for your enterprise. Off ignores every money cap, every run-count cap, the caps' model tiers and the tasks' per-run budgets, for runs and chat alike, and queues any paused runs again. Spend is still recorded, and a task's own highest tier still applies. With limits off, the rest of the Spend page and the Paused spend section on Blockers are hidden.

Planned

Caps still to come

  • A month cap. Month $ can be saved on a cap today, but nothing holds a run to it yet.
  • Stopping a run mid-way. A run that reaches a cap will stop before its next paid model call, instead of only new runs being held.
  • A per-run cap on every connection. A run that reaches its per-run budget will stop, on a Claude connection as on OpenRouter.
  • An approval threshold. A run that would spend more than an amount you set will wait at a gate for you before its next paid call.

Model tiers

A tier names a class of model, so the OS can choose "a cheap one" or "the best one" without naming it:

Tier For
economical The cheapest model; fine for API and data work.
mid A good mid-priced model.
frontier The most capable, and the most expensive.

Each tier stands for one model on each provider. The cap form shows which model a tier means on your connection.

Which model a run uses

A task's Model field decides:

  • Auto, which every new task starts on, has the OS choose. As the run starts, a small, fast model reads what the run was asked, the task's instructions and its tools, and picks the tier the work needs: economical for simple, well-specified work, mid for everyday work, frontier for the hardest. The run uses that tier's model on your connection, and its page says which tier was chosen.
  • An exact model, picked from your providers' directories, is the model every run asks for. A tier cap does not block it; money caps still apply. When the connection that answers does not offer that model, the run uses the closest model it does offer.

Auto never chooses above the tightest Max model tier that applies to the run: the task's own, and the one on every cap that covers it. With none set, it may choose any tier. Every cap carries a Max model tier, mid unless you choose otherwise, so adding a cap also sets how high Auto may go.

What else to know about Auto:

  • Who chooses. The choice is made on your own connection: by Jev on OpenRouter, by the Decisions API on an OpenAI API key, and by the provider's smallest model on Claude, Grok and a ChatGPT plan. The call is charged to the run. It reads a few thousand tokens and writes almost none.
  • When nothing answers. If the choice cannot be made within a few seconds, the run uses mid, or the highest tier it is allowed when that is lower. Its page says so.
  • When there is nothing to choose. With one tier allowed, or one model behind every allowed tier, nothing is asked.
  • A run that carries on. A run resumed from an earlier attempt stays on the model that attempt used.
  • A task that drives a browser runs on the highest tier it is allowed, with nothing chosen: a cheaper tier's model may not be able to operate one.

Which model a chat uses

Chat is always on Auto. Each message you send has its tier chosen the same way, from the message and the last few turns of the conversation, up to the Max model tier of the caps that apply.

A conversation holds the tier it is on for an hour after each turn. Within that hour it can move up for a harder question but not down, since a step down would re-read the whole conversation on a model that has none of it cached. After an hour of quiet the next message is chosen afresh. When your day cap is nearly spent, a turn comes down to a tier it still has room for.

Model connections

Settings → Agents lists every model connection in the enterprise, whose it is, and whether it can be read. Each owner's connections are listed by priority, lowest number first; at the same priority, in the order a run tries providers. Keys are never shown, only their last four characters. Add Agent adds one:

Provider How you connect it
Claude A Console API key, a setup token, or Connect Claude Pro/Max to sign in with your seat.
OpenAI An OpenAI API key, or Connect ChatGPT plan to sign in with your ChatGPT plan (the login Codex uses).
Grok An xAI API key, or Connect SuperGrok plan to sign in with your SuperGrok plan (the login Grok Build uses).
OpenRouter An API key.

Signing in with a ChatGPT plan ends on a page that does not load. That is expected: OpenAI sends your browser to an address on your own computer, where nothing is listening. Copy the whole address from the address bar, paste it into the form, and choose Finish connect.

Signing in with a SuperGrok plan ends on xAI's own page, which shows a code under Enter this code to finish signing in and says to paste it into Grok Build. Paste that code into the form instead, and choose Finish connect. The page's address is not the code: pasting it is refused with a message saying so.

Pressing Connect again while a sign-in is under way reopens the same sign-in page rather than starting another. A sign-in that has expired says so when its code is pasted, and Connect then starts a new one.

A connection belongs to the enterprise, shared by everyone; to a team, shared by its current members and lead; or to one member, used for that member's runs and chats. Add team connections on the Team page or choose the team as the owner on Settings → Agents. If a task specifies an exact model, the OS first looks for that model on an eligible connection with capacity, using that connection's own spelling of the model id.

If no eligible connection with capacity lists that model, or the task specifies a tier instead, the OS tries:

  1. The member's own connections, lowest priority number first across providers.
  2. The task's teams the member currently sits on or leads, lowest priority number first across providers.
  3. The enterprise's connections, lowest priority number first across providers.

A member chat can use the teams that member sits on or leads. A task uses only its own teams. Removing the member from a team removes access to that team's connections unless they still lead it. Closed teams are excluded.

For example, Grok at priority 0 comes before Claude at 5 and OpenAI at 10 for the same owner. At equal priorities, Claude, OpenAI, Grok, then OpenRouter breaks the tie. A connection whose usage cannot be read can still be tried; an unknown usage reading does not mean its quota is exhausted.

Each provider has its own model for each tier. A task that names a tier runs that provider's model for it, and you can change the model behind a tier per provider.

If the connection that answers does not list a tier's model (the provider retired it, or that account was never given it), the tier runs the next best model that connection does list: the one most alike in name and nearest in output price. The cap form shows the model each tier is running. Nothing is blocked, and the tier goes back to its own model as soon as the connection lists it.

The OS's own tasks have no assigned member and borrow no team connections, so their fallback order is the enterprise's connections first, then the canonical COO's connections. An exact model is still tried first when an eligible account offers it.

When a connection does not offer the model

When no eligible connection with capacity offers the exact model, the first connection in the fallback order with capacity answers the run, using the closest of the three models your tiers mean on that provider. Model ids are translated between providers: anthropic/claude-sonnet-5.5 on OpenRouter is claude-sonnet-5-5 on Claude.

The closest tier model is chosen as follows:

  1. The tier you gave the named model yourself, if it is one of your tier models on any provider.
  2. Otherwise the tier model whose output price is nearest to the named model's.
  3. If nothing prices the named model, the tier the run would have used with Default.

The run page shows the model the run used, and the model it stands in for. The exact-model picker includes the models offered by enterprise, team and individual connections. An exact model available only on OpenRouter is tried there before substituting another model on a higher-priority connection.

When a connection cannot be used

A run never fails for want of a model. It is blocked, says why, and resumes when the cause clears:

What happened Reason Resumes
No connection at all llm_not_bound As soon as a connection the run can use is added: the member's own or the enterprise's. It does not try again before then
The provider refused the credential, or it is out of credit llm_http_401, …402, …403 As soon as you change a credential, and it tries again hourly. If the refused credential is a plan sign-in, the next row applies instead
A plan sign-in (Claude Pro/Max, ChatGPT plan, SuperGrok plan) has expired or been withdrawn claude_oauth_refresh_failed:…, llm_oauth_refresh_failed:…, or llm_http_401/…403 on that sign-in At once, on another member of the task's role whose sign-in works. If nobody's works, as soon as one of them signs in again. It does not try again hourly (see the note under this table)
A rate limit is used up: a Claude or ChatGPT seat's session or weekly window, or a Claude model window llm_quota_exhausted When the window resets
A spend limit is used up: Claude's extra usage, or an OpenRouter key limit that resets daily, weekly or monthly llm_quota_exhausted … kind=spend_limit When the limit resets: at the time the provider gives, or else the next midnight, Monday or 1st of the month (UTC)
A balance is used up: prepaid credits, or a key limit that never resets llm_quota_exhausted kind=balance It tries again hourly: add credits
The model does not exist llm_http_404 When the model answers again; after an hour it waits for you

A sign-in that stopped working. Only a person signing in again fixes a plan sign-in that has expired or been withdrawn, so the OS does not keep trying it. Blockers lists the sign-in, naming whose it is, with a Reconnect action that opens Settings → Agents on that connection to sign in again. Until then that member is passed over: new runs, retries and the blocked run itself go to another member of the role whose sign-in works. If nobody's works, the run waits on Blockers and goes ahead as soon as one of them signs in again, and not before: there is no timer. A timeout, a rate limit or a server error while renewing a sign-in is not this: the run tries again on the usual backoff.

Blockers lists a connection with a limit used up under No LLM capacity, once per connection: which limit, when it resets (in UTC), and Raise limit or Add credits. A key counts as used up only on what the provider reports as left on it, the same figure Agents shows, never on its all-time spend against a monthly limit.

The OS also checks every ten minutes that the model each tier runs still exists on your connection. A tier whose own model is gone runs the next best one instead, so a model is listed on Blockers under Models unavailable only when the provider says it is gone and its model list could not be read to choose another. See Runs.

Plans

Your plan sets how long run history is kept (see Isolation and retention), and what your enterprise includes: members, runs, runner minutes, concurrent runs, schedules and storage. See pricing.

Plan limits

The amounts your plan includes are held to. They sit beside your own caps, not instead of them: the Spend switch turns your caps off, never the plan's limits.

Where a plan says stop, work past it does not start. Free stops at its portal runs, its workspace runner minutes and its storage. A run that would start past a stop is paused, not failed:

  • It waits on Blockers under Paused: plan limit, naming the limit it met: for example, all 100 of Free's portal runs for the month used, which reads plan_limit: portal_run 100 of 100 on Free. Needs you shows the limit with Upgrade, and the run's member says so in chat.
  • It keeps its task and its member, like a run paused for spend.
  • A run already under way when the limit is reached is not stopped. It finishes.
  • A schedule that fires past a stop starts nothing, and leaves a skipped run that names the limit.

Paused work resumes by itself, within a minute of the limit clearing: when a new month begins (on Free, the 1st of the month, UTC), when storage is freed below what the plan includes, or when the enterprise moves to a plan that includes more. Nobody has to retry it.

Paid plans run on past the included amounts and bill the overage per billing cycle on the renewal invoice: extra members, runner minutes, portal runs and storage, each at the plan's own rate. A billing cycle is a month counted from the day the subscription started. A monthly plan is charged for it at the end of each cycle; an annual plan is still counted month by month, and charged once a year, on the yearly renewal invoice. See Billing.

Members, schedules and concurrent runs are capped by the plan:

Limit What happens at it
Members On Free, a member past the 2 included is refused. A paid plan adds them and bills the extra members.
Schedules Enabling a schedule past the plan's number (3 on Free, 15 on Starter) is refused. Company and above have no limit.
Concurrent runs The company's Concurrent runs can be set no higher than the plan's figure, plus any extra concurrent runs bought on Billing. A run past it waits its turn: it is not paused.

A refusal names the plan and says to upgrade on Billing.

The OS's own tasks do not count toward portal runs: onboarding, self-improvement and the organisation changes take none of the plan's portal runs, are never billed as extra ones, and are not held when the plan's portal runs are used up. One that works in a workspace still uses runner minutes. Their cadence takes none of the plan's schedules either.

Over the API

Call Scope What it does
GET /v1/spend spend:read Today's spend and runs, the tightest caps, and every cap.
PATCH /v1/spend/caps spend:write Add or replace the cap on one layer. Raising a day cap queues paused runs again.
PATCH /v1/spend/enabled spend:write Turn spend limits on or off: { "enabled": false }.
GET /v1/llm/models llm:read The models your connections offer, for a task's Model.
GET /v1/llm/connections llm:read Your model connections, without their keys.