GPT-6.2 Astra and Sol in the API: the tool calling rule is old, the billing traps are new
The Responses API requirement reads like the headline change, and it predates this release. Two changes reach an existing agent without a documented error: one field stops caching, and edited history loses its reasoning. The new background windows still cost more than Batch.
Contents
OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, and its API changelog says tool calling on both requires the Responses API. That reads like the breaking change. The rule is older, though: OpenAI’s reasoning guide says the same of GPT-6 Astra and GPT-6.1 Sol.
If you already moved for those models, the changes that reach your code are elsewhere. Two of them come with no documented error, so the first place you may notice them is the bill.
What did OpenAI ship with GPT-6.2 Astra and Sol?
Two models and a cheaper way to wait. gpt-6.2-astra targets demanding reasoning and coding, gpt-6.2-sol everyday coding and agent work. The same day, the Responses API gained two-hour and eight-hour background windows in public beta.
| Standard, up to 272K input, per 1M tokens | Input | Cached input | 30-minute cache write | Output |
|---|---|---|---|---|
| GPT-6.2 Astra | $8 | $0.40 | $10 | $40 |
| GPT-6.2 Sol | $2 | $0.10 | $2.50 | $10 |
| GPT-6 Astra, for comparison | $10 | $1 | $12.50 | $50 |
Per OpenAI’s pricing, Astra is 20% cheaper on input and output and 60% cheaper on cache reads, which is the number a long agent session feels. Sol keeps GPT-6.1 Sol’s Standard rates. Above 272K input tokens, the same line GPT-6 Luna has applies: input and cache rates double and output costs 1.5x, for the whole request.
Does GPT-6.2 tool calling work in Chat Completions?
No. The GPT-6.2 guide says both models support Chat Completions, but tool calling requires Responses. Two older lines fit that. The migration guide says that since GPT-5.4, Chat Completions supports tool calling only with reasoning_effort set to none, and the reasoning guide says GPT-6.2 rejects none. So if you run tools on Chat Completions with GPT-5.4 or later, my reading is that you are on none today, and neither half of that setup survives the move. The docs don’t name the error, so test it.
Moving means rewriting the tool loop. name, description and parameters leave the nested function object, function calls come back as function_call items, and results go back as function_call_output with the matching call_id, alongside any reasoning items if you manage state yourself. Omit strict and Responses attempts strict mode, falling back to non-strict if the schema can’t comply. response_format becomes text.format, and reasoning_effort becomes reasoning.effort. Drop temperature, top_p, logprobs and top_logprobs, and take message. out of include. If you were on none or minimal, OpenAI says to use low.
How do GPT-6.2’s instructions and prefix changes affect cost?
Top-level instructions no longer cache. From GPT-6.2 they are appended after input and billed at the uncached rate on every request, even on a cache hit. Reusable instructions belong in a developer message at the start of input.
Take 5,000 tokens of instructions over 100 turns on Astra. As top-level instructions they cost $4.00. In a developer message that the 99 later requests match as a cached prefix, they cost one write ($0.05) plus 99 reads (about $0.20).
The Responses API also now drops reasoning items that follow an edit to earlier history, and OpenAI’s examples are ordinary agent housekeeping: shortening a tool result, rewriting a developer message, replacing older turns with a summary. Changing the tools parameter can do it too. Two exits exist. Deleting whole items without editing the rest doesn’t by itself trigger the removal, and OpenAI’s own compaction keeps later reasoning. Otherwise the model may redo work and answers may get worse, and the same edit can cut cache reuse from that point on.
Claude Fable 5.2, by default and outside Message Batches, answers a replayed thinking block after such an edit with a 400, which I called the honest answer. OpenAI documents a removal instead, reported in input_transformations as prefix_mismatch. My read is that the quiet version costs more to discover. I’d log that field from the first day.
When do GPT-6.2 background windows beat the Batch API?
When you need the first result sooner than Batch’s 24 hours, or the work has several steps. For independent requests that can wait, Batch is still cheaper, at 50% off against 30% for 2h and 40% for 8h. One request with 200K uncached input tokens and 20K output tokens, reasoning included, by my arithmetic:
| Route | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Standard | $2.40 | $0.60 |
Background 2h | $1.68 | $0.42 |
Background 8h | $1.44 | $0.36 |
| Batch | $1.20 | $0.30 |
What the windows add is a loop. A response can ask for a tool, your code runs it when the webhook fires, and the follow-up gets the same discount. A single overnight review looks like this:
{
"model": "gpt-6.2-sol",
"input": "<contract text> List any missing approvals.",
"background": true,
"service_tier": "default",
"background_options": { "completion_window": "8h" }
}For a loop, add continuation_id to background_options and reuse it, with the same model, window and project, for queue priority. It doesn’t carry history; previous_response_id or replayed items do that.
The guide’s small print matters. The window is a target for the initial response, and follow-up start times depend on scheduling, so 8h doesn’t promise an eight-hour run. 2h and 8h requests can’t stream. Their queued input tokens count against the limit they share with Batch jobs. Cache entries they create can’t be reused by Standard requests. And background mode stores data temporarily even with store: false or Zero Data Retention.
How far can you trust the GPT-6.2 Astra launch numbers?
As OpenAI’s own numbers, for now. On Agents’ Last Exam, the launch post puts Astra 5.5 points ahead of Claude Fable 5.2 at 5% of the cost, with a footnote that Fable’s results exclude nine tasks that used a fallback model. Both list at $8 and $40, so the rate card doesn’t explain a 20x gap, and the post gives no breakdown. Simon Willison reports that Astra trails Fable 5.2 on various benchmarks.
For anyone running agents, the behavior notes matter more than the leaderboard. Willison relays Theo Browne’s pre-release report of a long /goal task blocked on an obscure implementation question, and OpenAI’s guide says the model may wait for confirmation when intent is unclear. OpenAI also says both models were more likely, in two tests, to omit obstacles that blocked their work, such as a missing file. Its fix lives in Codex, and the system card is explicit about the boundary:
The Codex developer prompt used in these evaluations is not applied to
direct API requests.If you call the API from your own harness, write a blocker-reporting instruction and test it.
Should you switch a working integration to GPT-6.2?
From GPT-6 Astra, the price is a reason on its own. From GPT-6.1 Sol the Standard rates didn’t move, so you’d be switching for the model. Either way, change the prompt structure first: reusable instructions in the first developer message, history that only grows, input_transformations in your logs. Then change model. Astra’s cheaper cache reads only pay on a prefix that survives.
01 / Discussion
No comment section here — all discussions happen on X.
02 / More articles
Migrating to Claude Fable 5.2: change the tools first, then the model
The advisor and the computer use tool both live in tools, and changing tools mid-conversation breaks preserved thinking. Do both while you still run the old model, and the switch to Claude Fable 5.2 becomes one field you can flip back.
Claude Fable 5.2's prefix check: a 400 that depends on what your code did last turn
The check that rejects replayed reasoning after an edited history now applies to every account. Code that keeps its history append-only never meets it, and code that doesn't won't find out from a single test request. The fix is in the error message; the hard part is producing the error before production does.
Claude Opus 4.8 fast mode ends November 30: Opus 5.5 is cheaper per token, not always per request
The replacement costs 20% less per token and 60% less on cache reads. It also thinks on every request and bills that thinking as output, and its speed gain is in throughput, not in time to first token. Whether the move saves money depends on how much each request writes, and on what your error handler does when the fast rate limit runs out.