Estimate agent workload cost

Synced from outfitter/docs/documentation/cost-estimation.md. The repository is the source of truth.

This table estimates what one agent that never stops costs in model tokens. Every figure comes from a dated price book and an estimated token rate, not from an invoice. The day column is 24 hours at the stated rate. The month column is 730 hours, the average month.

Provider	Model	Steady: day / month	Saturated: day / month
Anthropic	Claude Fable 5	$182.40 / $5,548	$408.00 / $12,410
OpenAI	GPT-5.6 Sol	$98.40 / $2,993	$216.00 / $6,570
Anthropic	Claude Opus 5	$91.20 / $2,774	$204.00 / $6,205
OpenAI	GPT-5.6 Terra	$39.36 / $1,197	$86.40 / $2,628
Anthropic	Claude Sonnet 5	$36.48 / $1,110	$81.60 / $2,482
Anthropic	Claude Haiku 4.5	$18.24 / $555	$40.80 / $1,241
OpenAI	GPT-5.4 mini	$14.76 / $449	$32.40 / $986
OpenAI	GPT-5.6 Luna	$3.94 / $120	$8.64 / $263

Four notes apply to every row:

• The two rates. Steady is ordinary agent turns with repeated instructions: 400K input, 600K cache-read, and 60K output tokens for each active hour. Saturated is continuous agentic coding with large tool results: 1M / 2M / 100K.
• Scope. This is the model line only. It excludes substrate, tools, subagents, and cache writes. See What this figure excludes.
• Luna reserve. Apply a five-times reserve to GPT-5.6 Luna until an invoice settles its disputed price. That gives $19.68 / $599 steady and $43.20 / $1,314 saturated.
• Part-time agents. Cost scales with active hours. Eight hours on each working day is about 176 hours, which is 24 percent of the month column.

At the same token rate, GPT-5.6 Sol costs about 25 times GPT-5.6 Luna and Claude Fable 5 costs about 46 times. Apply the Luna reserve and those spreads fall to 5 and 9 times. Against Claude Haiku 4.5, the cheapest model with an undisputed price, they are 5.4 and 10 times. The two rates change the cost of one model by about 2.2 times. Model choice and work intensity are separate controls.

This guide calculates a planning estimate. It does not read invoices or collect usage. See Replace estimates with measurements for the record that can replace each estimate later.

Price book

Two providers, two capture dates. Prices are United States dollars for one million text tokens.

OpenAI standard text-token prices, captured 2026-08-15 from the OpenAI model documentation:

Model	Documented role	Input	Cache read	Output
GPT-5.6 Sol	Frontier tier	$5.00	$0.50	$30.00
GPT-5.6 Terra	Balance of intelligence and cost	$2.00	$0.20	$12.00
GPT-5.4 mini	High-volume coding, computer use, and subagents	$0.75	$0.075	$4.50
GPT-5.6 Luna	Cost-sensitive, high-volume tier	$0.20	$0.02	$1.20

Anthropic standard text-token prices, captured 2026-08-17 from the Claude platform pricing page:

Model	Documented role	Input	Cache read	Output
Claude Fable 5	Demanding reasoning and long-horizon work	$10.00	$1.00	$50.00
Claude Opus 5	Complex agentic coding and enterprise work	$5.00	$0.50	$25.00
Claude Sonnet 5	Balance of speed and intelligence	$2.00	$0.20	$10.00
Claude Haiku 4.5	Fastest and most cost-effective	$1.00	$0.10	$5.00

Three properties of these tables control every figure in this guide:

• The Anthropic price vectors are exactly proportional on every token class. Fable 5 : Opus 5 : Sonnet 5 : Haiku 4.5 = 10 : 5 : 2 : 1. Therefore any Anthropic figure in this guide scales by that ratio, whatever the token mix is. Use this property to check the arithmetic.
• Neither table contains a cache-write price, and both providers charge one. An OpenAI explicit cache write costs 1.25 times the uncached-input price. An Anthropic cache write costs 1.25 times input for a 5-minute lifetime and 2 times input for a 1-hour lifetime. Every figure in this guide omits that line, so every figure understates the cost. See Correction from measured usage for the size of that error.
• The GPT-5.6 Luna price is disputed. The 2026-08-15 capture and a later live re-check of the model catalog, the comparison page, and the Luna page all gave $0.20 / $0.02 / $1.20. Official-domain search results crawled two weeks earlier gave $1.00 / $0.10 / $6.00, which is five times more. No invoice has settled it. That ratio is the five-times reserve this guide applies to every Luna figure.

In the 2026-08-17 capture, the Claude Sonnet 5 introductory price of $2.00 / $10.00 is the standard price, and a previously scheduled increase to $3.00 / $15.00 is no longer listed. An estimate built on the increase is about 50 percent too high.

How this figure is calculated

Three inputs produce every number in the table above: a dated price book, an estimated token rate, and the active hours in the period.

Step 1 — select a token rate

The rate is the only estimated input. Two rates bound realistic agent work. Both come from the workload profile, not from a measured ledger:

Rate	Per active hour: input / cache read / output	Derivation
Steady	400K / 600K / 60K	100K / 150K / 15K for each run, 15 minutes each run, 4 each hour
Saturated	1M / 2M / 100K	500K / 1M / 50K for each run, 30 minutes each run, 2 each hour

No observed provider record supplies these two rates. Every dollar figure in this guide inherits that uncertainty.

Step 2 — calculate the cost of one active agent-hour

Apply the price book to the selected rate. For Claude Opus 5 at the steady rate:

  400,000 input      × $5.00  / 1,000,000 = $2.00
+ 600,000 cache read × $0.50  / 1,000,000 = $0.30
+  60,000 output     × $25.00 / 1,000,000 = $1.50
                                            -----
                                            $3.80 per active agent-hour

The general form, with cache writes and reasoning, is in Calculate model cost once. The same calculation for every model:

Model	Steady	Saturated
Claude Fable 5	$7.60	$17.00
GPT-5.6 Sol	$4.10	$9.00
Claude Opus 5	$3.80	$8.50
GPT-5.6 Terra	$1.64	$3.60
Claude Sonnet 5	$1.52	$3.40
Claude Haiku 4.5	$0.76	$1.70
GPT-5.4 mini	$0.615	$1.35
GPT-5.6 Luna	$0.164	$0.36

Step 3 — multiply by the active hours in the period

A non-stop agent is active for 24 hours on each day and 730 hours in each month. For Claude Opus 5 at the steady rate:

$3.80 × 24  =  $91.20 for one day
$3.80 × 730 =  $2,774 for one month

The table at the top of this guide applies these two multiplications to every model.

What this figure excludes

The table at the top of this guide is the model line only. The full equation has five more terms. The prices quoted below come from the same 2026-08-17 Anthropic capture as the price book.

• Cache writes. See the price book above. This is the one excluded term with a measured size. See Correction from measured usage.
• Substrate. A non-stop agent holds compute for all 730 hours. Add the hourly price of the node or pod. Claude Managed Agents prices this line directly at $0.08 for each session-hour, which is $58.40 for a non-stop month.
• Tool fees. Anthropic web search costs $10 for 1,000 searches. An agent that searches once each minute non-stop adds $438 each month.
• Subagents. A coordinator that runs subagents multiplies the token rate by its concurrency. These rates describe one serial thread.
• Long-context and residency uplifts. A GPT-5.6 request above 272,000 input tokens can cost more. Anthropic inference_geo: "us" adds 1.1 times.

Correction from measured usage

One measured record exists, and it corrects the token mix that the estimate assumes.

A single workstation retained 2,804 Claude Code session files covering 42 active days. Each assistant turn carries a usage object. Aggregating all 221,609 turns gives 45.84 billion tokens with this composition:

Token class	Assumed by the rates	Measured
Uncached input	~38%	0.04%
Cache read	~57%	96.76%
Cache write	0%, omitted	2.82%
Output	~6%	0.39%

Two corrections follow:

1. Uncached input is a rounding error. Real agent work re-reads a cached prefix on almost every turn. A cost model weighted toward uncached input prices the wrong thing. Priced on Claude Opus 5, the measured mix costs about 4.7 times less for each token than the steady rate does.
2. Cache writes are the second-largest cost line. The 125,394 Claude Opus 5 turns in this record used 24.51B cache-read, 703M cache-write, 86M output, and 2.08M uncached-input tokens. Priced on Claude Opus 5 and treating every cache write as a 5-minute write, that is $12,255 cache read, $4,397 cache write, $2,151 output, and $10 uncached input: 65, 23, 11, and 0.05 percent. A table that omits a line of that size reports about 77 percent of the model cost.

Correction 2 is worth about 1.3 times, and correction 1 about 4.7 times. Both are smaller than the 25-times spread between model tiers, so model choice remains the larger control. Neither correction transfers directly to the tables above: the two rates assume no cache writes at all, so their cache-write error is unknown rather than 23 percent.

This record measures one human driving agents interactively between 2026-07-05 and 2026-08-17. It does not measure a resident Deployment, and it is not a provider invoice. Treat it as evidence about token composition, not as a price for the non-stop case.

Evidence class for each number

Value	Class	Basis
Model prices	Price book	Dated public captures, 2026-08-15 and 2026-08-17
730 hours in a month	Convention	The 730 / interval_hours rule
The two token rates	Estimated	Workload profile assumptions, no ledger
Cost per hour and per month	Derived	Price book times the estimated rate
Token-class composition	Measured	221,609 assistant turns over 42 days
GPT-5.6 Luna price	Disputed	$0.20 / $0.02 / $1.20 against $1.00 / $0.10 / $6.00, no invoice
Substrate and tool prices	Price book	The 2026-08-17 Anthropic capture
Every other excluded term	Unknown	Not zero

A price-book calculation is not an observed provider charge. An unknown value is not zero.

Cost boundary

Use one workload profile for every execution surface. Change only the substrate inputs when you compare a local run, GitHub Actions, a scheduled Kubernetes Job, or a resident Deployment. Use this equation:

monthly cost =
  fixed substrate cost
  + runs × (model + tools + variable compute)
  + storage
  + network

The terms mean:

Term	Include
Fixed substrate	Compute that accrues while no run is active. A resident Deployment is the usual case.
Runs	Every initial attempt, retry, and delegated run in the month.
Model	Input, cache-read, cache-write, output, and reasoning charges for one run.
Tools	Search, browser, image, sandbox, or other billable tool use for one run.
Variable compute	Runner minutes or Job resources that accrue only while a run is active.
Storage	Session data, artifacts, logs, volumes, and backups.
Network	Egress, gateways, and other billed transfer.

An included quota changes the billed amount. It does not change usage. Record the usage before you apply the quota.

Define one workload profile

Enter these values once:

Input	Unit	Rule
Workload identity	stable text	Use the same identity on every surface.
Interval	hours	Use the time between scheduled starts.
Attempts per scheduled start	count	Include the first attempt and expected retries.
Delegated runs per attempt	count	Count each subagent or delegated Job separately.
Input tokens	tokens per run	Keep uncached input separate from cache reads.
Cache-read tokens	tokens per run	Use null, not zero, when the provider does not report them.
Cache-write tokens	tokens per run	Use null, not zero, when the provider does not report them.
Output tokens	tokens per run	Keep reasoning separate when the provider reports it separately.
Reasoning tokens	tokens per run	Use the provider’s billing rule. Do not assume that they are free.
Billable tools	quantity per run	Name each unit and price source.
Active duration	minutes per run	Use this for variable compute.
Artifacts, storage, and network	provider units	Keep each provider line separate.

Convert an interval to an average month with:

runs per month = 730 / interval_hours

For example, one run every 24 hours gives 730 / 24 = 30.4167 scheduled starts in an average month. A calendar-month report can use the actual count instead. Label which method you use.

Then calculate the total attempt count:

attempts per month =
  scheduled starts
  × attempts per scheduled start
  × (1 + delegated runs per attempt)

Use the last factor only when every attempt creates that number of delegated runs. If delegation varies, list the parent and child workloads separately.

Calculate model cost once

Use a price book with a source and an effective date. For a model with separate text-token prices:

model cost per run =
  input_tokens × input_price / 1,000,000
  + cache_read_tokens × cache_read_price / 1,000,000
  + cache_write_tokens × cache_write_price / 1,000,000
  + output_tokens × output_price / 1,000,000
  + provider-defined reasoning cost

The same workload profile and price book MUST produce the same model line on every execution surface. Do not recalculate model cost inside an Actions or Kubernetes estimate.

Keep two cost fields when evidence is available:

• Provider-reported cost is the charge that the provider returned for the exchange. Keep its amount and currency unchanged.
• Price-book estimate is a derived amount. Keep the source and effective date with it.

Do not replace one with the other. Do not present a derived estimate as an observed provider charge.

Worked case: one organization report each day

The example starts from an observed AI Outfitter organization-report flow. The 2026-W32 report covered 16 repositories. Its KPI JSON was 21,020 bytes. Its rendered Markdown was 11,719 bytes. Scripts collected and rendered the facts. The model wrote only a short Highlights paragraph.

Those report dimensions are observed. The retained artifacts do not contain a token total. Therefore, these token bands are estimated:

Band	Input	Cache read	Output	Total per run
Compact	10,000	20,000	2,000	32,000
Expected	25,000	75,000	5,000	105,000
High	100,000	300,000	15,000	415,000

All values use the OpenAI half of the price book above. Keep the base estimate and the five-times Luna reserve separate.

At 730 / 24 = 30.4167 runs per month, the model estimates are:

Band	Monthly tokens	GPT-5.6 Sol	GPT-5.6 Terra	GPT-5.6 Luna	GPT-5.4 mini
Compact	0.973M	$3.65	$1.46	$0.15	$0.55
Expected	3.194M	$9.51	$3.80	$0.38	$1.43
High	12.623M	$33.46	$13.38	$1.34	$5.02

The expected model cost is $0.313 for each run on Sol, $0.125 on Terra, $0.013 on Luna, and $0.047 on GPT-5.4 mini. The five-times Luna reserve changes its expected monthly planning line from $0.38 to $1.90.

These values exclude everything in What this figure excludes, and also tax.

This case sits far below the non-stop ceiling at the top of this guide, because the model writes one paragraph and scripts do the rest.

Compare execution surfaces

Start with the same expected daily-report model line. Then add only the surface-specific substrate.

Surface	Fixed substrate	Variable compute
GitHub-hosted Actions	none for an otherwise idle workload	billable runner minutes after included quotas
Self-hosted Actions	allocated runner and operations cost	per-run cost when your allocation method charges it
Local run	allocated workstation cost, if the organization accounts for it	active process time, if the organization accounts for it
Scheduled Kubernetes Job	none when no workload-specific capacity stays allocated	pod resource time for every attempt
Delegated Kubernetes Job	none when no workload-specific capacity stays allocated	child pod resource time, recorded under its parent run
Resident Kubernetes Deployment	allocated resources for 730 hours	extra per-run resources that are not in the resident allocation

This gives two different substrate equations for the same model line:

Actions monthly cost =
  model and tool cost for all attempts
  + hosted billable minutes × hosted runner price
  + self-hosted runner allocation
  + storage
  + network

Resident monthly cost =
  resident hourly allocation × 730
  + model and tool cost for all attempts
  + storage
  + network

An idle resident has zero model cost when it makes no model exchange. It still has its 730-hour substrate allocation. A scheduled Job has no workload-specific compute cost while no pod exists, unless the cluster allocation method assigns idle capacity to it.

See the Actions billing-inputs research note for the runner-minute form. The Agent Operator resident and Job forms are not documented yet.

Retries, failures, and subagents

Count every attempt once. A failed attempt can incur model, tool, runner, and network costs even when it produces no artifact. A retry MUST use a new attempt number. Do not overwrite or hide the first attempt.

A delegated run MUST carry its parent run. Add the child cost once to the workload total. Do not also copy the child model exchanges into the parent’s direct model line.

If a workflow platform retries a whole job, record that job as a new attempt. If a harness retries one provider request inside the same attempt, record each model exchange and aggregate them once into that attempt.

Unknown and partial usage

Use these states:

State	Meaning
complete	The record contains all usage fields that the provider and harness expose. It has no declared gap.
partial	The record contains some usage fields and lists each unavailable field.
unavailable	The record contains no usable usage counters and lists the gap.

Use null for an unavailable counter. Use 0 only when the provider or harness observed zero. A monthly view MUST render unavailable cost as unknown. It MUST NOT render it as $0.

Do not compare two totals until their boundaries match. State whether each total includes retries, delegated runs, tools, storage, network, quotas, and tax.

Replace estimates with measurements

Retain one machine-readable record for each run and model exchange. After 30 measured daily reports, replace the planning bands with the median, 90th percentile, and maximum successful-run cost. Report failed attempts and retries separately.

Only one execution surface can supply that record today:

Surface	Usage record	Status
Local Claude Code	One usage object for each assistant turn	Available
Local codex	The rollout file carries no token field	Unavailable
Agent Operator resident	The Pi session file carries no token field	Unavailable
GitHub Actions run	An HTML transcript artifact, with no total	Unavailable

Therefore a comparison across surfaces is not possible yet. Close this gap before you replace any estimate above. Two proposals do it: Pensieve pull request #22 for the record contract, and Actions pull request #42 for the runner-minute inputs. Neither is merged.

This guide defines the method and the record contract. It does not include a collector, a calculator command, or a billing dashboard.