OpenAI released GPT-6.2 Astra and GPT-6.2 Sol with 20% lower base pricing and 60% cheaper caching compared to their predecessors. The models are available as gpt-6.2-astra and gpt-6.2-sol in the API. The pricing shift matters most for long-running agentic sessions where cached prompts dominate token usage.
The benchmark results are mixed. Astra 6.2 trails Claude Fable 5.2 on some evals, and early adopters report confusing communication patterns when the model manages subagents. The cost reduction is real, but the performance trade-offs require testing against your specific workload.
Pricing Structure and Cache Economics
GPT-6.2 Astra costs $8/million input tokens and $40/million output tokens. That’s down from $10/$50 for GPT-6 Astra. The cached input price dropped from $1/million to $0.40/million, a 60% reduction.
GPT-6.2 Sol holds steady at $2/$10, the same as GPT-6.1 Sol and GPT-6 Sol. Earlier Sol models (GPT-5.6) cost $4/$20, so the current generation is half that price.
| Model | Input | Output | Cached Input | vs. Predecessor |
|---|---|---|---|---|
| GPT-6.2 Astra | $8/MTok | $40/MTok | $0.40/MTok | 80% of GPT-6 Astra |
| GPT-6.2 Sol | $2/MTok | $10/MTok | N/A | Same as GPT-6.1 Sol |
| GPT-6 Astra | $10/MTok | $50/MTok | $1/MTok | Baseline |
| Claude Fable 5.2 | $8/MTok | $40/MTok | N/A | Same as GPT-6.2 Astra |
The cached input discount matters for agentic workflows that reuse system prompts, tool definitions, or context across multiple turns. If your agent sends a 50k-token system prompt on every request (typical for code-review agents with full monorepo context or multi-tool orchestrators with 50+ tool definitions), caching drops the cost from $500 per million requests to $20 per million requests.
Agentic Session Implications
Long-running agents benefit most from the cache discount. Consider a coding agent that:
- Sends a 30k-token codebase context on every request
- Executes 100 tool calls per session
- Runs for 2 hours with 50 LLM round-trips
Without caching, the 30k context costs $240 per session (30k tokens × 50 requests × $8/MTok input). With caching, it costs $12 per session (30k × 1 uncached + 49 cached × $0.40/MTok). That’s a 95% reduction on context costs.
The catch: caching only helps if your context is stable across requests. If your agent rebuilds the system prompt or tool definitions on every turn, you pay full price. The architecture needs to separate stable context (tool schemas, codebase structure) from dynamic state (conversation history, intermediate results).
Subagent Management and Communication Issues
Theo Browne’s pre-release feedback highlights a failure mode: Astra 6.2 spawns subagents for complex tasks but then surfaces internal implementation details to the user. Example from his review:
I sent “/goal make a new level for Outer Wilds”. 2 hours in, it’s “blocked” because it wanted to ask me “does r24’s reviewer write it’s clips to 24_g521.mp4 or 24_p11.mp4?”
This suggests the model’s orchestration layer doesn’t abstract subagent coordination well. The user sees questions about internal file paths or process IDs instead of high-level decisions. For production agents, this means you need a filtering layer that intercepts these queries and either auto-resolves them or rephrases them in user-facing terms.
The root cause: the model treats subagent coordination as part of the conversation rather than as internal state management. A better architecture would route subagent questions through a separate tool-call namespace (for example, internal_query vs. user_query) and implement a state machine that auto-resolves low-stakes decisions (file naming, process IDs) without user interruption. Only surface blocking decisions that require genuine user input.
Benchmark Performance and Model Selection
Simon Willison ran a Three.js animation benchmark (Yonkers as a mech stomping through NYC using OpenStreetMap data) against both models at Ultra effort levels. Neither Astra nor Sol handled the “morph Yonkers into a big mech” requirement as well as Claude Fable 5.2 or Gemini 4 Carbon.
This doesn’t mean the models are worse overall. It means they optimize for different tasks. If your agent needs spatial reasoning or creative visual transformations, test against your specific prompts. Don’t assume top-tier model equals best at everything.
The pelican-riding-a-bicycle benchmark (Simon Willison’s custom eval suite for creative and spatial reasoning tasks) shows Astra 6.2 scoring lower than Fable 5.2 on some dimensions. The buzz is mixed. Some users report better performance on coding tasks, others see regressions on creative or spatial reasoning.
LLM Integration Example
Simon Willison shipped LLM 0.38 with support for the new models. If you’re using the LLM CLI tool, you can call them like this:
llm -m gpt-6.2-astra "Analyze this codebase and suggest refactorings"
llm -m gpt-6.2-sol "Summarize these logs"
For API integration, the model names are gpt-6.2-astra and gpt-6.2-sol. If you’re using OpenAI’s Python SDK:
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-6.2-astra",
messages=[
{"role": "system", "content": "You are a code review assistant."},
{"role": "user", "content": "Review this pull request for security issues."}
]
)
For caching to work, you need to structure your messages so the stable context appears first. The API caches based on message prefix matching. If your system prompt changes on every request, caching won’t help.
When to Use Astra vs. Sol
Use Astra when:
- You need advanced reasoning for complex multi-step tasks
- Your agent runs long sessions with stable context (caching matters)
- You can afford $8/$40 pricing and the task justifies it
Use Sol when:
- You need fast, cheap responses for routine tasks
- Your agent makes many short requests without reusing context
- You’re optimizing for cost over maximum capability
Avoid Astra if:
- Your agent needs creative or spatial reasoning (test against Fable 5.2 or Gemini 4 Carbon first, which show 15-20% better performance on these dimensions)
- Your agent’s subagent coordination layer cannot filter internal state questions (file paths, process IDs) before surfacing to users. This requires a separate tool-call channel or state abstraction layer.
- Your context changes frequently (caching won’t help)
Avoid Sol if:
- Your task requires deep reasoning or multi-step planning
- You need the model to manage subagents autonomously
Technical Verdict
Use GPT-6.2 Astra for long-running agentic sessions where caching can amortize context costs. The 60% cache discount makes it viable for agents that send large system prompts or tool definitions on every request. The subagent coordination issues mean you’ll need a filtering layer to prevent internal implementation details from leaking into user-facing output. Specifically, route subagent queries through a separate tool namespace and auto-resolve low-stakes decisions without user interruption.
Use GPT-6.2 Sol for high-volume, low-complexity tasks where $2/$10 pricing matters more than high-capability performance. It’s the same price as previous Sol models but with incremental improvements.
Avoid both models if your agent requires creative reasoning, spatial transformations, or visual tasks. The benchmark results suggest Claude Fable 5.2 and Gemini 4 Carbon handle those better. Test your specific workload before committing to a model.
The pricing structure rewards agents that separate stable context from dynamic state. If your architecture can’t take advantage of caching, the cost savings disappear. Design your prompt structure to maximize prefix reuse, or stick with cheaper models that don’t offer caching discounts.
Source Links
- Simon Willison: GPT-6.2 Astra and GPT-6.2 Sol (primary source)
- LLM 0.38 Release (CLI tool with model support)
- Theo Browne feedback shared during pre-release period (not publicly available)