Since November 17, 2026 the OpenAI API has two GPT-6.2 models: OpenAI points Astra at demanding reasoning and coding and Sol at everyday coding and agent workflows, with the same limits and tools on both. The release also changes when the Responses API keeps a model's reasoning between turns, so leaving the start of a conversation untouched now matters more.
A reasoning item is an output item in the Responses API that carries the model's reasoning state, so it can be passed into the next turn; the reasoning itself is not returned as ordinary readable text. The prompt prefix is the beginning of the rendered request (tool definitions, instructions and conversation items) that is identical to an earlier request. The prompt cache is the provider's store of processing already done on such a prefix, which a later request may read instead of redoing it.
What is new in GPT-6.2 Astra and Sol?
OpenAI added two reasoning models with the same limits and tools, per the API changelog entry of November 17, 2026 and the two model pages, checked on November 19, 2026.
| GPT-6.2 Astra | GPT-6.2 Sol | |
|---|---|---|
| Model id | gpt-6.2-astra |
gpt-6.2-sol |
| OpenAI's positioning | Demanding reasoning and coding | Everyday coding and agent workflows |
| Context window | 1,050,000 tokens | 1,050,000 tokens |
| Max input / output | 922,000 / 128,000 tokens | 922,000 / 128,000 tokens |
| Knowledge cutoff | May 18, 2026 | June 1, 2026 |
| Modalities | Text and image in, text out | Text and image in, text out |
| Endpoints | Responses, Chat Completions | Responses, Chat Completions |
The two pages list the same Responses API tools: web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search. The changelog adds one rule for anyone building agents on them: tool calls must go through the Responses API.

What happens to reasoning when you edit a GPT-6.2 conversation?
Edit an earlier turn and the Responses API stops carrying the reasoning items forward, according to the GPT-6.2 migration guide. The guide lists three triggers: an edit to earlier history, certain model changes including downgrades, and a change of end user or organization. After a drop, the model may spend more tokens redoing earlier work.
Take a code-review agent. Turn 1 sends a developer message with the review rules, then the diff; the model reasons, calls a tool and answers. In turn 2 the earlier reasoning can come along in two ways: the request points at the stored turn 1 response with previous_response_id, or your code sends the prior input and output items, reasoning items included, in their original order, followed by the new message. If your code later rebuilds the history with a typo fixed in the developer message, that is a prefix edit, and per the guide the turn 1 reasoning is dropped.
The prompt cache is a separate layer. It stores computed key-value states for the start of a request, while reasoning items are output items in the conversation. The caching guide says a request looks for the longest cached prefix, working back through eligible breakpoints, and a prefix is reusable only when the rendered content up to that point matches. So the typo fix ends reuse from the changed point; an earlier breakpoint stays eligible, which makes a hit possible but not guaranteed.
| Reasoning items | Prompt cache | |
|---|---|---|
| Kept when | Earlier history unchanged and passed along, no listed model, user or organization change | Rendered prefix matches up to an eligible breakpoint |
| After an earlier edit | Dropped | No reuse from the edit onward; an earlier breakpoint may still match |
| What you can read | The guides name no direct signal | usage.input_tokens_details.cached_tokens |
Treat the conversation as an append-only log: add new items at the end and leave old ones alone. When an edit is necessary, for example to remove a secret pasted by mistake, the guide's rule applies: the reasoning items are dropped, and cache reuse may still reach an earlier matching breakpoint.
The second change is placement. From GPT-6.2 on, top-level instructions are appended after input, outside the cacheable prefix. The guide says to put reusable instructions in a developer message as the first input item. We covered why repeated context needs processing every time in long context vs RAG.
How do you use GPT-6.2 Astra and Sol in the API?
Change the model id, use the Responses API for tools, and set a reasoning effort. The migration guide's steps:
- Set
modeltogpt-6.2-solorgpt-6.2-astra. - Use the Responses API if the call uses any tool.
- Set reasoning effort:
mediumfor a new integration,lowif you usednoneorminimal. The field isreasoning.effortin Responses andreasoning_effortin Chat Completions. - In Responses, omit
temperature,top_pandtop_logprobs, and removemessage.output_text.logprobsfrominclude. In Chat Completions, also omitlogprobs. - Move stable instructions into a first
developermessage. - Coming from GPT-5.5 or earlier, replace
prompt_cache_retentionwithprompt_cache_options.ttlset to"30m".
A first turn to POST /v1/responses:
{
"model": "gpt-6.2-sol",
"reasoning": { "effort": "medium" },
"tools": [{ "type": "web_search" }],
"input": [
{ "role": "developer", "content": "You review pull requests. Reply with a numbered list." },
{ "role": "user", "content": "Review this diff: <paste the diff>" }
]
}
The second turn continues from the stored response, so the earlier items, reasoning included, stay unchanged and in order:
{
"model": "gpt-6.2-sol",
"reasoning": { "effort": "medium" },
"tools": [{ "type": "web_search" }],
"previous_response_id": "<id from the first response>",
"input": [{ "role": "user", "content": "Now check the tests." }]
}
These short examples show continuation; they may not hit the cache. Per the caching guide, a reusable prefix needs at least 1,024 visible tokens on GPT-5.6 and later (checked November 19, 2026) and a matching cache entry must be available. Top-level instructions do not carry over through previous_response_id, according to the Responses API reference. Keep them in a developer message. cached_tokens measures cache reuse only, not whether reasoning items were kept.
GPT-6.2 Astra vs Sol: which should you try first?
Try Sol first for agent loops and routine coding, and Astra for the hard planning or debugging step, since that is how OpenAI positions them. Neither page says how they do on your work, so run both on 10 to 20 of your real requests. Because the guide says some model changes drop reasoning items, a fresh conversation for the Astra step can be the simpler design. Splitting work across separate contexts is the idea behind subagents.
What are the current API limits?
Both models take text and images and return text only, and reasoning cannot be switched off. Request and token rate limits depend on your account's usage tier and are listed on each model page.
- No audio or video input or output.
- The API rejects reasoning effort
none. - Chat Completions works, but without tool calling.
- The guide does not say which model changes, besides downgrades, drop reasoning items.
What changes for developers and everyone else?
Developers running multi-turn agents should append rather than edit where they can, move instructions into a developer message and track cached_tokens. Researchers testing what a model knows should note the two cutoffs. Students and makers can compare both models in the API by changing one field.
Sources: OpenAI API changelog entry of November 17, 2026, the GPT-6.2 Astra and Sol model pages, the GPT-6.2 migration guide, the prompt caching guide and the Responses API reference, all checked November 19, 2026. Statements about how OpenAI's systems keep reasoning and cache prompts are from those pages. Details can change after publication.
Top comments (0)