GPT-6.2 Astra and Sol Shipped Nov 17. What Changes for Your Bot's Tool Calls?
OpenAI shipped GPT-6.2 Astra and GPT-6.2 Sol on November 17, 2026. For bot builders the headline isn't the benchmark chart — it's that tool calling still requires the Responses API, and a new prefix-edit rule can silently discard a conversation's stored reasoning, raising token use in multi-turn agent loops. Test in staging before swapping model IDs in production.
AI-assisted editorial: researched and drafted with AI using the primary sources linked below. Check the cited evidence and any stated test scope. Illustrative examples are not measured product results. Editorial policy.
Key takeaways
- GPT-6.2 Astra and Sol launched Nov 17, 2026; tool calling still requires the Responses API, not Chat Completions, and both models reject a reasoning effort of none.
- New in this release: editing earlier conversation turns, downgrading the model mid-session, or changing the end user can silently drop stored reasoning items, which can lower answer quality and raise token use.
- Before swapping a production model ID, audit for prefix edits, move stable instructions into a developer message for caching, and use a configuration_update item instead of editing settings mid-conversation.
What shipped on November 17
OpenAI released two new models, GPT-6.2 Astra and GPT-6.2 Sol, available in the API as gpt-6.2-astra and gpt-6.2-sol. Astra is positioned as OpenAI's most capable model for demanding, end-to-end work, while Sol is the everyday, lower-cost pick.
Both run in ChatGPT Work, Codex, and the API, accepting text and image input and returning text. In the Responses API, you can also hand work to subagents through the Multi-agent beta, and the API rejects any request that sets reasoning effort to none.
Sources: GPT-6.2 | ChatGPT Learn, GPT-6.2 Astra Model | OpenAI API.
Tool calling still needs the Responses API
If your bot calls tools, the endpoint choice has not changed with this release. OpenAI's migration guidance is explicit on this point: use the Responses API, because GPT-6.2 Astra and GPT-6.2 Sol support Chat Completions, but tool calling requires Responses.
On Responses, the documented tool set includes function calling for your own custom code, web search for internet data, and remote MCP servers for new capabilities, alongside file search and other hosted tools shown in the tools guide. If your current integration still routes tool calls through Chat Completions, that gap does not close with GPT-6.2 — you need to migrate the call shape, not just the model string.
Both models also reject a reasoning effort of none on either endpoint's reasoning parameter, and OpenAI's starting recommendation for a new integration is medium effort, or low if you were previously using none or minimal.
A common failure mode after swapping model IDs is a tool-calling bot built on Chat Completions that suddenly returns plain text instead of invoking functions, since Astra and Sol support Chat Completions but tool calling requires the Responses API. Operators typically catch this when their function-calling tests start failing silently or the API rejects a reasoning effort of none with an error. The practical recovery is to migrate the affected call paths to the Responses API, keep the documented function calling, web search, or remote MCP tool definitions intact, and set reasoning effort to low or medium rather than none.
Sources: Using GPT-6.2 | OpenAI API, Using tools | OpenAI API, Reasoning models | OpenAI API.
The change that bites agent loops: prefix edits drop reasoning
The behavior most likely to surprise an existing bot is new to this release. Starting with GPT-6.2, the Responses API drops reasoning items after mid-conversation edits to the conversation history, certain model changes including downgrades, or changes to the end user or organization. When the model loses access to reasoning items, answer quality can decline and the model may use more tokens to repeat earlier work, and OpenAI tells developers to review their integration for edits such as changes to earlier developer messages or tool calls.
Illustrative example: imagine a small-team support bot that runs a two-turn loop. Turn one sends a developer message with triage rules, then a ticket; the model reasons, calls a lookup tool, and drafts a reply. Before turn two, the bot's summarizer trims that tool's raw output to save tokens and rewrites it back into history. That edit touches the prefix the model reasoned over in turn one — under the new rule, the stored reasoning for that turn is dropped, and the model has to reconstruct its reasoning from scratch on the next call. The failure is quiet: no error, just a worse answer and a bigger bill on a call that looked like a routine cleanup step.
The documented fix is to keep the prefix unchanged when you change settings between responses, which preserves reasoning and keeps the earlier input eligible for prompt caching. If you need to change reasoning effort or output format mid-conversation, OpenAI's own usage guidance says to append a configuration_update item before the next user message and keep the request-level settings unchanged, since keeping earlier input intact helps preserve reasoning across turns and keeps that input eligible for caching.
Another concrete failure appears when an operator downgrades the model mid-session to cut cost, for example switching from Astra to Sol between turns for a cheaper reply. Because OpenAI documents that certain model changes including downgrades drop stored reasoning items, the operator notices the symptom as a sudden jump in response latency or token counts on the next turn, paired with a reply that re-derives context the model had already reasoned through. The recovery is to avoid swapping models inside a live conversation and instead start a fresh conversation, or hold the model constant and use a configuration_update item for any mid-session setting change.
Sources: Using GPT-6.2 | OpenAI API, GPT-6.2 | ChatGPT Learn.
Instructions placement changed too — check your cache hit rate
A second, smaller change affects any bot with a long-lived system prompt. Models starting with GPT-6.2 append top-level instructions after input in the Responses API, so to make reusable instructions eligible for prompt caching, you need to put them in a developer message as the first item in input instead of the top-level instructions field.
For a routine that runs the same system prompt hundreds of times a day, this is the difference between most of that prompt hitting the cache and most of it being billed as fresh input every call. It is easy to miss because a direct model-ID swap will still work — it just quietly stops caching what used to be cached.
A related failure surfaces only in billing or usage dashboards: a bot that migrated model IDs but left its system prompt in the top-level instructions field keeps functioning correctly but stops getting prompt-cache discounts, since GPT-6.2 appends top-level instructions after input. Operators typically detect this by noticing cached-token counts drop toward zero on calls that previously showed high cache hits, even though responses still look correct. The fix is to move the stable instructions into a developer message as the first item in input, restoring eligibility for caching without changing the model ID again.
Sources: Using GPT-6.2 | OpenAI API.
The decision: worth testing this week, not worth a blind swap
GPT-6.2 Astra and Sol are worth a staging test this week if your bot already uses the Responses API for tool calls — the model IDs are a drop-in field change, and the behavior differences are documented, not guessed at. They are not worth a same-day production swap if your bot edits conversation history mid-run, which is common in summarization, compaction, or tool-result trimming code.
Run this checklist before moving traffic:
- Confirm every tool-calling path uses the Responses API, not Chat Completions — Chat Completions still can't call tools on these models.
- Replace any reasoning effort of none or minimal with low or medium; both models reject none outright.
- Audit mid-conversation edits: rewriting a developer message, trimming a tool result, or summarizing old turns now drops stored reasoning items on GPT-6.2.
- Move stable system instructions into a developer message at the start of input, not the top-level instructions field, to keep prompt caching working.
- Use a configuration_update item when you need to change reasoning effort or output format mid-conversation instead of editing the same request's settings directly.
Sources: Using GPT-6.2 | OpenAI API, Reasoning models | OpenAI API.
Primary sources
Sources checked 2026-11-21. Standards and product documentation can change; follow the linked version when implementing.
- Using GPT-6.2 | OpenAI API — OpenAI
- Reasoning models | OpenAI API — OpenAI
- Using tools | OpenAI API — OpenAI
- GPT-6.2 Astra Model | OpenAI API — OpenAI
- GPT-6.2 | ChatGPT Learn — OpenAI
BotBento is in development. Suggest a correction.