GPT-6 Astra vs Sol vs Terra: What a Small Test Can—and Cannot—Tell You

This comparison covers gpt-6-astra, gpt-5.6-sol, and gpt-5.6-terra. Sol here means GPT-5.6 Sol. Newer GPT-6 Sol models are separate products; results from this test do not transfer to them. The retained model runs date from September 11, 2026. Official specifications and prices below were rechecked on October 7, 2026.

Use this guide when you can select these exact models and need to choose one for an API or coding-agent workflow. The dollar figures are API token rates. If you work through a ChatGPT or Codex subscription, use the models and allowance shown in your account for the budget decision. A model listed in API documentation does not establish what your particular account can select.

Which model should you try first?

These starting points combine the documented model roles with the small test below. For the harder workloads, check the named failure on your own work before adopting the recommendation.

Prices, limits, and features

OpenAI positions Astra for demanding reasoning, coding, research, computer use, and document work; Sol is the GPT-5.6 flagship for complex professional work; Terra balances intelligence and cost. The specifications below come from the linked model pages.

Sol's listed rate is promotional through at least November 21, 2026. Recheck the model page when budgeting work beyond that period. All three model pages specify higher rates when input exceeds 272,000 tokens: 2 times input and 1.5 times output for the whole request. The price examples later use Standard processing and exclude tools, cache writes, and other charges.

Astra's larger generation number does not give it a larger listed context window than these two GPT-5.6 models. Likewise, computer-use support is shared. To justify Astra for a browser workflow, compare successful actions, recovery, and review time in that workflow.

Two GPT-6 features can affect the integration choice. Mid-turn steering lets an application send an update during an active response through the Responses API over WebSocket; GPT-5.6 models lack that support. Steering cannot undo completed actions or cancel a tool that has already started. GPT-6 also introduces async tool calling, which lets the model continue independent work while a tool runs. The application must execute the tool and manage its result, as explained in the async tool guide. Choosing the model alone does not implement either feature.

What the September 11 test actually asked

Each model received the same three fixed prompts and required JSON format in fresh, read-only Codex CLI 0.153.4 sessions. There was one run per model per case, nine outputs altogether. The scoring script, called a grader, was written before the runs and withheld from the model input. The original matched test kit contains the prompts, schema, outputs, grader, timing files, and reported scores.

To reproduce the offline score, unpack the kit and run the following command from its directory. This grades saved answers and makes no model request.

python3 grade.py runs/*/case-*.json

Four records classified under explicit rules

The source task allowed escalation only when severity was P1 and customer impact was confirmed. A verified resolution allowed closure; other records stayed on hold. The records deliberately included a missing fact:

R-101: P1, impact confirmed, resolution not verified → ESCALATE
R-102: P2, impact confirmed, resolution verified     → CLOSE
R-103: P1, impact unknown, resolution not verified  → HOLD
R-104: P3, impact none, resolution not verified     → HOLD

All three outputs used those actions and preserved R-103:customer_impact as unknown. This is relevant to rule-based extraction: a missing value stayed missing. The case did not ask a model to retrieve external evidence, resolve contradictory reports, or discover the classification policy.

A short JavaScript review with three stated requirements

The supplied function treated zero as missing, failed to enforce an integer quantity from 1 through 99, and returned an unrounded product. All three models identified those failures. Astra and Terra suggested a numeric conversion around toFixed(2); Sol suggested a Math.round expression with Number.EPSILON.

The prompt explicitly prohibited code execution, so the outputs show defect recognition and suggested repairs. To judge an actual coding result, apply the proposed patch and check cases derived from the supplied requirements:

These are proposed checks, not results from executed model patches. The prompt did not define every possible input or rounding policy. Decide those requirements before treating this tiny function as suitable for a real billing system.

A revised plan supplied inside the prompt

The third prompt described completed CSV import and date-normalization work, then replaced a planned email with a local report-draft.md containing a "Timezone exceptions" section. Each model returned the requested PRESERVE, STOP, NEXT, and VERIFY actions without claiming the draft had already been created.

The change note was part of the input before generation began. There was no running task to interrupt, no file operation, and no email tool call. This case tests interpretation of a newer instruction in a written plan. It supplies no evidence about API mid-turn steering or stopping a live external action.

How to read the scores and timings

Each model passed 16 text checks, for 48 across the nine outputs. The result shows that these particular outputs satisfied the implemented checks. It gives no estimate of a production acceptance rate, and it does not mean the models have identical reasoning, coding, or writing quality.

The elapsed totals include local startup, network time, and service conditions. The 0.16-second difference between Sol and Terra cannot support a speed ranking. Compare repeated runs under a recorded configuration before choosing a model for a deadline or interactive response time.

The downloadable kit has no token-level billing record or effective reasoning-effort and service-tier record. It also lacks a long-context task, executed tool recovery, visual assessment, or repeated reliability trial. Use it to inspect this dated result; a fresh workload comparison needs those controls recorded separately.

Differences hidden by the equal scores

The saved answers were not identical. Two details are useful when deciding what to check in your own workflow:

All three chose the correct HOLD action for R-104. Astra's explanation also cited the unverified resolution. That field matters because a verified resolution would allow closure even for a P3 record. A checker that scores only the action cannot distinguish those explanations.

For the revised report, the prompt contained no actual rows. Astra and Terra explicitly identified the row information needed to fill the exceptions section; Sol left its missing-information list empty. Its NEXT action still requested the section. These are differences in the retained answers, not estimates of how often any model notices missing evidence. They show why you should read a few outputs beside the scores.

Why a perfect score still needs a grader audit

The source grader checks action labels and whether the missing-impact entry appears in unknowns. It does not verify that the cited evidence matches the records. The code grader looks for defect labels and words such as null, integer, or round; it does not evaluate a repaired function. The plan grader checks ordered prefixes and selected phrases, with a limited phrase filter for false completion.

We reproduced the 48/48 result on October 7, then deliberately damaged copies of two saved answers to check the grader. No new model run was involved:

• Replacing every source answer's evidence with invented_field=unsupported, while retaining its action, still passed all six source checks.
• Changing the plan's NEXT action to save report-draft.md without the required section still passed all six plan checks, because the VERIFY line retained the expected section name.

Both deliberately damaged answers passed. The models did not generate those changes; the result exposes checks missing from the grader.

A stricter source check would compare each evidence field and value with the frozen record. A code check would apply the proposed patch and execute requirement tests. A workflow check would inspect the saved file and tool log. Keep the original grader and scores intact for historical reproducibility, and use stronger checks for a new deployment decision.

How to choose for six common tasks

Structured extraction and high-volume transformations

Terra is a sensible first candidate when each input has a small, explicit rule set and an inexpensive checker. Adapt the source case to your own records: require one output per ID, compare extracted values with the source, and distinguish an unknown value from a negative result. Include records that contain irrelevant instructions, missing fields, or conflicting values.

Keep Terra when its answers satisfy your required rules without more correction than you can afford. Try Sol when Terra repeatedly misapplies a clear rule or introduces facts despite complete inputs. If every model fails the same ambiguous rule, clarify that rule first.

Coding across connected files

The tiny JavaScript case is useful for spotting a defect; it does not represent a repository change. For a Sol-versus-Terra trial, use a real bug with a failing test and dependencies in several files. Give both models the same checkout and tools. Require a patch, evidence that the original failure is fixed, and a check that unrelated behavior still works.

Record whether you had to explain the dependency again, repair an incomplete patch, or remove an unrelated refactor. Add Astra when failures involve difficult dependencies or repeated recovery after a tool problem. Judge the saved patch and test results together.

Reports that combine several sources

Compare Terra and Sol on a report where sources disagree or cover different dates. Require every decisive claim to cite the document and location that supports it. The model should preserve conflicting values until the task supplies a rule for choosing between them. Include an answerable question and one question the documents cannot answer.

Score factual support separately from readability. A fluent report can omit a condition, merge two time periods, or select a number without evidence. Include Astra if these failures persist with clear source instructions. Keep the candidate that produces a report you can use with the least total review work.

Long document collections

All three have the same listed context capacity, so "the documents fit" does not resolve the choice. Build questions that require connecting distant passages, respecting a later amendment, or tracking which source controls a particular decision. Check answers against a human-prepared evidence map.

Run the workload once with the full relevant collection and once with selected passages that preserve the required evidence. That comparison separates model choice from how much material you send. Check the long-context price threshold before adding logs or documents that the decision never uses.

Browser and tool workflows with changing requirements

Use an isolated environment for the first trial. Include a slow read, a failed operation, and a requirement update that arrives after some valid work is complete. Inspect what happened: whether the agent preserved the valid work, waited for needed results, handled the failure, and respected the revised scope.

Astra is the relevant candidate when your application specifically requires the documented steering feature. For a sequential workflow that can accept changes between completed responses, test Sol and Terra as well. In either design, the application needs controls for pending writes. A model's updated plan cannot retract an email that your tool already sent.

Images, screenshots, and visual review

The September test used text only. For a screenshot-based task, give each candidate the same image and ask for a verifiable output, such as a field value with its location or a proposed click that matches a visible control. Include small text, similar controls, and a screen where the requested item is absent.

Count mistaken readings and incorrect actions separately from verbal explanations. A model may describe the intended workflow correctly and still select the wrong element. Image-input support establishes compatibility; the visual task needs its own comparison.

Diagnose the failure before paying for an upgrade

If Terra passes your checker but you reject its answer during review, inspect the checker before changing models. The damaged source answer above shows how a passing score can hide bad evidence. If Terra repeatedly fails a valid check with complete inputs, give Sol or Astra the same failing case.

Compare the models on work you actually need done

Start with a small set of recent work you understand well enough to grade. Include ordinary tasks in their normal proportions and keep a separate group for rare, costly failures. An overall average can hide the fact that a model fails every requirement-change case.

1. Write down what would make the result usable before running a candidate. For extraction, list the expected values and allowed unknowns. For coding, keep the failing test and tests for behavior that must continue to work. For a report, note which source passages support each required claim. Set the maximum correction time you can afford.
2. Keep the input, required output format, tools, and starting environment the same. Record the exact model ID, endpoint or product, client version, reasoning settings, service tier, and output budget. Check supported settings: Astra's API does not accept none reasoning, while the two GPT-5.6 models do. Using low for each model gives you a comparison at the same named setting; it does not guarantee equal computation.
3. Test the checker on deliberately bad answers. A correct-looking source citation with the wrong value must fail. A missing required section must fail. For code, the tests must reject the original faulty function. Keep these checker probes separate from model results.
4. Run each candidate repeatedly in a mixed order, with fresh starting state. Three runs per case can reveal inconsistency, but they cannot establish reliability for a consequential production workflow. Keep failed runs and retries in your comparison records.
5. Inspect outputs without the model label where practical. Record each failed requirement and actual correction minutes. For timing, measure the completed job, including tool waits and necessary retries, under comparable conditions.
6. Keep some cases aside while improving the prompt. Use those untouched cases for the final comparison, so you find out whether the instructions also work on inputs you did not keep correcting.

Use a row like this for each attempt. The job ID links retries to one requested deliverable; the attempt ID preserves the failed work as part of its cost.

Here, accepted means the output passed the required checks and your review. repair_minutes is the time you actually spent correcting it. In an API comparison, service_tier records the processing mode, so the timing and bill are interpretable.

job_id,attempt_id,case_group,model_id,reasoning_effort,service_tier,
input_tokens,cached_input_tokens,cache_write_tokens,billable_output_tokens,
tool_cost,elapsed_seconds,failed_checks,repair_minutes,accepted

Compare both the initial controlled settings and any separately tuned configuration you would deploy. Report them separately if one model uses higher effort or a larger budget. After a prompt change, repeat the checks on old and new cases; the prompt regression guide explains how to maintain that set.

Calculate cost per accepted job

For a simple uncached Standard text request, multiply input and billable output by their respective rates. The following are fixed-input calculations, not measured usage or invoices from the nine retained runs. Each row holds token counts equal to isolate the price difference.

The first Terra calculation is 20,000 / 1,000,000 × $2 + 2,000 / 1,000,000 × $12 = $0.064. The second uses the higher rates on the full request, because 300,000 input tokens exceeds the 272,000 threshold. For Astra that means 0.3 × $20 + 0.01 × $75 = $6.75.

Billable output includes reasoning tokens, even when they are not visible in the final answer; see OpenAI's reasoning-token accounting. If usage reports already include them in output totals, do not add them again. Record cached reads and cache writes separately at the applicable rates. Check the pricing page for processing-mode and tool charges before estimating a real workflow. These API figures also do not establish a ChatGPT plan's cost or a Codex account's per-turn allowance.

Then include rejected attempts and human work:

Cost per accepted job =
  (all attempt charges + tool charges + human correction cost)
  / number of accepted jobs

For example, three Terra attempts at the first row's token counts total $0.192, already above one $0.120 Sol attempt. This arithmetic does not tell us either model's retry rate. It shows why a routing decision needs the attempted work as well as the accepted output.

Suppose, solely for budgeting, correction time costs $30 per hour. Four minutes of correction on a $0.064 Terra request makes the total $2.064; two minutes on a $0.120 Sol request makes it $1.120; one minute on a $0.300 Astra request makes it $0.800. The minutes are hypothetical, not observed model performance. Replace them with your ledger's timings. A cheaper token rate saves money only when the complete workflow preserves that saving.

How much correction time must an upgrade save?

For the 20,000-input, 2,000-output example, Sol costs $0.056 more than Terra. At the same assumed $30 hourly correction rate, that difference equals about 6.7 seconds of your time. Astra costs $0.180 more than Sol, equal to 21.6 seconds. This gives you a break-even check: if your measured correction-time saving exceeds that amount and both results meet the required checks, the upgrade lowers total cost under these assumptions. Recalculate when token use, tools, or your time value differs.

A two-stage route also pays for both stages. If Terra drafts every job and Astra reviews every draft, include both calls and any repeated context. Compare that arrangement with one Sol or Astra pass under the same acceptance rules. Add routing only when it reduces total cost or resolves failures you can identify reliably.

When to keep Terra, move to Sol, or start with Astra

Keep Terra for a type of task when repeated checks and your review find its results usable within your budget. Use Sol when it finishes more tasks correctly or saves enough correction time to cover the measured cost difference. Start with Astra when a required GPT-6 feature rules out the older models, or when your difficult cases show that the added capability pays for itself.

Define escalation using an observable event: a failed source check, a patch that still fails its requirement test, repeated tool recovery that exceeds the time budget, or a missed requirement after one recorded repair attempt. Carry the original task, verified completed work, failure evidence, and remaining scope into the next model's input. If the failure is an unavailable source or broken tool access, fix that dependency first.

Save the chosen model, reasoning settings, escalation trigger, and maximum correction time for each task group. When a new failure appears, add its original input and acceptance check to the comparison set before changing that group's default model.