GPT-6 Astra’s Standard API rates start at $10 per million input tokens and $50 per million output tokens. That is 2.5× GPT-5.6 Sol’s short-context rates.
But the number I would put on a monitoring dashboard first is 272,000 input tokens. Cross that boundary and higher rates apply to the entire request, not just the excess.
For coding agents, browser automation, research, and computer-use workflows, the useful comparison is total spend per accepted result. Retries, growing tool history, cache misses, execution charges, and human correction can matter more than the headline token rate.
Here is how I would break down the budget.
Start with the context cliff
These simplified requests use Standard pricing, without caching or tool charges:
| Workload | Input tokens | Output tokens | Estimated cost |
|---|---|---|---|
| Short coding request | 20K | 2K | $0.30 |
| Large analysis | 100K | 10K | $1.50 |
| Agent near the threshold | 270K | 10K | $3.20 |
| Agent above the threshold | 280K | 10K | $6.35 |
| Repository-scale task | 300K | 20K | $7.50 |
The two middle rows are the trap:
270K input, 10K output:
270,000 × $10 / 1,000,000 + 10,000 × $50 / 1,000,000 = $3.20
280K input, 10K output:
280,000 × $20 / 1,000,000 + 10,000 × $75 / 1,000,000 = $6.35
Input grew by about 3.7%; the request cost grew by almost 98%.
According to the model documentation, input above 272K triggers 2× input/cache rates and 1.5× output rates for the full request.
That makes context management a pricing decision, not just a latency optimization. I would avoid letting every screenshot, terminal log, retrieved page, and old conversation turn accumulate indefinitely. Summarization, selective retrieval, scoped sub-agents, and selective tool-result retention all deserve testing.
A small request does not pay for the model’s full context window. The bill follows processed tokens; the long-context band activates only when input exceeds 272,000 tokens.
The rate card I’d use in a budget
All prices below are per million tokens. Context bands depend on input-token count.
| Mode / input context | Input | Cache read | Cache write | Output |
|---|---|---|---|---|
| Standard ≤272K | $10.00 | $1.00 | $12.50 | $50.00 |
| Standard >272K | $20.00 | $2.00 | $25.00 | $75.00 |
| Batch/Flex ≤272K | $5.00 | $0.50 | $6.25 | $25.00 |
| Batch/Flex >272K | $10.00 | $1.00 | $12.50 | $37.50 |
| Fast ≤272K | $20.00 | $2.00 | $25.00 | $100.00 |
| Fast >272K | $40.00 | $4.00 | $50.00 | $150.00 |
Batch and Flex use half the applicable Standard rates. Fast uses twice those rates. They have different latency and availability characteristics, so I would not treat them as interchangeable discounts or speed settings.
Processing tier can move the bill by 4×
For the same 300K-input, 20K-output request:
| Mode | Input cost | Output cost | Total |
|---|---|---|---|
| Batch/Flex | $3.00 | $0.75 | $3.75 |
| Standard | $6.00 | $1.50 | $7.50 |
| Fast | $12.00 | $3.00 | $15.00 |
I would start offline evaluations, backfills, repository analysis, enrichment, and asynchronous research with Batch or Flex when their operating constraints fit.
Standard is the baseline I would use for interactive production evaluation. Fast needs a stronger justification: elapsed time must have enough value to cover the premium.
OpenAI describes up to 2× faster processing for Fast at twice the applicable rate. However, Fast has no latency SLA and is unavailable with EU data residency.
What the model actually exposes
The large context window explains why context costs can get out of hand:
| Specification | Value |
|---|---|
| Developer | OpenAI |
| Model ID | gpt-6-astra |
| Context window | 1,050,000 tokens |
| Maximum output | 128,000 tokens |
| Knowledge cutoff | April 30, 2026 |
| Input | Text and images |
| Output | Text |
| Reasoning levels | Low, Medium, High, XHigh, Max |
| Recommended API | Responses API for tool-rich workflows |
| Fine-tuning | Not supported |
| Long-context pricing | Above 272K input tokens |
OpenAI positions Astra for difficult end-to-end work rather than cheap, high-volume inference. Its supported workflows include coding, research, computer use, prompt caching, multi-agent orchestration, and compaction. The latest-model guide also describes async tool calling and mid-turn steering.
I would check feature availability on the actual endpoint before designing around it. Model support does not guarantee that every provider exposes every tool or capability.
The 1.05M-token window is capacity, not a recommendation to fill it.
Cache hits are cheap; repeated prompts are not automatically hits
In the Standard short-context band:
- Ordinary input: $10/M
- Cache read: $1/M
- Cache write: $12.50/M
A successful cache read costs one tenth of ordinary input. That does not mean every repeated prompt receives the read price: reuse requires a matching cached prefix that remains available.
I would track cache writes and successful reads separately.
Take ten requests, each containing the same 100K-token prefix, with every request staying within 272K total input tokens. Compare no caching against one full-prefix write followed by nine successful full-prefix reads, with no further writes:
| Prefix-only spending | No cache | One write, nine reads |
|---|---|---|
| Ordinary input | 10 × 100K × $10/M = $10.00 | $0.00 |
| Cache write | $0.00 | 100K × $12.50/M = $1.25 |
| Cache reads | $0.00 | 9 × 100K × $1/M = $0.90 |
| Total | $10.00 | $2.15 |
That is a 78.5% reduction in the repeated prefix’s input cost, not a prediction of typical savings or a reduction in the entire bill.
Now give each request 2,000 billable output tokens. Across ten requests, output adds $1.00 to either scenario:
Without caching: $10.00 + $1.00 = $11.00
With caching: $2.15 + $1.00 = $3.15
The total model-token reduction becomes about 71.4%, assuming no other input or charges. Misses, rewrites, extra input, tools, and processing tiers change it again.
Stable system instructions, repository maps, schemas, policies, and static documentation are the prefixes I would investigate first. The important measurement is actual reuse, not how repetitive the workload looks.
Tokens are only one part of an agent bill
OpenAI’s tool pricing adds separate charges:
| Item | Listed charge |
|---|---|
| Web search | $10 per 1,000 calls; retrieved content also billed at model token rates |
| File-search calls | $2.50 per 1,000 calls |
| File-search storage | $0.10/GB/day after the free 1 GB allowance |
| Hosted Shell / Code Interpreter, 1 GB | $0.03 per 20-minute session per container |
Eligible hosted execution sessions use per-minute billing with a five-minute minimum. Larger memory allocations cost more.
Tools also expand subsequent model input. A cheap search or terminal action can leave behind enough history to push the next request into the expensive context band.
My evaluation record would therefore include:
- Model input, output, cache writes, and cache reads
- Tool calls and hosted execution
- Total steps and retries
- Accepted results and unresolved failures
- Human correction time
Reasoning effort belongs in the experiment
Reasoning effort is not a separate line item in the published token table. It can still change spending through output length, tool use, and trajectory length.
Deeper reasoning might reduce retries and correction, or it might consume more resources without improving acceptance. I would compare settings on the same task set and report tokens, tool charges, completion rate, and correction time together.
Compare models on two axes: rates and outcomes
Here is the compact rate-and-capacity comparison. OpenAI prices use Standard short-context rates.
| Dimension | GPT-6 Astra | GPT-5.6 Sol | Claude Fable 5.1 | Gemini 3.8 Flash |
|---|---|---|---|---|
| Input / 1M | $10.00 | $4.00 | $10.00 | $0.75* |
| Output / 1M | $50.00 | $20.00 | $50.00 | $3.75* |
| Cache read / 1M | $1.00 | $0.40 | $0.25 | $0.075* |
| Context | 1.05M | 1.05M | 1M | 1,048,576 |
| Maximum output | 128K | 128K | 128K | 65,536 |
* Google’s introductory rates run through December 31, 2026. From January 1, 2027, input/output become $1.50/$7.50 per million tokens, and cache reads become $0.15/M. Cache storage is separate: $0.50/M tokens/hour during 2026, then $1/M tokens/hour from January 2027.
Fable: identical headline rates, different cache costs
Claude Fable 5.1 matches Astra’s $10/M input and $50/M output, but its $0.25/M cache reads cost one quarter of Astra’s short-context reads.
Its five-minute cache-write rate is $12.50/M, matching Astra’s listed write rate. Fable also has a one-hour write option at $20/M.
For a workload dominated by reusable cached prefixes, I would take that difference seriously. For tool-heavy engineering, I would also check whether Astra’s task outcomes offset it. Cache lifetime, hit rate, output volume, and acceptance all belong in the comparison.
Sol: the 2.5× premium needs evidence
Astra’s short-context input, output, and cache-read rates are all 2.5× Sol’s. Context and maximum output are the same.
With identical token usage and success rates, Sol wins on cost. To break even on tokens alone, Astra would need roughly 40% as much billable token-equivalent work.
Real trajectories are less tidy. Two failed-or-retried $1 attempts cost more than one successful $1.50 attempt. OpenAI reports stronger results with fewer output tokens and lower estimated API cost per task in several evaluations, despite Astra’s higher rates.
I would not extend that argument automatically to rewriting, extraction, classification, or ordinary chat.
Flash: a different budget category
At Google’s introductory rates, Astra is about 13.3× more expensive for both uncached input and output.
That is a strong reason to test routing: cheap models for predictable high-volume work, Astra for tasks where its capabilities measurably improve completion. “Astra everywhere” and “never Astra” are both policies I would want evidence for.
What the published benchmarks do—and do not—show
These are vendor-reported results, not independent measurements. A dash means no result was reported.
| Benchmark (%) | Astra | Sol | Fable 5.1 | Flash |
|---|---|---|---|---|
| AutomationBench | 41.4 | 18.1 | 31.4 | — |
| Terminal-Bench 4.0 | 57.9 | 37.3 | 55.8 | 19.1 |
| Terminal-Bench Science 0.1 | 64.6 | 22.4 | 52.6 | — |
| FrontierMath Tier 4 (v2) | 97.6 | 83.0 | 87.8 | — |
| GPQA Diamond | 96.0 | 94.6 | 93.7 | 95.3 |
| ExploitBench | 100.0 | 78.5 | — | — |
Against Sol, Astra gains 23.3 percentage points on AutomationBench and 20.6 points on Terminal-Bench 4.0.
OpenAI’s OSWorld 2.0 offline evaluation reports 72.6% versus 65.7%, a 6.9-point difference. A latency simulation estimated about 40 versus 75 minutes per task. Those timings describe that evaluation setup, not a general latency guarantee.
These results give me candidates for an evaluation, not a purchasing decision. The premium is useful only where the capability improvement survives contact with my workload.
Provider rates can change the arithmetic too
If I were already using a unified multi-model API, I would include CometAPI in the rate comparison: its listed Astra input, output, cache-read, and cache-write prices are 20% below the matching official rates.
| Context band | Input / 1M | Output / 1M | Cache read / 1M | Cache write / 1M |
|---|---|---|---|---|
| Short | $8.00 | $40.00 | $0.80 | $10.00 |
| Long | $16.00 | $60.00 | $1.60 | $20.00 |
For the same uncached token composition:
100K input + 10K output:
Official: 100K × $10/M + 10K × $50/M = $1.50
Provider: 100K × $8/M + 10K × $40/M = $1.20
Difference: $0.30/request; $3,000 across 10,000 equivalent requests
300K input + 20K output:
Official: 300K × $20/M + 20K × $75/M = $7.50
Provider: 300K × $16/M + 20K × $60/M = $6.00
Difference: $1.50/request
I would confirm current rates, billing rules, and exposed features before budgeting production traffic. A 20% token-category difference is not automatically a 20% reduction in an agent’s complete operating cost.
Use accepted results as the denominator
Consider two hypothetical agents:
| Agent | Cost per attempt | Success probability |
|---|---|---|
| A, cheaper model | $0.80 | 55% |
| B, Astra | $1.40 | 90% |
Assume independent attempts, unchanged cost and success probability on every retry, and retries continuing until success. Then:
Expected model cost per success = attempt cost / success probability
Agent A: $0.80 / 0.55 ≈ $1.45
Agent B: $1.40 / 0.90 ≈ $1.56
Using the exact ratios, B is about 6.9% more expensive, not cheaper. The point is that the cost-per-success difference is much smaller than the attempt-price difference.
This formula already includes repeated attempts; adding another retry allowance would double-count them. Tools, execution, and human review need separate measurement. Correlated failures can also make this simple model inappropriate.
For a real test, I would divide all model and tool spending across the test set by accepted results, then report correction time and unresolved failures separately.
My deployment checklist would be short:
- Watch input growth around 272K.
- Measure cache writes and hits rather than assuming reuse.
- Test Batch/Flex wherever immediacy is unnecessary.
- Route routine tasks to cheaper models.
- Compare full trajectories, not isolated calls.
An optimization that cuts tokens by 20% but increases failed runs can still make the system more expensive. I would pay Astra’s premium only where the measured cost of finishing the work justifies it.
Top comments (0)