GPT-6.2 Astra and Sol: The Cache Price Is the Story for Agents

OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, 2026 (announcement, release notes). Astra is the flagship for complex reasoning, Sol the everyday model. For an agent, the price line that matters most is cached input, because an agent spends most of its input tokens re-reading the same context on every turn.
Below we work out what the new prices do to one SRE investigation, the failure mode the write pricing creates, and when Sol beats Astra per solved task.
What Changed in the Price List
All prices are per million tokens, Standard tier, prompts up to 272K input tokens, from the OpenAI pricing page on 2026-11-18:
| Model | Input | Cached input | 30m cache write | Output |
|---|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $12.50 | $50.00 |
| GPT-6.2 Astra | $8.00 | $0.40 | $10.00 | $40.00 |
| GPT-6 Sol | $2.00 | $0.20 | $2.50 | $10.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $2.50 | $10.00 |
| GPT-6.2 Sol | $2.00 | $0.10 | $2.50 | $10.00 |
The pricing page lists no GPT-6.1 Astra, so the previous Astra is GPT-6 Astra. Against it, GPT-6.2 Astra is 20% cheaper on input and output, and cached input drops from $1.00 to $0.40, which is 60% cheaper. Sol 6.2 keeps the GPT-6.1 Sol price exactly.
The prompt caching guide explains the bigger cut: reads cost "0.05× on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Sol, and GPT-6.1 Terra", against 0.1× on most other models from GPT-5.6 on. Astra got the cheaper multiplier and a lower base price at once. Two more details change the math:
- Caching is on by default for supported models, with a 1,024-token minimum prefix.
- Writes replace the input rate, they are not a fee on top. Cache-write pricing "is not an additive fee: input tokens use the uncached-input, cached-input, or cache-write rate." A 30-minute write costs 1.25× the input rate and a 12-hour write costs 2.5×.
A Worked Example: One Incident Investigation
Take an agent that investigates one alert in 30 turns:
- A stable prefix of 20,000 tokens: system prompt, tool schemas, the runbook.
- Each turn adds 3,000 new tokens: tool output plus the model's previous reply.
- Each turn produces 1,000 output tokens, reasoning included.
- The cache works: every turn reads everything before the newest message and writes only the new part.
Over 30 turns that is 1.995M input tokens. Of them, 1.885M are cache reads and 110K are writes (the first 23K plus 3K per later turn). Output is 30K tokens. The largest prompt is 110K tokens, well under the 272K long-context line.
| Line | GPT-6 Astra | GPT-6.2 Astra | GPT-6 Sol | GPT-6.2 Sol |
|---|---|---|---|---|
| Cache reads (1.885M) | $1.89 | $0.75 | $0.38 | $0.19 |
| Cache writes (110K) | $1.38 | $1.10 | $0.28 | $0.28 |
| Output (30K) | $1.50 | $1.20 | $0.30 | $0.30 |
| Total | $4.76 | $3.05 | $0.95 | $0.76 |
GPT-6.2 Astra is 36% cheaper per investigation than GPT-6 Astra, not 20%. Of the $1.71 saved, $1.13 (two thirds) comes from the cache read line. The headline input and output cut delivers the rest.
On GPT-6.2 Astra, cache reads are now only a quarter of the bill. Writes and output are the big lines, so the next saving comes from fewer new tokens: shorter tool output, trimmed log excerpts, fewer turns. We covered those levers in where AI agent tokens go.
SRE Bench, our benchmark of real production incidents, points the same way: GPT-6.2 Astra costs $0.35 per identified root cause against $0.70 for GPT-6 Astra. The GPT-6 Astra figure is a cache-corrected estimate, so read the ratio as rough. OpenAI reports that on Agents' Last Exam, 6.2 Astra beats GPT-6 Astra "at less than half the cost per task", a vendor result, not an independent one.
The Failure Mode: A Broken Cache Now Costs More Than No Cache
Because writes cost 1.25× input, a miss is not neutral. If the prefix changes on every turn, every token becomes a write. GPT-6.2 Astra then costs about $21.15 per investigation (1.995M tokens at $10 plus output): seven times the cached price, and 23% more than the plain $8 input rate with no cache at all.
"Cache reuse requires the entire rendered prefix to match." The guide lists the settings that affect the cached prefix: the model, tools (names, descriptions, schemas, order), parallel_tool_calls, text.format, reasoning.effort, text.verbosity and context_management. Compaction "can prevent reuse from the first changed token onward". The usual culprits in SRE agents are a timestamp or alert ID in the system prompt, a tool list that changes when an MCP server reconnects, and an aggressive compaction loop (see context rot and compaction).
30 Minutes or 12 Hours
An on-call agent often sits idle between alerts. The default cache lives at least 30 minutes, and a read refreshes it. The 12-hour lifetime (prompt_cache_options.ttl: "12h" in the Responses API) costs 2.5× input to write.
For the 20K stable prefix on GPT-6.2 Astra:
- 30m write on every cold start: 20K × $10 = $0.20 per investigation.
- One 12h write: 20K × $20 = $0.40, then reads at 20K × $0.40 = $0.008 each.
Two cold starts in 12 hours is a tie. From the third, 12 hours wins. If alerts arrive every few minutes, the 30-minute cache stays warm and the longer lifetime only adds cost. OpenAI may keep entries longer than the minimum, so these are worst-case numbers.
Sol or Astra per Solved Task
In the example, Astra costs four times as much as Sol. Counting tokens only, Sol wins unless its success rate falls below a quarter of Astra's. But a failed investigation also sends the alert to an engineer.
Say a failed run costs $50 of engineer time (an assumption, use your own number). With hypothetical success rates of 85% for Sol and 95% for Astra:
- Sol: $0.76 + 0.15 × $50 = $8.26 per alert
- Astra: $3.05 + 0.05 × $50 = $5.55 per alert
Once failures are expensive, the more reliable model wins. On our SRE Bench tasks both models scored 100% on root cause, so Sol is cheaper there: $0.10 per identified root cause and a 48 second median, against $0.35 and 64 seconds for Astra. Measure on your own incidents before you route.
| Job | Model | Why |
|---|---|---|
| Alert triage, grouping, short summaries | GPT-6.2 Sol | Same price as 6.1 Sol, short context, failure is cheap |
| Routine investigation with known runbooks | GPT-6.2 Sol | 4× cheaper per run, check the success rate on your incidents |
| Novel or multi-system incidents | GPT-6.2 Astra | The cost of a miss is engineer time, not tokens |
| Latency-critical triage | GPT-6.2 Sol on Ultrafast | About 3× Sol cost until February 28, 2027 |
| Postmortem drafts | Either, on Batch | Batch is half the Standard price |
What Ultrafast Changes
The speed docs say that on both GPT-6.2 models, Ultrafast "generates tokens at up to 4.5 times the speed of Standard on the same model". In the API, the pricing page says "Ultrafast costs 3 times the Standard rate through February 28, 2027", and 6 times Standard from March 1, 2027. At the promotional rate (Sol: $6 input, $0.30 cached, $30 output), and if writes scale the same way, our investigation costs about $2.29 on Sol Ultrafast, still below Astra on Standard. After March 1, about $4.58.
For ChatGPT subscribers, the release notes say "Pro $200 subscribers can use Ultrafast with Sol. Pro $500 subscribers can use it with either model." On ChatGPT plans, Ultrafast on these models draws 6× the included usage (pricing). So the $200 plan gets faster Sol answers, and the allowance drains about six times faster while Ultrafast is on. It supports US data residency only.
Migration Checklist for Agent Builders
- Log cache reads and writes per request. Alert when writes rise above a few percent of input tokens.
- Keep the prefix byte-stable. No timestamps or IDs in the system prompt, a fixed tool order, and tools loaded before the first turn.
- Change reasoning effort without breaking the cache. The guide recommends appending a
configuration_updateinput item instead of editing the top-levelreasoning.effort. - Use the Responses API. The migration guide says tool calling on these models requires it. It also recommends moving stable instructions into a
developermessage, so expect one full cache rewrite on the first run. - Stay under 272K input tokens. Above that line, input and cached rates double.
- Pick the cache lifetime from your alert rate. Use 12h when two or more cold starts happen in 12 hours.
In Akmatori, you choose the model in Settings → AI models, and you can type a model name that is not in the list yet (getting started). Run a few investigations on your own alerts before you switch the default.
Conclusion
For agents, GPT-6.2 Astra is a bigger cut than the 20% headline, because agents mostly pay for cached reads and that line fell 60%. Sol 6.2 keeps the 6.1 Sol price. The new risk is the write price: a prefix that changes every turn costs more than no cache at all. Check your cache hit ratio before you trust any per-token comparison.
If your team wants AI-assisted incident workflows on your own infrastructure, Akmatori helps SRE teams investigate alerts, coordinate response, and automate safe infrastructure actions. Powered by Gcore for global infrastructure reliability.
