OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on 17 November 2026, and both are already live in the API as gpt-6.2-astra and gpt-6.2-sol. Astra is the new frontier model for hard reasoning and coding work. Sol is the cheaper, everyday model for coding and agent workflows. If you already call GPT-6 or GPT-6.1 from Python, switching is mostly a model-name change, but two behaviour changes in the Responses API can quietly hurt quality and caching if you ignore them.
This guide walks through the first call, picking a model, the new rules for instructions and conversation history, and a short migration checklist. Everything here comes from OpenAI’s Using GPT-6.2 guide, the API changelog and the launch post.
Astra or Sol: which one should you use?
| GPT-6.2 Astra | GPT-6.2 Sol | |
|---|---|---|
| Model ID | gpt-6.2-astra |
gpt-6.2-sol |
| Best for | Hardest reasoning, coding and long projects | Everyday coding, agents, high volume |
| Input (per 1M tokens) | $8 | $2 |
| Cached input (per 1M) | $0.40 | $0.10 |
| Output (per 1M) | $40 | $10 |
OpenAI says Astra’s input and output prices are 20% lower than GPT-6 Astra, with a 60% discount on cached input. Sol keeps GPT-6.1 Sol’s prices. Both support the Responses API and Chat Completions, but tool calling requires the Responses API.
A sensible default: build on Sol, and route only the hard tasks (large refactors, tricky debugging, deep analysis) to Astra.
Step 1: Install the SDK and make a first call
pip install -U openai
export OPENAI_API_KEY="sk-..."
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY
response = client.responses.create(
model="gpt-6.2-sol",
reasoning={"effort": "medium"},
input=[
{"role": "developer", "content": "You are a senior Python reviewer. Answer briefly."},
{"role": "user", "content": "Is it safe to use a mutable default argument in a function?"},
],
)
print(response.output_text)
OpenAI recommends starting new integrations at medium reasoning effort. If your current code uses none or minimal, switch to low for GPT-6.2.
Step 2: Move reusable instructions into a developer message
This is the change most likely to catch you out. Starting with GPT-6.2, the Responses API appends the top-level instructions field after input. Because prompt caching works on matching prefixes, a long system prompt passed through instructions is no longer at the start of the request, so it stops being reused from cache.
The fix is simple. Put stable, reusable instructions in a developer message as the first item of input, and keep instructions only for guidance that applies to this one request.
SYSTEM_PROMPT = open("prompts/reviewer.md").read() # long and stable
def review(code: str, extra_note: str | None = None):
return client.responses.create(
model="gpt-6.2-sol",
reasoning={"effort": "medium"},
input=[
{"role": "developer", "content": SYSTEM_PROMPT}, # cacheable prefix
{"role": "user", "content": f"Review this code:\n\n{code}"},
],
instructions=extra_note, # per-request only, e.g. "Focus on security."
)
Keep the developer message byte-for-byte identical across calls. Even small changes, such as inserting today’s date at the top, break the shared prefix.
Step 3: Do not edit the conversation prefix
The second change is about reasoning items. In multi-turn conversations, GPT-6.2 keeps its earlier reasoning so it does not have to redo work. The Responses API now drops those reasoning items when you:
- edit an earlier part of the conversation (a “prefix edit”), such as rewriting an old developer message or tool call,
- change models in certain ways, including downgrades,
- change the end user or organization.
When reasoning is dropped, OpenAI warns that answer quality can decline and the model may spend more tokens repeating earlier work. The rule is: append, do not rewrite.
history = [
{"role": "developer", "content": SYSTEM_PROMPT},
{"role": "user", "content": "Plan a migration from Flask to FastAPI for our app."},
]
first = client.responses.create(model="gpt-6.2-sol", input=history)
# Append the model's output items, then the next user turn.
history += first.output
history.append({"role": "user", "content": "Now write step 1 in detail."})
second = client.responses.create(model="gpt-6.2-sol", input=history)
print(second.output_text)
If you need to change a setting between turns, change it on the new request rather than by rewriting older messages. If your app trims or summarises old messages to save tokens, test whether that is still worth it, because every trim is a prefix edit.
Step 4: Remove parameters GPT-6.2 does not accept
When migrating, strip these from your requests:
- Chat Completions:
temperature,top_p,logprobs,top_logprobs. - Responses:
temperature,top_p,top_logprobs, and removemessage.output_text.logprobsfrominclude.
Reasoning effort is set with reasoning.effort in Responses and reasoning_effort in Chat Completions:
chat = client.chat.completions.create(
model="gpt-6.2-sol",
reasoning_effort="low",
messages=[{"role": "user", "content": "Summarise PEP 8 in five bullets."}],
)
print(chat.choices[0].message.content)
If you are coming from GPT-5.5 or earlier, also replace prompt_cache_retention with prompt_cache_options.ttl set to "30m".
Step 5: Tune prompts for the new behaviour
OpenAI’s guide lists a few behaviour differences worth knowing before you ship:
- Shorter answers by default. Astra writes more concisely and directly. If your system prompt says “be concise”, it may now be too terse. Remove or soften it and check the output.
- It may pause on unclear tasks. When intent is unclear, the model may propose a next step and wait. For agent-style work, tell it which decisions it can make on its own and which need the user.
- Describe your coding conventions. The model writes efficient code, but you still need to say when to reuse existing helpers, how narrow a change should be and when tests are expected.
- Frontend look. If a UI needs a specific style, name the typography and imagery explicitly.
Cheaper background jobs
The same changelog entry adds a public beta of two-hour and eight-hour background completion windows in the Responses API for GPT-6.2 and some other models. OpenAI lists token rates 30% below Standard for the two-hour window and 40% below for the eight-hour window. For nightly reports, bulk classification or code review backlogs that do not need instant answers, this is worth testing. Check the changelog for the exact request options before using it in production.
Migration checklist
- Change
modeltogpt-6.2-sol(orgpt-6.2-astrafor hard tasks). - Set reasoning effort to
medium; replacenone/minimalwithlow. - Use the Responses API for anything that calls tools.
- Move long, stable instructions from
instructionsinto a firstdevelopermessage. - Stop editing earlier turns; append new items instead.
- Remove
temperature,top_pand logprob options. - Replace
prompt_cache_retentionwithprompt_cache_options.ttlif you used it. - Re-test prompts that ask for brevity or that expect the model never to pause.
Takeaway
GPT-6.2 Sol is the easy upgrade for most apps, and Astra is there for the hard cases. The model swap takes a minute, but the real work is in two small rules: keep reusable instructions at the very start of input, and never rewrite conversation history. Get those right and you keep both answer quality and cache savings.
