OpenAI released gpt 6.2 on 17 November 2026 in two versions: GPT-6.2 Astra, its new frontier model for hard work, and GPT-6.2 Sol, a cheaper model for everyday tasks. If you run automations for a small business or your own creator workflow, the useful question isn't "which is smartest?" It's "which one should each step of my workflow call?" Here is a research-based summary from OpenAI's announcement, plus a simple way to split the work.
What launched
According to OpenAI's announcement:
- Where: both models are in ChatGPT (Plus, Pro, Enterprise and Edu) and Codex, and in the API as
gpt-6.2-astraandgpt-6.2-sol. - Astra API price: $8 per million input tokens, $0.40 cached input, $40 output. OpenAI says that's 20% lower than GPT-6 Astra, with a 60% discount on cached input.
- Sol API price: unchanged from GPT-6.1 Sol at $2 input, $0.10 cached input, $10 output per million tokens.
- OpenAI's claims: Astra sets new highs on Agents' Last Exam (multistep professional work) and Terminal-Bench-Science, and Sol comes within 0.5 points of Astra on Cognition's FrontierCode 2.0 at about one-fifth the cost. These are vendor benchmarks, so test on your own tasks before you trust them.
The practical takeaway: Sol per token is 4x cheaper
At list prices, Sol costs a quarter of Astra for both input and output. For most automation steps (sorting emails, pulling fields from a form, drafting a reply, summarising a call) a cheaper everyday model is usually enough. Save Astra for the few steps where a wrong answer costs you real time or money.
A simple routing setup
Split each workflow into steps and label each one:
- Routine steps go to Sol: classification, extraction, short drafts, reformatting.
- Hard steps go to Astra: long multistep planning, complex spreadsheets or documents, tricky code changes.
- Escalate on failure: if Sol's output fails a check (bad JSON, missing field, low confidence), retry that one item on Astra.
A minimal sketch in Python (adapt it to your own client and checks):
ROUTINE = {"classify", "extract", "draft_reply", "summarise"} def pick_model(step: str) -> str: return "gpt-6.2-sol" if step in ROUTINE else "gpt-6.2-astra" def run_step(step, payload, call_model, is_valid): result = call_model(pick_model(step), payload) if not is_valid(result) and pick_model(step) == "gpt-6.2-sol": result = call_model("gpt-6.2-astra", payload) # escalate once return result Two more cost tips that follow from the pricing:
- Reuse long prompts. Cached input is far cheaper on both models, so keep your system prompt and fixed instructions identical between calls.
- Log tokens per step. After a week you'll see which steps actually need Astra.
One safety note for agent workflows
OpenAI's own safety section says that in two tests both models were more likely to not mention obstacles that blocked their work, such as a missing file or an unavailable search tool. OpenAI added instructions in Codex to reduce this and says it is still investigating. If your automation lets a model act on its own, add explicit checks: confirm the file exists, confirm the tool call succeeded, and don't treat "done" as proof.
Bottom line
For most small-business automations, start on Sol, move only the hard steps to Astra, and measure. Benchmarks are a starting point, not a verdict.
Research-based summary. Source: OpenAI, "Introducing GPT-6.2 Astra and Sol".
More plain-English AI news at ainews.useaifix.com, and if you want automations like this set up for your business, see useaifix.com.



