GPT-6.2 Astra and Sol Arrive: API Changes, Pricing, Prompt Caching and Migration Guide (November 2026)
Updated: November 18, 2026 · Release date: November 17, 2026
OpenAI's latest model release is not just a pair of new model IDs. GPT-6.2 Astra and GPT-6.2 Sol arrive with a developer-facing change that can affect the correctness and cost of an existing agent: the Responses API now drops reasoning items after certain edits to earlier conversation history. If your application rewrites old developer messages, changes tool definitions in place, or truncates earlier tool results, a seemingly harmless prompt update can make the model repeat work, spend more tokens, or lose useful context.
This guide explains what OpenAI announced, how Astra and Sol differ, what the published API prices mean, and how to migrate an existing Python integration without accidentally breaking tool calling or prompt-cache reuse. Release details below are current as of November 18, 2026.
Who should read this?
- Developers maintaining applications on the GPT-6 API or Responses API.
- Teams building coding assistants, support agents, research workflows, or multi-step tool-using systems.
- Backend engineers who need to estimate token costs and preserve conversation state across requests.
- Product teams deciding whether a workload belongs on Astra or the lower-priced Sol model.
1. What OpenAI released on November 17
OpenAI introduced two hosted models:
- GPT-6.2 Astra (
gpt-6.2-astra): positioned by OpenAI for demanding reasoning, coding, computer-use, and professional-work tasks. - GPT-6.2 Sol (
gpt-6.2-sol): positioned for everyday coding and agent workflows where a lower per-token price matters.
The official API changelog records both model IDs on November 17, 2026. Both are available through the Responses API and Chat Completions. The important qualification is that tool calling requires the Responses API; a Chat Completions integration can still be used for supported text/image exchanges, but it is not the route for these models' function-tool workflow.
OpenAI also says the models are available in ChatGPT Work and Codex for eligible Plus, Pro, Enterprise, and Edu users. API availability is separate from a ChatGPT subscription: developers still need an API project with billing and access configured.
2. Astra vs Sol: which model should you start with?
| Area | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| API model ID | gpt-6.2-astra | gpt-6.2-sol |
| OpenAI's positioning | Hardest reasoning and coding tasks | Everyday coding and agents at lower cost |
| Context window | 1,050,000 tokens | 1,050,000 tokens |
| Maximum input | 922,000 tokens | 922,000 tokens |
| Maximum output | 128,000 tokens | 128,000 tokens |
| Knowledge cutoff shown in model docs | May 18, 2026 | June 1, 2026 |
| Standard input price / 1M tokens | $8.00 | $2.00 |
| Standard cached input / 1M tokens | $0.40 | $0.10 |
| Standard output / 1M tokens | $40.00 | $10.00 |
Both model pages list text and image input with text output. Neither page lists audio or video input support. The models are API-hosted services, not downloadable GGUF or MLX weights for Ollama or LM Studio.
Practical starting point: begin with Sol for high-volume application traffic, routine code explanations, drafting, and straightforward tool workflows. Test Astra on the subset that genuinely needs deeper debugging, architecture decisions, or long multi-step work. Do not assume Astra is automatically better for every request; route by task type and evaluate on your own data.
3. Understand the price table before switching
OpenAI's published Standard rates per one million tokens are:
| Charge | Astra | Sol |
|---|---|---|
| Input | $8.00 | $2.00 |
| Cached input | $0.40 | $0.10 |
| 30-minute cache write | $10.00 | $2.50 |
| 12-hour cache write | $20.00 | $5.00 |
| Output | $40.00 | $10.00 |
At Standard rates, Astra is four times Sol's listed input and output price. Cached reads are also four times the Sol rate. This is a price comparison, not a claim that one model produces four times the quality.
Long-context pricing matters
The model pages state that requests with more than 272,000 input tokens use higher rates for the full request: input and cached-input rates double, while output costs 1.5 times the short-context rate. A request just over the threshold can therefore cost materially more than a shorter request. Measure the complete request, including cached history and tool output, rather than budgeting only for the latest user message.
Other processing tiers
The pricing page also lists Batch, Fast, background completion windows, and Ultrafast. For GPT-6.2, the published Ultrafast multiplier is three times Standard through February 28, 2027, then six times Standard from March 1, 2027 (Pacific time). Availability and regional processing differ by tier; the model guide lists Ultrafast as US-residency only, while Standard, Fast, and Batch support US and EU data residency. Check the live pricing page before quoting a customer or hard-coding a rate.
4. The most important API behavior change: prefix edits
In earlier agent integrations, teams sometimes modified an earlier message before sending the next turn—for example, replacing a developer instruction, shortening a previous tool result, or swapping the tool list. Starting with GPT-6.2, OpenAI says the Responses API drops reasoning items that follow certain mid-conversation prefix edits. The documentation also calls out certain model changes (including downgrades) and changes to the end user or organization.
When those reasoning items are removed, the model may have to repeat work. OpenAI warns that this can increase token usage and latency and may reduce answer quality if the missing reasoning cannot be recovered. Prefix changes can also reduce prompt-cache reuse.
Use an append-oriented conversation history
- Keep the original developer message and earlier input items unchanged.
- Append new user messages, tool results, and new developer instructions instead of rewriting old items.
- Keep tool definitions in a stable order across turns.
- When changing reasoning effort or output schema, review the documented
configuration_updateinput item instead of changing the earlier request prefix. - When adding tools, review the documented
additional_toolspattern; usetool_choiceandallowed_toolswhen restricting tools for a turn. - Use the official compaction flow when appropriate. A custom summary inserted in the middle of prior history changes the prefix and can discard later reasoning items.
For a long-running agent, this is an architecture concern, not merely a prompt-writing tip. Treat the conversation as an append-only event log where possible. If you must edit history, do it deliberately and test the effect on quality, latency, and cache usage.
5. A second migration change: where reusable instructions belong
GPT-6.2 changes how the Responses API handles the top-level instructions field: the API appends those instructions after input. If your instructions are stable across requests, put them in a developer message at the beginning of the input array. That makes the reusable prefix eligible for prompt caching. Reserve top-level instructions for guidance that applies only to the current request.
For example, a stable application policy belongs in the first developer item. If the user later asks for a different output format, append a new developer message describing that turn's change rather than editing the first developer message in place.
6. Make a first GPT-6.2 API request with Python
Prerequisites
- Python 3.10 or newer for the current OpenAI Python SDK.
- An OpenAI API project and an API key with billing configured.
- The official OpenAI Python SDK.
Step 1 — Install the SDK
python -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade openai
On Windows PowerShell, activate the environment with .venv\Scripts\Activate.ps1.
Step 2 — Set the API key outside your source code
export OPENAI_API_KEY="your_api_key"
Use your platform's secret manager or environment configuration in production. Do not commit the key to Git, paste it into frontend JavaScript, or expose it in logs.
Step 3 — Call Sol first
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6.2-sol",
reasoning={"effort": "medium"},
input=[
{
"role": "developer",
"content": (
"You are a backend engineering assistant. "
"Explain assumptions and flag unsafe changes."
),
},
{
"role": "user",
"content": (
"Review this Django endpoint design for pagination, "
"authorization, and database-query risks."
),
},
],
)
print(response.output_text)
The example uses a stable developer message as the first input item and a supported reasoning effort. Change the model ID to gpt-6.2-astra to test Astra against the same prompt and workload. The expected result is a text response in response.output_text; actual quality, token use, and latency depend on the request and account limits.
Step 4 — Add tool calling through Responses
If your application needs a function such as looking up an order or checking a deployment, define a narrow JSON-schema tool and use the Responses API. Your server—not the model—must execute the function after validating its arguments. Do not give the model unrestricted database, shell, or filesystem access merely because it can call tools.
tools = [{
"type": "function",
"name": "get_deployment_status",
"description": "Return the status of one deployment by its public ID.",
"parameters": {
"type": "object",
"properties": {
"deployment_id": {"type": "string"}
},
"required": ["deployment_id"],
"additionalProperties": False
},
"strict": True
}]
response = client.responses.create(
model="gpt-6.2-sol",
reasoning={"effort": "medium"},
input="Check deployment deploy_123.",
tools=tools,
)
This snippet demonstrates tool declaration only. A production tool loop must inspect returned function-call items, validate the arguments again on the server, enforce user authorization, execute the function, and send the matching tool output back to the Responses API. Consult the official function-calling guide for the full cycle.
7. Migration checklist for an existing GPT integration
- Pin the model ID. Choose
gpt-6.2-astraorgpt-6.2-solexplicitly. Avoid silently changing a production model alias without an evaluation. - Move tool workflows to Responses. Both models support Chat Completions, but tool calling requires Responses.
- Remove unsupported sampling parameters. For Chat Completions, omit
temperature,top_p,logprobs, andtop_logprobs. For Responses, omittemperature,top_p, andtop_logprobs; also removemessage.output_text.logprobsfrominclude. - Review reasoning effort. Start a new integration at
medium. If an old integration usesnoneorminimal, move tolowand compare. GPT-6.2 rejectsnone. - Move stable instructions. Put reusable developer guidance in the first developer message inside
input. Use top-levelinstructionsonly for turn-specific guidance. - Preserve the prefix. Stop rewriting previous turns, tool results, or initial developer instructions. Append updates and keep tool order stable.
- Update prompt-cache settings. When migrating from GPT-5.5 or earlier, OpenAI's guide says to replace
prompt_cache_retentionwithprompt_cache_options.ttl, for example"30m". Recheck cache-write billing. - Review manual conversation state. For approved organizations using Zero Data Retention on eligible endpoints, the Responses API treats
storeasfalse. If you manage multi-turn state yourself, replay prior output items in order, including encrypted reasoning items where required. - Run regression tests. Compare representative coding, tool-use, long-context, and failure-recovery tasks on the old and new model IDs before shifting production traffic.
8. What OpenAI says about capability and safety
OpenAI describes Astra as its model for the hardest projects and Sol as the lower-cost everyday option. Its launch announcement reports improvements on internal and third-party evaluations, including coding and long-horizon professional-work tests. Treat those numbers as attributed results: benchmark setup, reasoning effort, scaffolding, fallback rules, and pricing assumptions affect comparisons. They are not a substitute for testing your own workload.
OpenAI's November 17 system card says both models meet its Critical threshold for cybersecurity capabilities and High threshold for biological and chemical capabilities. It says Astra meets the High threshold for AI self-improvement, while Sol does not. These are OpenAI's Preparedness Framework assessments, not independent certifications. The company also describes tighter safeguards for higher-risk cybersecurity assistance and additional vetting for more permissive access.
For developers, the practical takeaway is to use least-privilege tools, isolate code execution, require human approval for consequential actions, and log the tool inputs and outputs needed for an audit. Do not treat model capability or provider-side safeguards as a replacement for application authorization.
9. Troubleshooting common migration issues
HTTP 400 after setting reasoning effort
Check whether the request sets none. GPT-6.2 Astra and Sol reject that value. Start with low or medium and confirm the correct field for the endpoint: reasoning.effort in Responses or reasoning_effort in Chat Completions.
Tool calls are not available
Confirm that the application uses /v1/responses. The changelog says tool calling requires the Responses API for these models.
Requests fail after changing temperature or top_p
Remove the unsupported sampling parameters listed in the migration guide. Do not blindly pass a legacy parameter dictionary to the new model.
Agent repeats work after a prompt update
Inspect whether the integration rewrote an earlier input item, developer message, tool definition, user identity, or organization setting. Preserve the prefix and append updates. Use Prompt Cache Diagnostics and the response's input_transformations information to investigate cache misses and reasoning-item removals.
Token costs rise unexpectedly
Check whether requests crossed the 272,000-input-token pricing threshold, whether cache hits were lost after prefix edits, and whether a higher reasoning effort or processing tier is being used. Record input, cached input, cache writes, output, and service tier separately.
Multi-turn behavior changes when storage is disabled
Review the Zero Data Retention rules for your organization and endpoint. If your application manually manages state, preserve and replay the required output items in their original order rather than storing only the visible text answer.
10. Security, privacy, and production guidance
- Protect credentials: keep API keys on the server, rotate them, and scope project access.
- Minimize data: send only the context required for the task. A one-million-token context window is not a reason to upload an entire database.
- Authorize every tool call: validate user identity, tenant, resource ownership, and arguments on the backend.
- Sandbox execution: run generated code in an isolated environment with bounded CPU, memory, network, and filesystem access.
- Keep humans in the loop: require approval for deployments, payments, destructive database operations, security changes, and customer-visible actions.
- Check retention and residency: confirm the actual endpoint, ZDR eligibility, data-residency region, and service tier for your organization. Do not infer these from the model name.
- Audit model changes: store the model ID, prompt version, tool schema version, request ID, token usage, and evaluation result without logging secrets or unnecessary personal data.
11. What developers should test before switching
Build a small evaluation set from real, sanitized application cases. Include at least:
- A normal short request and a long-context request below and above 272,000 input tokens.
- A coding task with a known expected patch and test result.
- A multi-turn agent that appends tool results without rewriting prior history.
- A test that intentionally changes an earlier developer message so you can observe the documented prefix behavior.
- A function call with valid arguments, invalid arguments, and a user who lacks permission.
- A retry, timeout, and partial-failure scenario.
Measure task success, human correction rate, latency, total tokens, cached-token ratio, and cost per completed task. Run Astra and Sol on the same sanitized cases and compare the result that matters to your product. Do not compare only tokens per second or a single benchmark score.
12. Frequently asked questions
Are GPT-6.2 Astra and Sol open-weight models?
No downloadable model weights are listed in the official model documentation. They are accessed through OpenAI's hosted products and API.
Can I use Chat Completions?
Yes, both models support Chat Completions. For function/tool calling, use the Responses API.
Which one is cheaper?
Sol is cheaper at the published Standard rates: $2 input and $10 output per million tokens, compared with Astra at $8 and $40. Cached-input rates are $0.10 and $0.40 respectively.
Does a one-million-token context mean one million input tokens?
No. The model pages list a 1,050,000-token context window, 922,000 maximum input tokens, and 128,000 maximum output tokens.
Can I keep using my old prompt with no changes?
You can test it, but review the migration guide first. In particular, check unsupported parameters, reasoning effort, top-level instructions, and any code that edits earlier conversation history.
Do I need to change every Chat Completions integration to Responses?
Not necessarily for basic supported requests. You do need Responses for tool calling, and the official migration guide should be followed for model-specific parameter and prompt-state changes.
Is Astra always the better choice?
Not automatically. OpenAI positions it for more demanding work, but your own evaluation should determine whether its additional cost produces enough improvement over Sol for a specific task.
Related GyanAangan reading
- GPT-6 Cyber launch: restricted access and security implications
- Gemini 4 Hydrogen: API setup and agent workflows
- Claude Fable 5.2 vs Mythos 5.2
- LangGraph human-in-the-loop agents and strict resume
- Build a multi-tenant LLM quota layer with FastAPI and Redis
Official sources and further reading
- OpenAI: Introducing GPT-6.2 Astra and Sol
- OpenAI API changelog — November 17, 2026 entry
- Using GPT-6.2: official migration quickstart and prompting guidance
- GPT-6.2 Astra model reference
- GPT-6.2 Sol model reference
- OpenAI API pricing
- Keep the prefix unchanged
- Reasoning models and effort settings
- OpenAI API quickstart
- Official OpenAI Python SDK repository and supported Python versions
- GPT-6.2 system card and Preparedness assessments
- ITmedia: independent coverage of the November 17 release (November 18, 2026)
Editorial note: Product capabilities, prices, availability, and safety assessments are attributed to OpenAI's documentation unless stated otherwise. Benchmark claims are vendor-reported and have not been independently reproduced for this article. API behavior and prices can change; verify the live documentation before deploying.
