A document pipeline that runs ten thousand extractions a day fails in two ways. The fields come back wrong, or the fields come back right and the parser rejects them anyway. GPT-6.1 Terra and Claude Sonnet 5.5 separate far more sharply on the second failure than on the first.
In Kingy's pilot from 26 October — six short tasks, two attempts each, medium effort, no tools — both models answered every objective question correctly, 10 of 10. In the exact requested format it was 10 of 10 for Terra and 4 of 10 for Sonnet 5.5. Terra's twelve scored calls cost $0.0203 in credit against Sonnet's $0.0499, and Sonnet was faster per request, 2.83 seconds median against 3.84.
Capability runs the other way. Sonnet 5.5 leads on every computer-use and agent benchmark in this post, including the computer-use chart in OpenAI's own launch material. In Artificial Analysis's harness it also spent $5.46 per task against Terra's $0.40, and 901 seconds per task against 384.
So the engineering decision is not "which model is better". It is which failure your pipeline absorbs cheaply: a rejected line of JSON you can retry in milliseconds, or an unattended desktop run that dies dozens of actions in. Terra is the cheaper answer to the first, Sonnet to the second. Both are served through AIHubMix at the vendors' list prices, so switching between them is a change of model ID — the GPT-6.1 Terra model page has the endpoint details.
One step, priced at list prices
Terra shipped on 26 October 2026, four weeks after Sonnet 5.5 on 28 September. Terra is $1 per million input tokens and $5 per million output; Sonnet 5.5 is $2 and $10. That is the whole of the per-token story, so the useful question is what a step costs once token counts are in it.
Take a step that sends a 2,500-token stable prefix which hits the cache, 1,500 fresh input tokens for the page or screenshot content, and returns 1,500 output tokens. Run it 10,000 times:
| 10,000 steps | GPT-6.1 Terra | Claude Sonnet 5.5 |
|---|---|---|
| Cached input (25M tokens) | $1.25 | $2.50 |
| Fresh input (15M tokens) | $15.00 | $30.00 |
| Output (15M tokens) | $75.00 | $150.00 |
| Total | $91.25 | $182.50 |
Cache writes are left out; they add a little on both sides, at the rates in the spec table below. With token counts held equal the totals differ by exactly 2x, because every rate is doubled.
Held equal is the part to distrust. Artificial Analysis measured Sonnet using about 5.6 times Terra's output tokens per task at max effort, and output is the largest line above, so a real agent workload probably lands wider than 2x. Measure the ratio on your own traffic before you put a number in a budget.
The rates behind the table:
| GPT-6.1 Terra | Claude Sonnet 5.5 | |
|---|---|---|
| Input / output, per million tokens | $1 / $5 | $2 / $10 |
| Cache read | $0.05 | $0.10 |
| Cache write | $1.25 (30 min), $2.50 (12 h) | $2.50 (5 min), $4 (1 h) |
| Context window | 1,050,000 | 1M |
| Max output | 128K | 128K |
| Default effort | medium | high |
Both models take text and images as input, which is what makes the same pipeline possible on either. Sonnet's default effort is the Claude Platform default. Terra bills a whole request at 2x input and 1.5x output once input passes 272K tokens, a threshold one page or one screenshot will not reach; a batched multi-page PDF scan could, so check token counts before reusing the same cost model there.
What the independent run measured
Artificial Analysis ran both models on its own harness. Its Sonnet 5.5 figures are the max-effort configuration with fallback, as AA labels it; Terra's are max effort. These are AA's numbers only, not a blend with anything below.
| Artificial Analysis | Terra max | Sonnet 5.5 max |
|---|---|---|
| Intelligence Index | 48 | 56 |
| AutomationBench-AA | 60% | 72% |
| Terminal-Bench 4.0 | 56% | 64% |
| AA-LCR (long context) | 83% | 83% |
| GDP.pdf | 29% | 26% |
The same run recorded what each model spent to reach those scores:
| AA, max effort | Terra | Sonnet 5.5 |
|---|---|---|
| Cost per index task | $0.40 | $5.46 |
| Output tokens per task | 35k | 197k |
| Reasoning tokens in that | 25k | 147k |
| Time per task | 384s | 901s |
Read the second table as the price of the first. Sonnet bought eight more index points with more than five times the output tokens, each of those tokens at twice Terra's rate. Per task that came to $5.46 against $0.40, with Terra under a tenth of Sonnet's cost and about 43% of the time AA measured per task. That measure counts generation time, not the wait before the first token, and Sonnet's stream is itself the faster one: 141 output tokens a second against Terra's 91 in the same run. Terra's time advantage comes from writing fewer tokens, not from a quicker model. AutomationBench-AA separates them by 12 points; AA's Terminal-Bench run by 8.
Two rows cut against the pattern without reversing it. AA-LCR, a long-context reasoning test, ties at 83%. GDP.pdf, a document benchmark, has Terra ahead 29% to 26%. Neither makes Terra the stronger model. Neither shows Sonnet pulling away the way it does on agent runs.
One caution on the 384-second and 901-second figures: they are per task in AA's index, not a single invoice read, so they say what a hard problem costs in time rather than what one extraction step does.
What the vendors' own charts show
OpenAI's launch post puts Terra against Claude Opus 5.5, not Sonnet. The Sonnet column below is the reference point OpenAI drew in its own charts, as transcribed by Kingy. It is self-reported, and nobody has reproduced it independently. Sonnet 5.5 entries are its max-effort results as shown in those charts; task costs are OpenAI's estimates.
| OpenAI chart | Terra medium | Terra max | Sonnet 5.5 |
|---|---|---|---|
| OSWorld 2.1 offline | 66.7% | 74.2% | 83.9% |
| Terminal-Bench 4.0 | 35.8% | 50.3% | 70.6% |
| Terminal-Bench cost per task | – | $1.84 | $10.44 |
OSWorld 2.1 is the closest public test to a screen agent. On OpenAI's offline set, Sonnet leads Terra at max effort by 9.7 points, and Terra at its default medium effort trails by 17.2.
Anthropic's own Sonnet 5.5 launch page reports a different run of the same benchmark at 80.1%, marked "partial", plus 70.6% on Terminal-Bench 4.0. Four OSWorld 2.1 scores appear in this post and none of them may be subtracted from a score in another run. The 80.1% and the 83.9% come from different setups and are not comparable, and neither should be read against Terra's score from the other vendor's run. What survives the accounting is directional: both vendors' material points to Sonnet 5.5 being strong on desktop and terminal agent work.
Where the output breaks a parser
The pilot comes the closest of anything here to the actual job. Kingy ran six short tasks, two attempts each, at medium effort with no tools. One task pulled fields out of a synthetic invoice image; the others asked for JSON, Python or SQL in an exact format.
| Kingy pilot, medium effort | Terra | Sonnet 5.5 |
|---|---|---|
| Objective answers correct | 10/10 | 10/10 |
| Correct and in exact format | 10/10 | 4/10 |
| Credit for 12 scored calls | $0.0203 | $0.0499 |
| Median request time | 3.84s | 2.83s |
Request times include network and provider delay.
Both models knew the answers. The difference was delivery. Sonnet put arithmetic before the JSON in both attempts at one task, and wrapped its Python and SQL answers in Markdown fences the prompts had prohibited. Six failures out of ten attempts, all of them shape rather than content.
Kingy notes that a production parser or enforced structured output would absorb some of those wrappers, and did not test those fixes. That caveat is fair and it changes the size of the advantage, not its direction: in a loop where code validates every step, a model that returns bare JSON without coaxing removes a repair layer you would otherwise write and maintain. Terra did that in all ten attempts, for about 41% of Sonnet's credit.
Note what the pilot does not say. Sonnet answered faster per request here. Terra's speed case rests on the per-task figures in AA's run, not on latency per call.
Sending the same request to both
Terra's tools, including the built-in computer tool, are documented by OpenAI as a Responses API feature, and in AIHubMix's checks on 27 October a request with the computer tool and a screenshot came back with a computer_call action. Reasoning effort also only took effect on Responses in those checks. AIHubMix's model list shows Sonnet 5.5 on Chat Completions, Responses and Anthropic Messages; Terra answered on all three in AIHubMix's checks on 27 October, so one loop can hit both models. The AIHubMix Responses API docs cover the request shape.
The sample below sends one extraction prompt to both models with the OpenAI SDK and prints the answer and its token usage:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://aihubmix.com/v1",
api_key=os.environ["AIHUBMIX_API_KEY"],
)
prompt = (
"Extract the invoice number, date and total from this text. "
"Return only JSON with keys invoice_number, date, total.\n\n"
"Invoice INV-2041, issued 2026-10-12. Amount due: $1,291.50."
)
for model in ["gpt-6.1-terra", "claude-sonnet-5-5"]:
response = client.responses.create(model=model, input=prompt)
print(f"--- {model}")
print(response.output_text)
print(response.usage)
Run it against a sample of your own screens or documents, count how often each answer parses, and keep the usage lines: output tokens divided by steps gives the ratio to carry back into the cost table.
Failure modes to check before committing
- Effort set on Chat Completions. In AIHubMix's 27 October checks reasoning effort took effect on Responses but not on Chat Completions. If you tune effort, verify the setting on the endpoint you actually call.
- Budgeting with the Batch discount. OpenAI's Batch API discount does not apply on AIHubMix, which does not serve the Batch endpoint. The figures above are standard rates.
- Long-context billing leaking into a document job. Any single request past 272K input tokens bills at 2x input and 1.5x output for Terra. One page is nowhere near it; a concatenated multi-page scan may be.
- Subtracting across vendors. 80.1% from Anthropic and 83.9% from OpenAI's chart are two different OSWorld 2.1 setups. Compare scores only within a run.
- Treating a wrapper as free. A parser that strips Markdown fences is easy to write and was not tested in the pilot. If you add one, measure the parse rate again rather than assuming the gap closed.
- Picking on one anecdote. atomic.chat gave teams of eight agents the same prompt to build a small game: Terra finished in 6 minutes for $1.06, Sonnet 5.5 took an hour and $18.10, and atomic.chat judged Sonnet's game "far better". The test settings were not published, so it is one anecdote and nothing more — though it fits the pattern of the benchmark tables.
What this post cannot verify
OpenAI's charts are self-reported, read second-hand through Kingy's transcription. Anthropic's figures are self-reported. AA is an independent tester, but it is one harness at one effort setting. The pilot is six tasks and twelve calls with no tools, using a synthetic invoice; a real screen agent with a mouse, a browser and retries is a different stress test. Nothing here measures your documents.
Routing rules
Put Terra on the high-volume steps whose output a validator can judge: invoice fields, form entries, the next click on a known screen. A failed step is cheap to retry, the format comes back clean, and cost per step stays predictable as volume grows.
Put Sonnet 5.5 on the runs where nobody is watching each action, where completion rate decides whether the task gets done, and on coding work — it leads Terminal-Bench both in OpenAI's chart and in AA's run. Where a step fails Terra's validation repeatedly, route that step to Sonnet.
Running both costs a model ID per request. For the side-by-side specs and rates, see the Terra vs Sonnet 5.5 compare page.
Keep reading: the GPT-6.1 Terra series
If the benchmark came from a fleet still on GPT-5.6 Terra, the upgrade's own changes come first: GPT-6.1 Terra: A One-Line Model Swap, a 58% Cheaper Bill, and Three Things That Break
Moving the agent to Terra is its own project; the temperature and Responses fixes start here: GPT-6.1 Terra Migration for API Clients: The 400s, the Silent No-Ops, and a Working Codex Config
For the tasks a mid-tier model should not hold at all, the top-tier boundary: Routing GPT-6.1 Terra and GPT-6.1 Sol: The 2x Token Line
And the full billing picture from per-step cost to a worked month: GPT-6.1 Terra Cost Breakdown: Effort Tokens, the 272K Repricing Rule and Cache Writes
Sources
- OpenAI: Introducing GPT-6.1 Terra
- Anthropic: Introducing Claude Sonnet 5.5
- Artificial Analysis: GPT-6.1 Terra vs Claude Sonnet 5.5 comparison
- Kingy: GPT-6.1 Terra: Benchmarks, Pricing & Model Comparisons
- AIHubMix: GPT-6.1 Terra vs Claude Sonnet 5.5 compare page
Top comments (0)