Cost per accepted result is the total cost of every run, retry, tool call and human review divided by the number of outputs that pass a defined acceptance rubric. It is more useful than price per million tokens because a cheap model can become expensive when it fails often, and an expensive model can be economical when it reduces retries and correction time.
The calculator below turns DMT’s accepted-result methodology into a working tool. It uses editable price fields and August 11, 2026 OpenAI GPT-5.6 presets. Always check the current official pricing page before a procurement or budget decision.
AI agent cost calculator
All prices are editable. Token rates are USD per 1 million tokens. Enter totals across the evaluation batch, not a single successful run.
Important input rule: do not double-count cached tokens. Put regular/billable non-cached input in “Input tokens,” cached reads in “Cached input tokens,” and cache writes in their own field. Vendor usage exports differ; map each field to the current invoice documentation before using the output for finance.
The formula
Model cost =
(input tokens / 1,000,000 × input rate)
+ (cached input tokens / 1,000,000 × cached-input rate)
+ (cache-write tokens / 1,000,000 × cache-write rate)
+ (output tokens / 1,000,000 × output rate)
Tool cost = tool calls / 1,000 × tool-call rate
Human cost = reviewer hours × loaded hourly cost
Total evaluation cost =
model cost + tool cost + other infrastructure
+ human cost + correction/rework cost
Acceptance rate = accepted results / attempted runs
Cost per accepted result = total evaluation cost / accepted resultsIf no result is accepted, cost per accepted result is undefined/infinite—not zero. That outcome is informative: the workflow failed the rubric and should not be compared as if it produced usable work.
Current GPT-5.6 price presets
The calculator presets use OpenAI’s standard short-context rates captured on August 11, 2026. Prices are USD per 1 million tokens.
| Model | Input | Cached input | Cache write | Output |
|---|---|---|---|---|
| GPT-5.6 Luna (short) | $0.20 | $0.02 | $0.25 | $1.20 |
| GPT-5.6 Terra (short) | $2.00 | $0.20 | $2.50 | $12.00 |
| GPT-5.6 Sol (short) | $5.00 | $0.50 | $6.25 | $30.00 |
| GPT-5.6 Luna (long) | $0.40 | $0.04 | $0.50 | $1.80 |
| GPT-5.6 Terra (long) | $4.00 | $0.40 | $5.00 | $18.00 |
| GPT-5.6 Sol (long) | $10.00 | $1.00 | $12.50 | $45.00 |
Switch the calculator to Custom for long-context or future rates. OpenAI also documents a 10% uplift for eligible regional-processing configurations. Do not apply that uplift unless your deployment actually uses that option.
Tool and infrastructure costs to include
| Cost component | Current OpenAI reference | How to enter it |
|---|---|---|
| Tool calls | $2.50 per 1,000 calls on the captured pricing table | Use tool calls and tool rate fields |
| Web search | $10 per 1,000 calls plus search-content tokens where applicable | Add call charge to other cost or use a weighted tool rate; keep search tokens in token totals |
| Containers | Starts at $0.03 for 1 GB per priced session period; size/time rules apply | Add the billed container total from usage, not an estimate from wall-clock alone |
| File storage | $0.10/GB/day after the first free GB on the captured page | Add the billed storage amount |
| External SaaS/API | Provider-specific | Add actual call, seat or data cost to other cost |
| Compute/orchestration | Your platform-specific amount | Add cloud/run cost to other cost |
Built-in tool tokens are generally charged at the selected model’s token rates even when a separate call fee also applies. Review the official page for the exact tool because billing units and minimums can change.
Define “accepted” before the test
An acceptance rate is meaningless if reviewers decide after seeing which model produced the output. Use the same rubric, blinded where practical, with objective thresholds.
| Dimension | Pass rule example for a source-backed article package |
|---|---|
| Factual support | Every material claim maps to a current primary source; no invented quote/date/number |
| Intent | Answers the assigned primary query and reader job without changing scope |
| Completeness | All required sections, examples, limitations and implementation details are present |
| Duplication | New information gain is material; existing owners are linked rather than rewritten |
| Rights | Every visual has source, capture date, provenance, alt text and credit |
| Technical validation | Code/tool/template tests pass in the stated environment |
| Editorial quality | No major rewrite required; voice and structure meet the publishing standard |
| Release safety | Metadata, canonical, internal links and rendered QA pass |
Decide whether a correctable output is accepted. A useful policy is: accepted means no material factual/intent error and no more than a defined correction threshold, such as ten reviewer minutes. Track correction time separately even when the item passes.
Evaluation data template
run_id,model,reasoning,prompt_version,task_id,input_tokens,cached_input_tokens,cache_write_tokens,output_tokens,tool_calls,tool_cost,infra_cost,latency_seconds,retry_of,review_minutes,correction_minutes,accepted,rejection_reason
001,gpt-5.6-luna,high,v3,brief-01,48000,12000,0,9600,2,0.005,0.03,82,,3,0,true,
002,gpt-5.6-luna,high,v3,brief-02,51000,14000,0,10200,3,0.0075,0.03,94,,11,8,false,unsupported_claim
003,gpt-5.6-terra,high,v3,brief-02,56000,15000,0,11400,3,0.0075,0.03,106,002,4,0,true,Keep task IDs and prompt versions so you can separate model effects from a changing test. A retry belongs to the same reader job and its cost remains in the numerator.
Worked example
The calculator defaults to an illustrative 100-run Luna batch: 5 million regular input tokens, 2 million cached input tokens, 1 million output tokens, 150 generic tool calls, $5 other infrastructure, three reviewer hours at $25/hour and $20 rework. If 80 results pass, the model/token portion is small relative to human review. That is common in low-priced models: optimizing a few cached-token cents matters less than reducing correction time or increasing acceptance.
| Optimization | Can reduce cost | Can increase cost/risk |
|---|---|---|
| Use a cheaper worker model | Lower token bill | More retries or reviewer correction |
| Cache stable context | Lower repeated input cost | Stale context if invalidation is weak |
| Increase reasoning | Higher first-pass acceptance on difficult tasks | More tokens/latency on simple tasks |
| Add deterministic validation | Catches failures before human review | Engineering and maintenance cost |
| Reduce source scope | Less token/tool work | Missed evidence if scope becomes too narrow |
| Use stronger model only on escalations | Balances worker cost and difficult cases | Routing errors if escalation rules are vague |
Compare configurations fairly
- Freeze a representative task set before testing.
- Use the same acceptance rubric and reviewer instructions.
- Record model, reasoning, prompt version, tools and context mode.
- Include failed runs and retries.
- Measure human time, not just API spend.
- Report confidence intervals or at least the sample size; ten easy tasks are not a production benchmark.
- Segment by task difficulty instead of averaging unlike work.
- Run sensitivity scenarios for reviewer rate, acceptance and token prices.
Sensitivity analysis: what usually moves the answer
Do not present one calculator output as a forecast. Change the assumptions that are both uncertain and economically important. In many marketing-agent workflows, reviewer time and acceptance rate dominate the token rate.
| Scenario | Change | Question answered |
|---|---|---|
| Base | Observed token/tool/review totals | What did the test actually cost? |
| Acceptance downside | Acceptance rate minus 15 points | How expensive is quality drift? |
| Review downside | Reviewer minutes +50% | What if corrections are understated? |
| Scale | 10× tasks, separate fixed and variable cost | Does orchestration amortize or do review bottlenecks grow? |
| Model escalation | Worker model for 80%; stronger model for 20% | Is routing better than one model for everything? |
| Price change | Current vendor rates ±20% | Would the decision survive a pricing update? |
Cost per accepted result is nonlinear with acceptance: the denominator shrinks as quality falls while failed-run cost remains. That is why a model with one-tenth the token price is not automatically ten times cheaper per useful output.
Spreadsheet formulas
If your columns are attempted runs in B2, accepted results in C2, total model/tool/infra cost in D2, reviewer hours in E2, hourly rate in F2 and rework cost in G2:
Acceptance rate: =IFERROR(C2/B2,0)
Human review cost: =E2*F2
Total evaluation cost: =D2+(E2*F2)+G2
Cost per attempt: =IFERROR((D2+(E2*F2)+G2)/B2,"")
Cost per accepted result: =IF(C2=0,"No accepted result",(D2+(E2*F2)+G2)/C2)Keep raw runs on one sheet and aggregate by model, prompt version and task segment with a pivot table. Never average the “cost per accepted result” ratios from unequal batches; sum costs and accepted counts first, then divide.
Decision thresholds
- Ship: acceptance and incident thresholds pass, cost is within the business ceiling and the sample represents production.
- Route: cheap worker passes routine tasks but difficult segments need escalation.
- Redesign: reviewer time or repeated failures dominate; change the task, data or validation before changing the model.
- Stop: no accepted outputs, unsafe incidents, unmeasurable rubric or economics worse than the existing manual process.
Metrics to report beside cost
- acceptance rate and rejection reasons;
- cost per attempt and per accepted result;
- median and tail latency;
- review/correction minutes per accepted result;
- retry and escalation rate;
- tool-denial or policy-failure rate;
- quality score by task segment;
- material incident count.
A configuration with a slightly higher cost but much lower incident rate can be the correct business choice. The calculator is an economic lens, not a substitute for safety or quality gates.
FAQ
Should retries be included?
Yes. A retry is part of the cost of obtaining the accepted result. Excluding failed attempts systematically favours unreliable workflows.
Should reviewer time be included?
Yes. Use a loaded hourly cost or a consistent internal rate. Reviewer time often exceeds token cost and can reverse the apparent model ranking.
Is cost per accepted result the same as ROI?
No. Cost per accepted result measures production efficiency. ROI also needs the value or incremental benefit of the accepted result, attribution, operating period and counterfactual.
How this calculator was verified
DMT transcribed the GPT-5.6 and tool rates from OpenAI’s official pricing page captured August 11, 2026, kept every rate editable, and checked the JavaScript formula against the displayed equations and worked inputs. The calculator does not fetch billing data and cannot know discounts, contract rates or later price changes.
Bottom line
Measure the whole system: tokens, cache, tools, infrastructure, retries, review and correction. Define acceptance first and count every attempt. Then use the calculator to compare configurations on the same task set. For workflow design and cost controls around Luna, continue with DMT’s Luna automation cost playbook.
Use the result alongside the GPT-5.6 pricing-change analysis, model-routing guide, worker/reviewer pattern and Work/Codex automation architecture.
