GPT-6.2 Astra and Sol Migration: Responses API Changes

Learn how OpenAI's GPT-6.2 Astra and Sol affect prompt caching, prefix edits, instructions placement, tool calling requirements, and pricing models.

By ailog · Published Nov 20, 2026 · 7 min read · How we work
In short
  • OpenAI announced gpt-6.2-astra and gpt-6.2-sol on 2026-11-17 across the Responses API and Chat Completions.
  • Tool execution and function calls now strictly demand the Responses API; Chat Completions no longer supports tools for these models.
  • Top-level instructions now append after input items, requiring developer messages at the start of input to maintain prompt caching eligibility.
  • Altering conversation prefixes, changing models mid-stream, or switching user IDs will purge reasoning tokens from the conversation context.
  • Setting reasoning effort to none causes API rejection, while sampling parameters like temperature and top_p are no longer permitted.

GPT-6.2 Release Overview and Core Architecture Changes

On 2026-11-17, the OpenAI API changelog revealed the arrival of two flagship models: gpt-6.2-astra and gpt-6.2-sol. Designed as frontier reasoning engines, these systems target distinct workloads across production environments. The Astra variant addresses demanding software engineering, visual document analysis, and comprehensive autonomous operations. In contrast, the Sol variant is built as an everyday operational engine for coding assistance and scalable agent orchestration.

Both models introduce foundational protocol shifts. While both endpoints (v1/chat/completions and v1/responses) accept requests, tool calling functionality is exclusively restricted to the Responses API. Applications relying on functions, shell execution, or web browsing inside legacy Chat Completions code must migrate to the newer endpoint. Neither model provides compatibility for Assistants, Realtime, Fine-tuning, direct Speech generation, or Image generation routes, though tools like image_generation can be invoked via the Responses route.

Model Attribute gpt-6.2-astra gpt-6.2-sol
Context Window 1,050,000 tokens 1,050,000 tokens
Maximum Input Tokens 922,000 tokens 922,000 tokens
Maximum Output Tokens 128,000 tokens 128,000 tokens
Knowledge Cutoff May 18, 2026 Jun 01, 2026
Input Modalities Text, Image Text, Image
Output Modalities Text Text
Tool Calling Endpoint v1/responses only v1/responses only

Both model engines feature expansive token envelopes. Each supports up to 1,050,000 context tokens, capping request inputs at 922,000 tokens while allowing up to 128,000 generated output tokens per response. The cutoff for world knowledge sits at May 18, 2026 for Astra, whereas Sol includes information through Jun 01, 2026.

Responses API Migration: Instructions, Prefix Edits, and Reasoning State

The transition to GPT-6.2 alters how context matching and multi-turn states are processed inside the Responses API. The most notable architectural change involves the placement of the root instructions property. Previously, instructions sat at the beginning of an assembled context buffer. For models starting with GPT-6.2, the system automatically appends the top-level instructions attribute after all items in the input array.

This reordering directly disrupts prompt caching. If long-lived system instructions are placed into the root instructions field, appending them after dynamic conversation turns breaks cache prefix continuity. To keep static guidance cacheable, teams must position reusable prompts inside a developer role entry placed as the initial element of the input list. The top-level instructions field should be reserved strictly for transient directives specific to the single active call.

{
  "model": "gpt-6.2-sol",
  "input": [
    {
      "role": "developer",
      "content": "Base system instructions that remain static across turns for prompt caching."
    },
    {
      "role": "user",
      "content": "Check repository dependencies and suggest security updates."
    }
  ],
  "instructions": "Ephemeral instructions applying only to this specific execution turn.",
  "reasoning": {
    "effort": "medium"
  }
}

Prefix stability is equally critical for internal reasoning continuity. Beginning with GPT-6.2, altering historical entries in an active dialog (known as a prefix edit), downgrading to a different model tier mid-turn, or changing tenant metadata like the organization or end user triggers the Responses API to strip previously generated reasoning items. Discarding reasoning items forces the model to regenerate underlying logic, which can degrade output coherence and significantly inflate token consumption. To prevent this, developers must ensure message logs remain immutable between turns, as described in OpenAI’s guidance to keep prefix unchanged.

Parameter management requires strict auditing. The API will outright reject payloads setting reasoning effort to none. When migrating callers from previous iterations where reasoning effort was omitted, set to none, or set to minimal, engineers must supply at least low, with medium recommended for fresh integrations via reasoning.effort in Responses or reasoning_effort in Chat Completions. Furthermore, parameters such as temperature, top_p, logprobs, and top_logprobs are unsupported and must be stripped from outgoing requests.

Pricing Structure, Context Tiers, and Service Levels

Pricing for GPT-6.2 models splits along context length boundaries and throughput processing tiers. For short-context requests up to 272K input tokens under Standard tier rates, gpt-6.2-astra costs $8 per 1M input tokens, $0.4 per 1M cached input tokens, and $40 per 1M output tokens. The smaller gpt-6.2-sol comes in at $2 per 1M input tokens, $0.1 per 1M cached input tokens, and $10 per 1M output tokens.

Caching writes introduce explicit storage fees based on retention windows. A standard write with 30 minutes of retention costs $10 per 1M tokens on Astra and $2.5 per 1M tokens on Sol. Opting for a 12-hour cache write increases that cost to $20 per 1M tokens for Astra and $5 per 1M tokens for Sol for short-context Standard payloads. When migrating configurations from systems running GPT-5.5 or earlier architectures, developers must abandon the older prompt_cache_retention property and configure prompt_cache_options.ttl with the value "30m".

Model Name / ID Input (per 1M) Cached Input (per 1M) Output (per 1M)
gpt-6.2-astra $8 $0.4 $40
gpt-6-astra $10 $1 $50
gpt-6.2-sol $2 $0.1 $10
gpt-6.1-sol $2 $0.1 $10
gpt-5.6-sol $4 $0.4 $20
claude-opus-5.5 $4 $0.2 $20
claude-sonnet-5.5 $2 $0.2 $10
gemini-3.8-flash $0.75 $0.075 $3.75

Context scaling alters costs substantially. Once input tokens exceed the 272K boundary, base input token rates and cache prices double, while output generation charges increase by 1.5 times the short-context baseline for the entirety of that request. Teams processing large repositories or documentation sets can model these escalation rules using the /tools/llm-api-cost-calculator/ or review global baselines via /tools/llm-api-pricing/.

Execution tiers adjust processing schedules and billing. Using the Batch endpoint (v1/batch) discounts Standard rates by 50%. Conversely, Fast mode doubles Standard prices for matching token lengths. Ultrafast mode bills at 3 times Standard pricing through February 28, 2027, subsequently jumping to 6 times Standard rates starting March 1, 2027. Note that neither GPT-6.2 Astra nor Sol supports Flex processing (service_tier: flex). Instead, background jobs can utilize public beta discounted completion windows spanning two-hour or eight-hour execution spans under Standard processing.

Rate Limits, Data Residency, and Zero Data Retention

Throughput ceilings on GPT-6.2 align with account tiers. Under the Standard tier, organizations in the Build category receive limits of 5,000 RPM (requests per minute) and 1,000,000 TPM (tokens per minute). Advancing to Launch raises thresholds to 10,000 RPM and 4,000,000 TPM, while the Grow tier provides 15,000 RPM alongside 40,000,000 TPM.

  • Build Tier: 5,000 RPM and 1,000,000 TPM
  • Launch Tier: 10,000 RPM and 4,000,000 TPM
  • Grow Tier: 15,000 RPM and 40,000,000 TPM

Data residency support extends across the United States and European Union territories when executing calls through Standard, Fast, and Batch routes. However, systems operating on the Ultrafast tier are strictly limited to US data residency. Teams bound by geographical compliance boundaries must plan their service level selections accordingly.

For security-sensitive deployments, both models support Zero Data Retention (ZDR) for qualifying accounts. Enabling ZDR instructs the Responses API to handle the store argument as false. Because OpenAI will not persist conversational records on its backend under ZDR, clients executing multi-turn flows must resend previous context items in sequence, including encrypted reasoning objects, to retain logical state across sequential turns.

Agent Workflows and Prompt Tuning Strategies

GPT-6.2 models adopt a more concise and direct baseline voice. Legacy system prompts instructing the engine to ‘be concise’ may produce overly terse responses and should be reevaluated. When handling open-ended workflows, Astra tends to suggest prospective plans and halt for user affirmation rather than guessing. If developers intend for agents to proceed independently, instructions must explicitly license the model to adopt sensible, reversible assumptions and proceed through task milestones.

Multi-agent coordination is natively supported via the Responses API Multi-agent beta. Astra and Sol natively integrate with a comprehensive toolset including web_search, file_search, image_generation, code_interpreter, hosted_shell, apply_patch, skills, computer_use, mcp, and tool_search. Where ambiguous situations arise during unattended execution, developers can supply asynchronous input tools like request_user_input_async, enabling agents to request human guidance on blocked decisions while continuing independent work on unblocked components.

In long-running agent threads, intermediate reasoning shorthand can occasionally bleed into user-facing output. Prompts should instruct the model to produce self-contained final summaries that avoid carrying over internal abbreviations, raw tool calls, or reasoning artifacts. Code generation prompts should similarly outline local project conventions, such as prioritizing the reuse of existing classes and avoiding unnecessary helper abstractions.

GPT-6.2 Integration and Migration Checklist

  • Update model strings to gpt-6.2-astra or gpt-6.2-sol across deployment manifests.
  • Reroute all function and tool executions to the Responses API endpoint at v1/responses.
  • Transfer static prompt templates from the root instructions field into a developer role message at the start of input to maintain prompt caching.
  • Remove unsupported parameters including temperature, top_p, logprobs, and top_logprobs from request payloads.
  • Ensure reasoning effort is explicitly defined as low, medium, or high, avoiding none or minimal settings.
  • For legacy code using prompt_cache_retention, switch to prompt_cache_options.ttl assigned to 30m.
  • Audit conversation management to avoid prefix edits, model downgrades, or identity changes that wipe reasoning state mid-dialog.
  • Confirm whether request input exceeds 272K tokens to account for doubled input rates and 1.5x output rate increases.

Developers upgrading autonomous tooling or code-editing pipelines can accelerate the transition using the OpenAI Docs skill. Ensuring stable prefix caches and compliant parameter structures guarantees full access to the performance and reasoning improvements of the GPT-6.2 series.

Sources
  1. OpenAI API changelog — 2026-11-17
  2. GPT-6.2 Astra
  3. GPT-6.2 Sol
  4. Using GPT-6.2

Related