GPT-6.1 Terra vs Claude Sonnet 5.5: Which Mid-Tier Model for Screen and Document Agents?

OpenAI released GPT-6.1 Terra on 26 October 2026, four weeks after Anthropic shipped Claude Sonnet 5.5. OpenAI's launch post set Terra against Claude Opus 5.5, but the coverage drew a different line. The Decoder called Terra "OpenAI's closest competitor to Anthropic's mid-tier Sonnet series at half the price", and AlphaCorp called Terra against Sonnet "the real fight for the mid tier". GPT-6.1 Sol and Sonnet 5.5 share the same $2 / $10 price card, so a team choosing a mid-tier model this month is really choosing between Terra at $1 / $5 and Sonnet at $2 / $10.

This post makes that choice for one kind of work: the screen and document agent. The agent reads an invoice, a form or a screenshot, pulls out the fields, and enters them into another app. Each step is short and checkable, and it runs thousands of times a day. On that task the two models win different things. Sonnet 5.5 finishes more of the hard agent benchmarks, including the computer-use chart in OpenAI's own launch. Terra costs half as much per token, used far fewer tokens per task in independent tests, and followed strict output formats more reliably in one small pilot.

The short version: for high-volume steps whose output can be checked, start with Terra. For long, unattended desktop runs where a failed run costs more than the token bill, Sonnet 5.5 earns its price. Both run on one key through AIHubMix, at the same prices as the vendors' own APIs; the GPT-6.1 Terra model page has the details.

The task this comparison is about

A screen or document agent step usually looks like this:

• Input: a stable prefix (system prompt, output schema, tool definitions) that repeats on every call, plus fresh content: a page image, a screenshot or extracted text.
• Output: a short structured answer, such as JSON fields or the next UI action.
• Volume: thousands to hundreds of thousands of steps, each checked by code before anything is written downstream.

Four things decide the model here: correct fields, output that parses without cleanup, cost per thousand steps, and time per step. Long-horizon completion matters less when every step is short and verified, and a lot when the agent drives a desktop for dozens of actions with nobody watching.

Both models take text and images as input and fit this shape. The specs that matter here:

Prices are official list prices per million tokens; AIHubMix charges the same for both models. 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, which a single-page document step won't reach.

One practical point for screen agents: OpenAI documents Terra's tool calling, including the built-in computer tool, as a Responses API feature. In AIHubMix's checks on 27 October, Terra on the Responses endpoint returned a computer_call action when given the computer tool and a screenshot, so that path works through AIHubMix.

Where Sonnet 5.5 wins: finishing hard agent runs

The benchmark figures below come from three places, kept apart on purpose. OpenAI's launch charts, as transcribed by Kingy, are self-reported and nobody has reproduced them independently. Anthropic's launch figures for Sonnet 5.5 are also self-reported. Artificial Analysis (AA) is an independent tester. Each figure comes with its effort level where the source gives one.

Start with OpenAI's own charts, where Sonnet 5.5 appears as a reference point:

Sonnet 5.5 figures are its max-effort results as shown in OpenAI's charts. Task costs are OpenAI's estimates.

OSWorld 2.1 is a computer-use benchmark, the closest public test to a screen agent. On OpenAI's offline set, Sonnet 5.5 leads Terra at max effort by 9.7 points. Terra at medium, the default, is 17.2 points behind.

Anthropic's Sonnet 5.5 launch page reports its own OSWorld 2.1 run at 80.1%, marked "partial", and 70.6% on Terminal-Bench 4.0. That OSWorld run is a different setup from OpenAI's offline set, so the 80.1% and the 83.9% are not comparable with each other, and neither should be read against Terra's score from the other vendor's run. Both vendors' material points the same way: Sonnet 5.5 is strong on desktop and terminal agent tasks.

Artificial Analysis ran both models on its own harness:

AA's Sonnet 5.5 figures are its max-effort configuration with fallback, as AA labels it.

Independent testing keeps Sonnet ahead on agent work, by 12 points on AutomationBench-AA and 8 on AA's Terminal-Bench run. Two results break the pattern. On AA-LCR, a long-context reasoning test, the two tie at 83%. On GDP.pdf, Terra edges ahead, 29% to 26%. Neither result makes Terra the stronger model, but neither shows Sonnet pulling away the way it does on agent runs.

Do not read any of this as Terra beating Sonnet at computer use. On every computer-use and agent benchmark in this post, Sonnet 5.5 scores higher.

Where Terra wins: cost per task, speed and output discipline

The same AA run measured what each model spent to get its score:

Sonnet 5.5 used more than five times as many output tokens per task as Terra, and each of those tokens costs twice as much. The result is a cost per task under a tenth of Sonnet's ($0.40 against $5.46), and about 43% of the time AA measured per task (384 seconds against 901; AA counts generation time, not the wait before the first token). Sonnet's stream is itself faster, at 141 output tokens a second against Terra's 91 in the same run, so Terra's time advantage comes from writing fewer tokens rather than from a quicker model. Sonnet bought eight more index points with that spend. Whether eight points is worth almost 14 times the cost depends on what a failed step costs you.

OpenAI's Terminal-Bench chart shows the same trade from the other side: 70.6% at $10.44 per task for Sonnet against 50.3% at $1.84 for Terra at max. Kingy put the business question plainly: how much a higher completion rate is worth once retries and human review enter the calculation.

For the screen and document task, the most relevant independent data is Kingy's pilot from 26 October. It was small: six short tasks, two attempts each, at medium effort with no tools. One task extracted fields from a synthetic invoice image; others asked for JSON, Python or SQL in an exact format.

Request times include network and provider delay.

Both models got every answer right. The difference was delivery. Sonnet added arithmetic before the JSON in both attempts at one task and wrapped its Python and SQL answers in Markdown fences, which the prompts prohibited. Kingy notes that a production parser or enforced structured output could handle some of these wrappers, and it did not test those fixes. In a pipeline where code parses every step, though, a model that returns bare JSON without being coaxed saves a retry or a cleanup pass. Terra did that in all ten attempts, at about 41% of Sonnet's credit. Sonnet answered faster per request in this pilot.

One more data point travels widely, and it should be read as exactly 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 weren't published, so it proves nothing on its own, but it matches the pattern above: Sonnet spends more and often delivers more.

What the task costs on each

A worked example at list prices, with the token counts held equal. Take 10,000 document steps. Each step sends a 2,500-token stable prefix that hits the cache, 1,500 fresh input tokens (the page or screenshot content), and gets 1,500 output tokens back.

Cache writes are left out. They add a small amount on both sides, at the write rates in the spec table above.

With identical token counts, Sonnet costs exactly twice as much, because every rate is doubled. Real token counts won't be identical. In AA's run Sonnet used about 5.6 times Terra's output tokens per task at max effort, and output is the largest line in this example, so the real gap on agent work is likely wider than 2x. How much wider depends on your prompts and effort settings; measure it on a sample of your own steps before committing.

One pricing note: OpenAI's Batch API discount doesn't apply on AIHubMix, which doesn't serve the Batch endpoint, so the figures above are standard rates.

Who should pick which

Pick GPT-6.1 Terra when:

• steps are short, many and checked by code: invoice fields, form entries, the next click on a known screen;
• the output must parse without cleanup, and you would rather not add a repair layer;
• cost per thousand steps decides the budget;
• a failed step is cheap to retry or send to a person.

Pick Claude Sonnet 5.5 when:

• the agent drives a desktop for long multi-step runs with nobody checking each action;
• completion rate matters more than the bill, because a failed run costs more than the tokens;
• the same agent also does coding work, where Sonnet leads Terra on Terminal-Bench in OpenAI's chart and in AA's run.

Running both is also an option: Terra on the high-volume extraction and entry steps, Sonnet on the long, hard runs and the cases Terra's output fails validation on. Through AIHubMix that is a change of model ID, not a second integration.

Try both through AIHubMix

Both models run on one AIHubMix key at the official prices. AIHubMix's model list shows Sonnet 5.5 on Chat Completions, Responses and Anthropic Messages, and Terra answered on all three in AIHubMix's own checks on 27 October. Use the Responses endpoint for Terra: OpenAI documents its tools as Responses-only, and in AIHubMix's checks reasoning effort only took effect there. The AIHubMix Responses API docs cover the request format.

The sample sends the same extraction prompt to both models with the OpenAI SDK and prints each 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 on a sample of your own documents or screens, check how often each answer parses, and compare the usage lines: that is your real token ratio. For a side-by-side view of specs and prices, see the Terra vs Sonnet 5.5 compare page.

FAQ

Is GPT-6.1 Terra better than Claude Sonnet 5.5 at computer use?
No. Sonnet 5.5 scores higher on OSWorld 2.1 in OpenAI's own chart (83.9% against Terra's 74.2% at max effort) and on AutomationBench-AA in Artificial Analysis's run (72% against 60%). Terra's case is cost and output format, not capability.

How much cheaper is Terra than Sonnet 5.5?
Per token, half: $1 input and $5 output per million tokens against $2 and $10, and $0.05 against $0.10 for cached input. Per task the gap can be wider, because Sonnet tends to use more output tokens. In Artificial Analysis's max-effort run, Terra cost $0.40 per task and Sonnet $5.46.

Which model is better for invoice and form extraction?
For high-volume extraction checked by code, Terra is the better starting point. In Kingy's small pilot both models extracted the invoice fields correctly and in the requested format. Across all ten objective attempts, though, Terra returned the exact requested format 10 times and Sonnet 4 times, with Sonnet's misses on a separate JSON task and the Python and SQL tasks, and Terra cost about 41% of Sonnet's credit. Test both on your own documents before deciding.

Why do Anthropic and OpenAI report different OSWorld scores for Sonnet 5.5?
They ran different setups. Anthropic reports 80.1% on OSWorld 2.1, marked partial; OpenAI's chart shows 83.9% on its OSWorld 2.1 offline set. The numbers can't be compared with each other, and each should only be read against scores from the same run.

Do both models cost the same on AIHubMix as on the official APIs?
Yes. AIHubMix charges the official list prices for both: $1 and $5 for Terra, $2 and $10 for Sonnet 5.5, per million tokens. OpenAI's Batch API discount is not available, because AIHubMix doesn't serve the Batch endpoint.

Which endpoint should be used to call Terra through AIHubMix?
The Responses API. OpenAI documents Terra's tools, including the computer tool, as Responses-only, and in AIHubMix's checks on 27 October the reasoning effort setting took effect on Responses but not on Chat Completions. Sonnet 5.5 is also served on Responses, so one loop can call both.

Keep reading: the GPT-6.1 Terra series

• If your agent runs on GPT-5.6 Terra today, see what the upgrade alone changes before comparing vendors: GPT-6.1 Terra vs GPT-5.6 Terra: Half the Price, What Changed, and Who Should Switch
• Before moving a screen agent to Terra, fix the parameters and tool calls that break on the switch: Migrating to GPT-6.1 Terra: Fix the temperature 400s, Move Tools to Responses, and Set Up Codex
• If the long desktop runs need more than Terra but you want to stay with OpenAI, compare the tier above: GPT-6.1 Terra vs GPT-6.1 Sol: Which Tasks Still Need Sol?
• To tune the cost table above for your own traffic, work through effort levels and caching: What GPT-6.1 Terra Really Costs: Effort Levels, the 272K Line, and Caching

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