Skip to main content

GPT-6.2 Astra and Sol: prefix edits, pricing and migration

OpenAI released GPT-6.2 Astra and Sol on 17 November 2026. What changed in price and behaviour, why edited conversation history now costs reasoning, and the migration checks to run first.

Share -
Engineer in a dark teal-lit office studying a large monitor full of code and configuration panels while typing on a white keyboard

GPT-6.2 Astra and GPT-6.2 Sol are OpenAI's new Astra and Sol models, announced on 17 November 2026 for the API, ChatGPT Work and Codex. Astra's token rates drop, Sol keeps GPT-6.1 Sol's prices, and both now discard reasoning when an agent edits earlier conversation history, so check your integration before switching.

What OpenAI released

GPT-6.2 Astra and GPT-6.2 Sol were announced by OpenAI on 17 November 2026 in Introducing GPT-6.2 Astra and Sol. OpenAI's summary promises better professional outputs, coding, computer use and efficiency at lower cost across ChatGPT Work, Codex and the API.

The API changelog positions Astra for demanding reasoning and coding tasks and Sol for everyday coding and agent workflows. The model IDs are gpt-6.2-astra and gpt-6.2-sol, both on v1/responses and v1/chat/completions. The same day, GitHub made both generally available in Copilot.

What changed from GPT-6 Astra and GPT-6.1 Sol

Comparing the new GPT-6.2 Astra and GPT-6.2 Sol model pages with GPT-6 Astra and GPT-6.1 Sol:

  • Astra price: input, cached input, cache writes and output are all listed lower than GPT-6 Astra. Cached input falls the most, to less than half the old cached rate.
  • Sol price: unchanged. GPT-6.2 Sol lists the same input, cached input, cache write and output rates as GPT-6.1 Sol, so a Sol upgrade is a quality and behaviour decision, not a cost one.
  • Knowledge cutoff: 18 May 2026 for Astra and 1 June 2026 for Sol, up from 30 April 2026 on both predecessors.
  • Context and output: unchanged at 1,050,000 tokens of context, 922,000 maximum input tokens and 128,000 maximum output tokens. Input is text and images; output is text.
  • Reasoning effort: the API rejects none. The GPT-6.2 guide says to use low if you send none or minimal today, and to start new integrations at medium.
  • Multi-agent: both pages point to the Multi-agent beta in the Responses API for delegating work to subagents.

The change that can quietly raise your bill

The guide's headline change is behavioural. Starting with GPT-6.2, the API drops reasoning items when it detects a mid-conversation change to earlier history (a prefix edit), a model downgrade, or a change of end user or organisation. OpenAI warns that answer quality can decline and the model may use more tokens to repeat earlier work.

Many agent loops edit history without anyone noticing. The keep the prefix unchanged guide lists the usual causes: changing tools, instructions or text.format between calls, rewriting a developer message, shortening old tool results, or home-grown compaction that replaces older turns with a summary. Its fixes are append-only:

  • append a configuration_update item to change reasoning effort or the output schema, instead of changing the request parameter;
  • add tools with an additional_tools item, or restrict them per turn with allowed_tools;
  • append a new developer message rather than editing the original;
  • use OpenAI compaction, or place your own compacted item at the end of the context;
  • trim long tool outputs before they are first sent, not afterwards.

To find the edits, the response's input_transformations field shows which reasoning items the API removed and why, and Prompt Cache Diagnostics compare a request with an earlier response.

Where teams can use it

On the API, both models support streaming, Structured Outputs, function calling, web search, file search and prompt caching. Through the Responses API their tools include code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search. Fine-tuning and Predicted Outputs are not supported. Both support US and EU data residency for Standard, Fast and Batch processing; Ultrafast is US only, and the model pages note its rate rises on 1 March 2027.

The same changelog added discounted background completion windows in public beta: a two-hour or eight-hour window at lower token rates, for jobs nobody is waiting on.

In GitHub Copilot, both models are available to Pro+, Max, Business and Enterprise users in VS Code, Visual Studio, JetBrains IDEs, Xcode, Eclipse, Copilot CLI, the coding agent, the Copilot app, github.com and GitHub Mobile, with a gradual rollout. GitHub reports that in early testing both caught more real issues in code review than earlier GPT-6 models while using fewer tokens. They are billed at provider list pricing.

What it means for teams building agents

CodeDTX's view: the Astra price cut makes this an easy model to trial, but the reasoning-drop rule decides whether the trial is fair.

Cost. For an agent on GPT-6 Astra, the lower cached-input rate matters most when long system prompts and tool definitions are reused on every turn. That saving only appears if the prefix stays stable, so the same append-only work that preserves reasoning also protects your cache hits. Measure cost per completed task, as our guide to controlling AI agent running costs describes, because repeated reasoning can cancel a per-token saving.

Agent design. If your orchestration swaps tool lists between steps or rewrites the system prompt per stage, expect GPT-6.2 to behave worse than its predecessor until that is fixed. Our post on context engineering for AI agents goes further into managing what the model sees on each turn.

Fallbacks. Model downgrade is one of the listed triggers. If your agent falls back from Astra to Sol on errors or budget limits mid-conversation, the fallback turn loses Astra's reasoning. Fall back at the start of a task, not halfway through.

Copilot governance. GitHub says new models are enabled by default unless an administrator has turned off the global default or disabled these models. Check the Copilot model policy if your organisation reviews models first.

Choosing a tier. Our earlier comparison of GPT-6 Astra and GPT-6.1 Sol still describes the split: Astra for the hardest work, Sol for volume. GPT-6.1 Terra remains the cheaper step below for screen and image work.

Migration checklist

  1. Change the model name to gpt-6.2-astra or gpt-6.2-sol.
  2. Fix reasoning effort. Replace none or minimal with low; otherwise keep your current level for a like-for-like comparison.
  3. Move tool calls to Responses. Tool calling requires the Responses API, though plain Chat Completions requests still work.
  4. Strip unsupported parameters: temperature, top_p, logprobs and top_logprobs on Chat Completions; temperature, top_p and top_logprobs on Responses, plus message.output_text.logprobs in include.
  5. Update caching settings if you come from GPT-5.5 or earlier: replace prompt_cache_retention with prompt_cache_options.ttl set to "30m".
  6. Audit for prefix edits with input_transformations on a sample of real agent runs before rollout.
  7. Rerun your evals and compare quality, steps and tokens per task, using the set behind your AI agent evals. Revisit "be concise" instructions, since the guide says Astra is more concise and direct by default.
  8. Keep the old model behind a flag, and plan for the day a model is deprecated.

When not to switch yet

Wait if your agent framework edits conversation history and you cannot change it soon, since dropped reasoning can make GPT-6.2 cost more and answer worse than the model you run today. Wait too if you rely on temperature or logprobs, need fine-tuning, or need Ultrafast with EU data residency. And if you run GPT-6.1 Sol and are happy with it, there is no price reason to hurry: test the quality gain on your own tasks first.

Frequently asked questions

What are GPT-6.2 Astra and GPT-6.2 Sol?

They are OpenAI models announced on 17 November 2026, with the API names gpt-6.2-astra and gpt-6.2-sol. Astra is aimed at demanding reasoning and coding, and Sol at everyday coding and agent workflows. Both accept text and images, return text, have a 1,050,000-token context window and run on the Responses API and Chat Completions. They are also in ChatGPT Work, Codex and GitHub Copilot.

Is GPT-6.2 Astra cheaper than GPT-6 Astra?

Yes, per token. OpenAI's model pages list lower rates for GPT-6.2 Astra on input, cached input, cache writes and output, with cached input showing the largest cut. GPT-6.2 Sol keeps the same rates as GPT-6.1 Sol. Long prompts, Fast mode and repeated reasoning after prefix edits change the real cost, so measure cost per completed task on your own workload.

Why does editing conversation history matter with GPT-6.2?

From GPT-6.2, the API drops earlier reasoning items when it sees a change to earlier history, a model downgrade, or a different end user or organisation. The model may then repeat work, using more tokens, and answers can get worse. Change settings by appending configuration_update items, additional tools or new developer messages instead of editing earlier input, and check input_transformations to find edits.

Do I need to change code to move to GPT-6.2?

Usually a few small changes. Set the new model name, replace a reasoning effort of none or minimal with low, move tool calls to the Responses API, and remove temperature, top_p and logprobs parameters. Teams coming from GPT-5.5 or earlier also need the new prompt cache TTL setting. Then audit agent loops for prefix edits and rerun your evaluation set before switching traffic.

Share this post

Contact us to build the right product

Talk to our engineers about your application, the systems it connects to, and what you want to build next.

Get in touch
Two people discussing work with a laptop