OpenAI GPT-6.2 Astra and GPT-6.2 Sol: 95.8% ARC-AGI-2, Responses API Shifts, and the 1/5th-Cost Workhorse

Inside OpenAI's GPT-6.2 Astra and Sol launch: 95.8% on ARC-AGI-2, High self-improvement preparedness, Responses API changes, and Sol's coding parity.

OpenAI GPT-6.2 Astra and GPT-6.2 Sol: 95.8% ARC-AGI-2, Responses API Shifts, and the 1/5th-Cost Workhorse

Series: Frontier AI Model Releases & Agentic Economics


Summary

On November 17, 2026, OpenAI released GPT-6.2 Astra and GPT-6.2 Sol across ChatGPT Work, Codex, Amazon Bedrock, GitHub Copilot, and the OpenAI API. Rather than shipping a single monolithic upgrade, OpenAI sharpened its dual-tier strategy: GPT-6.2 Astra pushes frontier fluid intelligence to 95.8% on ARC-AGI-2 and becomes OpenAI’s first external model to cross the High threshold for AI self-improvement under its Preparedness Framework while cutting input pricing by 20% to $8.00 per million tokens ($0.40 cached). Meanwhile, GPT-6.2 Sol holds the $2.00 / $10.00 price floor ($0.10 cached) while closing within 0.5 points of Astra on Cognition’s FrontierCode 2.0—giving engineering teams near-flagship coding performance at one-fifth the API cost.


Hugging Face / Official Model Card Summary

SpecificationGPT-6.2 AstraGPT-6.2 Sol
API Identifiergpt-6.2-astragpt-6.2-sol
Release DateNovember 17, 2026November 17, 2026
Context Window1,050,000 tokens (Text + Image)1,050,000 tokens (Text + Image)
Standard Input ($\le$ 272K)$8.00 / 1M tokens (20% cut vs. GPT-6)$2.00 / 1M tokens
Cached Input ($\le$ 272K)$0.40 / 1M tokens$0.10 / 1M tokens
Standard Output ($\le$ 272K)$40.00 / 1M tokens$10.00 / 1M tokens
Long-Context (> 272K)$16.00 In / $60.00 Out per 1MScaled long-context multiplier
Speed TiersStandard, Batch (50% off), Fast (2x), UltrafastStandard, Batch (50% off), Fast (2x), Ultrafast
Key Benchmarks95.8% ARC-AGI-2 (Max), 62 AA Index85.8% ARC-AGI-2 (Max), -0.5 pts vs. Astra on FrontierCode 2.0
Preparedness / SafetyFirst external OpenAI model at High AI Self-ImprovementStandard frontier safeguards
Official LinksOpenAI Platform & ModelsOpenAI Announcements

Prior Reading Material

Before diving into GPT-6.2’s benchmark jumps, token economics, and Responses API changes, review our earlier coverage of OpenAI’s GPT-6 family and competing frontier releases:


1. The Dual-Tier Strategy: Why Two Models Matter More Than One

Most frontier labs still market a single flagship model as the answer to every engineering problem. In production agentic workflows, however, running a flagship model on every file read, test check, and lint loop burns budget fast.

OpenAI’s GPT-6.2 launch refines the split we first saw in GPT-6 Sol and Luna into two clear roles:

OpenAI GPT-6.2 Family: Dual-Tier Architecture & Economics Figure 1: Architectural and pricing comparison between GPT-6.2 Astra and GPT-6.2 Sol across standard input, cached input, output tokens, and benchmark positioning. Source: OpenAI & Artificial Analysis.

  1. GPT-6.2 Astra (gpt-6.2-astra) — The Heavyweight Strategist:
    • Cuts standard input cost by 20% (from $10.00 down to $8.00 / 1M) and drops cached input to $0.40 / 1M, making large repository prefills significantly cheaper.
    • Excels at deep scientific analysis (Terminal-Bench-Science 0.1, Vals Science Index), legal synthesis (Harvey LAB-AA, Astra for Law), and GDPval v2 while emitting fewer output tokens than earlier Astra builds.
  2. GPT-6.2 Sol (gpt-6.2-sol) — The 1/5th-Cost Coding Workhorse:
    • Retains the aggressive $2.00 / $10.00 pricing ($0.10 cached) while landing within 0.5 points of Astra on Cognition’s FrontierCode 2.0.
    • Built for continuous Codex loops, CI triage, and multi-turn repository edits where latency and unit economics dominate.

Two-Tier Agentic Routing: GPT-6.2 Sol vs. GPT-6.2 Astra Figure 2: Recommended two-tier routing pattern pairing GPT-6.2 Sol for high-volume coding loops with GPT-6.2 Astra for frontier reasoning.


2. Benchmark Breakdown: ARC-AGI Milestones & Frontier Science

The headline story of GPT-6.2 is fluid intelligence—solving novel abstract puzzles that cannot be memorized from pre-training scrapes.

ARC-AGI Fluid Intelligence Milestones: GPT-6.2 Astra vs. Sol Figure 3: Reported ARC-AGI-1, ARC-AGI-2, and ARC-AGI-3 scores across GPT-6.2 Astra and GPT-6.2 Sol. Source: ARC Prize / OpenAI.

  • ARC-AGI-1: GPT-6.2 Astra hits 98.5% at roughly $0.17 per task.
  • ARC-AGI-2: GPT-6.2 Astra (Max) reaches 95.8% (~$0.50 per task), while GPT-6.2 Sol (Max) reaches 85.8%.
  • ARC-AGI-3: With a provider adapter configuration, GPT-6.2 Astra became the first model to hit 100.0% (scoring ~70.3% in standard configuration), with GPT-6.2 Sol reaching ~98% with adapters.
  • Artificial Analysis Intelligence Index: GPT-6.2 Astra jumps 5 points to 62 (#2 overall behind Anthropic’s Claude Fable 5.2 at 65), while GPT-6.2 Sol climbs to 57 (matching the prior GPT-6 Astra baseline).
  • Science, Coding & Agentic Suites: Astra ranks #1 on Terminal-Bench-Science 0.1 (78%, with Sol at 68%), hits 77% on AutomationBench-AA, and scores 45% vs. Sol’s 44% on FrontierCode-AA 2.0, alongside leading AA-3D and AA-Robotics v0.1.

Artificial Analysis Intelligence Index vs. Output Tokens per Task Figure 4: Artificial Analysis Intelligence Index vs. output token consumption per task, showing GPT-6.2 Astra’s Pareto efficiency across reasoning effort levels (low through max). Source: Artificial Analysis.

Artificial Analysis Coding Agent Index and Cost per Task Figure 5: Artificial Analysis Coding Agent Index v2.1 and Cost-per-Task Pareto frontier comparing Codex + GPT-6.2 Astra/Sol against Claude Fable 5.2 and Gemini 4. Source: Artificial Analysis.


3. Evolution Across the GPT-6.x Lineage (GPT-6 → 6.1 → 6.2)

Stepping back across OpenAI’s 2026 releases shows how rapidly capability has migrated downward in price—GPT-6.2 Sol now matches the original GPT-6 Astra’s Artificial Analysis Intelligence Index score (57) at one-fifth the input cost:

MetricGPT-6 AstraGPT-6.2 AstraGPT-6 SolGPT-6.1 SolGPT-6.2 Sol
RoleOriginal FlagshipCurrent FlagshipInitial WorkhorseDevDay WorkhorseCurrent Workhorse
Input / 1M$10.00$8.00$2.00$2.00$2.00
Cached In / 1M$1.25$0.40$0.20$0.10$0.10
Output / 1M$40.00$40.00$10.00$10.00$10.00
AA Intelligence Index5762 (+5)485557 (+2 vs. 6.1)
AA Coding Agent Index5353—5249

Two practical patterns stand out from this progression:

  1. Flagship Intelligence Got Cheaper: GPT-6.2 Astra delivers a +5 point jump on the Intelligence Index while cutting uncached input pricing by 20% and cached input pricing by 68% compared to GPT-6 Astra.
  2. Workhorse Coding Caught Up: For teams running high-volume agent loops, GPT-6.2 Sol brings original Astra-level general intelligence (57) down to $2.00 / $10.00, though teams already tuned on GPT-6.1 Sol for Codex should benchmark both since GPT-6.1 Sol still edges out 6.2 Sol on the aggregate Coding Agent Index (52 vs. 49).

4. Preparedness Milestone & Responses API Breaking Changes

Two technical details in the GPT-6.2 release directly impact enterprise security teams and harness builders:

1. Crossing the “High” AI Self-Improvement Threshold

Under OpenAI’s Preparedness Framework, GPT-6.2 Astra is the first external OpenAI model to cross the High capability threshold for AI self-improvement—meaning it can meaningfully accelerate ML research engineering, experiment design, and automated optimization loops under supervised evaluation.

2. Responses API Prefix-Edit Behavior

Starting with gpt-6.2-*, OpenAI updated how the Responses API handles stateful reasoning items:

  • If your harness edits conversation history mid-flight (mutating earlier prefix turns), switches models/downgrades mid-session, or changes organization/end-user identifiers, the API drops prior reasoning items rather than carrying stale chain-of-thought state across mutated prefixes.
  • Practical Takeaway: Treat your system prompt and early conversation turns as immutable append-only prefixes so you preserve both reasoning continuity and the $0.40 / $0.10 per 1M prompt cache hit rates.

5. Token Economics: Comparing GPT-6.2 Astra vs. Sol in a 20-Turn Agent Loop

Consider a 20-turn coding agent session operating on a 120,000-token repository (within the 272K standard pricing tier), adding 2,000 new tokens and generating 1,500 output tokens per turn:

  • GPT-6.2 Astra ($8.00 uncached in, $0.40 cached in, $40.00 out):
    • Turn 1 prefill (0.12M × $8.00) = $0.96
    • Turns 2–20 cached reads (~2.6M × $0.40) + new deltas (0.038M × $8.00) = $1.34
    • Output across 20 turns (0.03M × $40.00) = $1.20
    • Total 20-Turn Session: ~$3.50
  • GPT-6.2 Sol ($2.00 uncached in, $0.10 cached in, $10.00 out):
    • Turn 1 prefill (0.12M × $2.00) = $0.24
    • Turns 2–20 cached reads (~2.6M × $0.10) + new deltas (0.038M × $2.00) = $0.34
    • Output across 20 turns (0.03M × $10.00) = $0.30
    • Total 20-Turn Session: ~$0.88 (a 75% cost reduction while staying within 0.5 points on FrontierCode 2.0).

(Note: Crossing the 272K-token input threshold triggers OpenAI’s long-context multiplier—e.g., Astra scales to $16.00 input / $60.00 output per 1M—so compacting stale tool logs before 272K remains critical.)


6. Runnable Python Simulation: GPT-6.2 Cost & Routing Simulator

The zero-dependency script below (scripts/gpt62_cost_router_sim.py, run standalone via python3 scripts/gpt62_cost_router_sim.py) models 20-turn cached agent sessions, the 272K long-context pricing cliff, and task routing between GPT-6.2 Sol and GPT-6.2 Astra.

Click to expand runnable code script
#!/usr/bin/env python3
"""
scripts/gpt62_cost_router_sim.py
Zero-dependency simulator for OpenAI GPT-6.2 Astra vs. GPT-6.2 Sol
multi-turn prompt caching economics and 272K long-context scaling.
"""

from dataclasses import dataclass

@dataclass
class ModelPricing:
    name: str
    input_per_m: float
    cached_per_m: float
    output_per_m: float
    long_input_per_m: float
    long_output_per_m: float

ASTRA = ModelPricing("GPT-6.2 Astra", 8.00, 0.40, 40.00, 16.00, 60.00)
SOL = ModelPricing("GPT-6.2 Sol", 2.00, 0.10, 10.00, 4.00, 15.00)

def simulate_session(model: ModelPricing, repo_tokens: int = 120_000,
                     turns: int = 20, delta_in: int = 2_000, out_per_turn: int = 1_500) -> float:
    total_cost = 0.0
    for t in range(1, turns + 1):
        ctx = repo_tokens + (t - 1) * delta_in
        is_long = ctx > 272_000
        in_rate = model.long_input_per_m if is_long else model.input_per_m
        out_rate = model.long_output_per_m if is_long else model.output_per_m

        if t == 1:
            turn_in_cost = (ctx / 1_000_000) * in_rate
        else:
            cached = ctx - delta_in
            turn_in_cost = (cached / 1_000_000) * model.cached_per_m + (delta_in / 1_000_000) * in_rate

        turn_out_cost = (out_per_turn / 1_000_000) * out_rate
        total_cost += turn_in_cost + turn_out_cost
    return total_cost

def main():
    print("=" * 70)
    print("OPENAI GPT-6.2 ASTRA vs. SOL: 20-TURN AGENT SESSION COST")
    print("=" * 70)
    for repo in (120_000, 300_000):
        astra_cost = simulate_session(ASTRA, repo_tokens=repo)
        sol_cost = simulate_session(SOL, repo_tokens=repo)
        tier = "Long-Context (>272K)" if repo > 272_000 else "Standard (<=272K)"
        print(f"\n[{tier} | Initial Repo: {repo:,} tokens]")
        print(f"  GPT-6.2 Astra Total: ${astra_cost:.2f}")
        print(f"  GPT-6.2 Sol Total:   ${sol_cost:.2f} ({(1 - sol_cost/astra_cost)*100:.1f}% cheaper)")
    print("=" * 70)

if __name__ == "__main__":
    main()

FAQ

  • When should a team pick GPT-6.2 Sol over GPT-6.2 Astra?

    Answer

    Use GPT-6.2 Sol ($2.00 / $10.00) for everyday coding agents, Codex loops, test-fix iterations, and high-volume extraction where it scores within 0.5 points of Astra on FrontierCode 2.0 at one-quarter the standard rate. Reserve GPT-6.2 Astra ($8.00 / $40.00) for hard scientific reasoning, legal/financial synthesis, and complex multi-system architecture.

  • Why does GPT-6.2 have a 272K token pricing threshold inside a 1.05M context window?

    Answer

    While both models accept up to 1,050,000 tokens, attention KV-cache memory and prefill compute grow rapidly beyond 272K tokens. OpenAI applies a long-context multiplier above 272K (e.g., Astra rises from $8/$40 to $16/$60 per 1M), making context compaction and prompt caching essential for long-running agents.

  • What breaks if my agent edits earlier messages in the Responses API?

    Answer

    Starting with GPT-6.2, mutating conversation history mid-session (prefix edits), switching models, or changing org/end-user IDs causes the Responses API to drop prior reasoning items. Keep your system prompt and earlier turns append-only to preserve both reasoning state and cached-input pricing ($0.40 / $0.10 per 1M).