AI/November 20, 2026/11 min read

How to Combine GPT-6.2 Astra and Sol: 5 Setups That Cut Cost Without Losing Quality

GPT-6.2 Astra is smarter, GPT-6.2 Sol is four times cheaper, and on many tasks they finish level. The smartest teams use both. Here are the five setups we recommend, when to escalate from Sol to Astra, how to configure it in Codex and the API, and when combining is not worth it.

Bella Ng
Bella NgCo-founder, Growthtrait
How to Combine GPT-6.2 Astra and Sol: 5 Setups That Cut Cost Without Losing Quality

Since OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, 2026, the question most teams ask is no longer which one is better. It is how to use both. Astra is the stronger model for hard, long work. Sol is four times cheaper per token and, on short and medium tasks, often finishes level with Astra. Putting each model where it is strongest gives you most of Astra's quality at a fraction of its cost.

This guide sets out the five setups we recommend, the rules we use to decide when a task should move from Sol to Astra, how to configure each setup in Codex and the API, what it costs, and the cases where a single model is simply the better choice. Prices and test results are as of November 20, 2026.

The Short Answer

  • Make Sol your default for everyday coding, writing, support and multistep workflows.
  • Bring in Astra for three jobs only: planning complex work, handling the hard step Sol cannot finish, and reviewing high-risk output.
  • Write down clear escalation rules so the switch to Astra is a decision, not a habit.
  • Keep Astra's share of tokens small. If Astra does most of the work, you are paying Astra prices with extra overhead.
  • Do not combine for simple, short or strictly step-by-step tasks. Sol alone is faster and cheaper there.

Why Combine Astra and Sol?

The case for combining comes from three numbers. On API price, Astra costs $8 per million input tokens and $40 per million output tokens, while Sol costs $2 and $10, according to OpenAI's model documentation. On the Artificial Analysis Intelligence Index, Astra scores 62 and Sol 57, at about $4.00 and $1.01 per task. And in hands-on tests, the gap on everyday work is small:

  • Customer support: in eesel's test, both models passed all 15 test tickets. Sol cost $1.42 per 1,000 tickets, Astra $5.79.
  • Coding benchmark run by a Hacker News user (PacBench): Astra scored 92 for $2.04, Sol 87 for $0.49.
  • A Codex bug fix tested by Flavio Copes: both models produced the same fix.

Astra pulls clearly ahead on harder work: science (68.44 against 57.76 on the Vals Science Index), long terminal tasks, CAD, legal analysis and secure coding. Developers also report that Astra is noticeably better at coordinating subagents, while Sol is the stronger choice for simply getting the work done. That split is exactly what a combined setup uses.

What each model does best

  • Astra: breaking a large task into parts, decisions that affect several systems, hard debugging, science, legal and CAD work, final checks on risky changes.
  • Sol: implementing well-defined tasks, drafting, bulk generation, support replies, code review (GitHub found it caught nearly twice as many real issues as GPT-6.1 Sol).
  • Watch out with Astra: it is slow to start (Artificial Analysis measured about 135 seconds to the first answer token) and, according to OpenAI's system card, more likely than its predecessor to leave known problems out of its final report.
  • Watch out with Sol: it dropped 14 points on a test of answering questions about a codebase, and in eesel's test it added tracking links the tool never returned in 7 of 14 order replies.

Setup 1: Sol by Default, Escalate to Astra

This is the setup we recommend for most teams, and it matches OpenAI's own advice: “For most tasks in ChatGPT Work or Codex, start with GPT-6.2 Sol,” and choose Astra for complex projects, according to its model selection guide. Sol handles every task first. A task moves to Astra only when it meets one of your escalation rules.

Escalation rules we suggest

  • Sol hands a step back, or says it cannot finish.
  • Tests or CI fail the same way twice in a row.
  • The change touches several services, or an API contract, database schema, authentication or data migration.
  • Two review rounds end in disagreement.
  • The scope of the task changes mid-way.
  • Evidence is missing after the usual local checks.

Just as important are the non-triggers: style comments, a single failed test with a clear cause, and small follow-up edits should stay with Sol. In Codex, you can switch the running session with the “/model” command, or start a session with “codex --model gpt-6.2-astra”. Escalate on the specific step, then switch back to Sol.

Setup 2: Astra Plans, Sol Executes

For large projects that split cleanly into parts, such as a multi-page website build, a data migration or a research report with several sections, let Astra write the plan and Sol do the work. Astra decides the structure, the order and the acceptance criteria. Sol subagents implement each part in parallel.

Codex supports this directly. Its subagent documentation says subagent workflows are enabled by default, and you can set a different model for subagents with the “agents.default_subagent_model” and “agents.default_subagent_reasoning_effort” settings, or with a “model” line in a custom agent file. OpenAI's own reviewer agent example uses “gpt-6.2-sol”. A setup we like:

  • Parent agent: Astra at high or xhigh effort, used for the plan and the final check.
  • Subagents: Sol at medium effort, one per independent part of the work.
  • Acceptance criteria written into the plan, so each subagent knows what “done” means.
  • A cap on parallel subagents (three to four is a sensible start) to keep cost and review load in check.

One caution. Keep Astra's role short. A developer who ran Astra as an always-on orchestrator in the previous generation used up a weekly quota in under half a day, then rebuilt the setup with Sol in charge and Astra on call, and the same kind of session used under 1% of quota. Astra should plan and check, not sit in the loop for every message.

Setup 3: Sol Does the Work, Astra Reviews

Here Sol completes the task and Astra checks the result before it ships. It suits work where mistakes are expensive: pricing pages, checkout code, legal or financial copy, and anything customer-facing that cites facts.

  • Review only what is risky. Sending every Sol output to Astra doubles cost for little gain. Sample routine work and review all high-risk changes.
  • Give Astra a checklist: facts and figures, links, claims that need a source, security and data handling.
  • Limit the loop to three review rounds. If the models still disagree, a person decides.
  • Consider a second opinion from another model family, such as Claude, for the most important reviews. Several developers prefer a reviewer that does not share the writer's blind spots.

Setup 4: Sol in Charge, Astra as Advisor

A lighter version of Setup 2. Sol runs the whole task, and asks Astra for advice only at a few key moments: choosing an approach, getting unstuck, and a final sanity check. Each consultation is short, so Astra's share of tokens stays small.

This pattern has the best published evidence from a comparable setup. When Anthropic tested a cheaper executor model with a stronger advisor model, the pair scored 2.7 percentage points higher on SWE-bench Multilingual than the cheaper model alone and cost 11.9% less per task, according to Anthropic. The models are different, but the principle is the same: the strong model spends a few hundred tokens of advice instead of doing the whole job.

Setup 5: Run Both in Parallel and Pick the Best

For a small number of high-stakes tasks, run Sol and Astra on the same brief in separate git worktrees and compare the results. Codex 0.169.0 or later supports choosing the model per cloud task, according to Paradev. This costs the most, so reserve it for work where a better answer is worth paying twice, such as a core architecture change or a launch landing page.

Combining in the API and Agents SDK

If you build your own agents, note one limit. In the Responses API Multi-agent beta, “the subagents share the request's model and available tools,” so an Astra request cannot start Sol subagents directly. To mix models through the API:

  • Use the Agents SDK, where each agent can have its own model. OpenAI's docs note that “a fast triage agent and a slower deep specialist can coexist cleanly.”
  • Or make separate calls: one Astra call for the plan, then Sol calls for each part, then an optional Astra call to check.
  • Avoid switching models inside one conversation thread. OpenAI's docs say a different model can use different caching behavior and that reasoning items are dropped after certain model changes, so keep each model in its own thread.
  • Start Sol at medium reasoning effort, as OpenAI recommends, and Astra at high or xhigh. Max effort rarely pays off.

What Does a Combined Setup Cost?

No one has yet published a controlled test of an Astra plus Sol pipeline against either model alone, so here is our own estimate. Using Artificial Analysis cost per task as the base ($1.01 for Sol, $4.00 for Astra), and assuming Astra handles 10% to 25% of the tokens with 20% to 50% extra coordination overhead:

  • Light combination (Astra plans and checks, about 10% of tokens): roughly $1.60 per task.
  • Heavier combination (Astra on about 25% of tokens): roughly $2.65 per task.
  • Sol alone: about $1.01. Astra alone: about $4.00.

In other words, a combined setup costs roughly 1.6 to 2.6 times as much as Sol alone and 40% to 66% of Astra alone. It pays off when it saves you from failed Sol runs, rework or review time. If Sol already gets the task right most of the time, the extra spend buys little.

When Not to Combine

  • Simple, short tasks such as small bug fixes, quick edits and one-shot drafts. Sol alone is faster and cheaper.
  • Customer support at volume. Both models passed eesel's tests, so an Astra layer adds cost without a measured quality gain. Spot-check instead.
  • Strictly step-by-step work, such as sequential debugging. A large Google and MIT study of agent setups found multi-agent variants lost 39% to 70% on sequential planning tasks, while gaining strongly on tasks that can run in parallel.
  • When speed matters. Because Astra is slow to start, a plan, execute and review loop can take longer than Astra alone. Combining saves time only when Sol subagents run in parallel.

Guardrails for Any Combined Setup

  • Ask every agent to list anything that blocked it or that it could not verify. Codex adds a prompt for this, but direct API calls do not, so add your own instruction.
  • Verify links, prices, order data and statistics before anything goes live, especially from Sol.
  • Pass a written brief between models, not a long chat history. Context lost in handoffs is the most common reason multi-agent setups fail.
  • Track escalation rates and cost per accepted result for a few weeks, then adjust your rules.

How Marketing and E-commerce Teams Can Use the Combination

  • Campaign planning: Astra builds the strategy brief and message hierarchy, Sol writes ad, email and social variants, Astra checks claims and offers before launch.
  • Product content at scale: Sol writes descriptions and metadata in bulk. Astra reviews a sample and every product in a regulated category.
  • Pitch decks and reports: Astra builds decks that follow your template and handles the analysis. Sol drafts supporting copy and summaries.
  • Website and store changes: Astra plans changes to checkout, tracking or site structure, Sol implements page by page, Astra reviews anything that touches payments or analytics.
  • Support: Sol only, with human spot checks on refunds, order status and anything that quotes data.

The combination will change as OpenAI updates both models, so treat these setups as a starting point and measure what works for your own tasks. If your team wants help designing AI workflows that route work to the right model, our AI training program covers model choice, agent setups and cost control. Contact us to plan a session.

Frequently asked questions

Should I use GPT-6.2 Astra or GPT-6.2 Sol?

Use both. Make Sol your default for everyday tasks, since it costs a quarter as much per token and often matches Astra on short and medium work. Bring in Astra to plan complex projects, handle steps Sol cannot finish and review high-risk output.

Can Astra control Sol subagents in Codex?

Yes. Codex enables subagents by default, and you can set a different subagent model with the agents.default_subagent_model setting or a model line in a custom agent file. A common setup is Astra as the parent agent and Sol for the subagents.

Can I mix Astra and Sol in the OpenAI API?

Not inside one Multi-agent beta request, where subagents share the request's model. Use the Agents SDK, which lets each agent have its own model, or make separate Astra and Sol calls. Keep each model in its own thread to protect caching and reasoning.

When should a task move from Sol to Astra?

Escalate when Sol hands a step back, when tests fail the same way twice, when a change touches several services, an API, database schema, authentication or migration, when two review rounds disagree, or when the scope changes.

How much does combining Astra and Sol cost?

By our estimate, roughly $1.60 to $2.65 per task when Astra handles 10% to 25% of the tokens, against about $1.01 for Sol alone and $4.00 for Astra alone, based on Artificial Analysis cost per task.

When is it better to use only one model?

For short tasks, high-volume support and strictly step-by-step work, Sol alone is usually faster and cheaper. For a single hard, long task that does not split into parts, Astra alone can be simpler than a combined setup.

Need help with this?

Growthtrait can help you put this into practice. Let's talk about your goals.

Contact us