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.

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
| Specification | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| API Identifier | gpt-6.2-astra | gpt-6.2-sol |
| Release Date | November 17, 2026 | November 17, 2026 |
| Context Window | 1,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 1M | Scaled long-context multiplier |
| Speed Tiers | Standard, Batch (50% off), Fast (2x), Ultrafast | Standard, Batch (50% off), Fast (2x), Ultrafast |
| Key Benchmarks | 95.8% ARC-AGI-2 (Max), 62 AA Index | 85.8% ARC-AGI-2 (Max), -0.5 pts vs. Astra on FrontierCode 2.0 |
| Preparedness / Safety | First external OpenAI model at High AI Self-Improvement | Standard frontier safeguards |
| Official Links | OpenAI Platform & Models | OpenAI 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:
- OpenAI GPT-6 Astra: Frontier Agentic Intelligence, ARC-AGI-3, and Critical Risk Thresholds — How the original GPT-6 Astra established the Preparedness Framework baseline and ARC-AGI trajectory.
- OpenAI GPT-6 Sol and Luna: The Structural Price Collapse in Frontier Agent Workflows — The economic mechanics behind multi-tier agent routing and prompt caching.
- OpenAI DevDay 2026: Dots Always-On Agents, GPT-6.1 Sol’s 80% Price Cut, the Decisions API — Plus Salesforce Koa and NVFP4 KV Cache — How GPT-6.1 Sol reshaped automated agent harnesses and Codex workflows.
- Claude Fable 5.2 & Claude Mythos 5.2: Anthropic’s Dual Frontier for Long-Horizon Autonomous Agents — Anthropic’s competing November 2026 flagship release (65 on the Artificial Analysis Intelligence Index).
- Gemini 4 Hydrogen: 2.5x Faster Agentic Execution, 1M Unified Context, and the Antigravity Orchestrator — Google’s high-speed execution model for coding and autonomous research.
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:
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.
- 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.
- 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.
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.
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.
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.
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:
| Metric | GPT-6 Astra | GPT-6.2 Astra | GPT-6 Sol | GPT-6.1 Sol | GPT-6.2 Sol |
|---|---|---|---|---|---|
| Role | Original Flagship | Current Flagship | Initial Workhorse | DevDay Workhorse | Current 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 Index | 57 | 62 (+5) | 48 | 55 | 57 (+2 vs. 6.1) |
| AA Coding Agent Index | 53 | 53 | — | 52 | 49 |
Two practical patterns stand out from this progression:
- 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.
- 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.00uncached in,$0.40cached in,$40.00out):- 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
- Turn 1 prefill (
- GPT-6.2 Sol (
$2.00uncached in,$0.10cached in,$10.00out):- 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).
- Turn 1 prefill (
(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/$40to$16/$60per 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.10per 1M).
