GPT-6.1 Terra: Benchmarks, Pricing, Specs, and How It Compares

GPT-6.1 Terra arrived on October 26, 2026, with an unusually practical pitch: better visual reasoning, better control of software, and a lower bill. At $1 per million input tokens and $5 per million output tokens, it gives OpenAI a less expensive option for work that involves reading screens, interpreting documents, and moving information between applications. Its position becomes more interesting when you look beyond the headline price.

On OpenAI’s Agents’ Last Exam v1 chart, Terra at medium effort matches GPT-6 Astra at medium effort, with a score of 57.6%, at an estimated $0.29 per task versus $4.82. Yet on Terminal-Bench 4.0, Terra at maximum effort scores 50.3%, below GPT-6.1 Sol’s 55.9% and Claude Sonnet 5.5’s 70.6%. Those results describe different strengths. They do not establish a universal replacement for the more expensive models. OpenAI launch and interactive benchmark charts.

Our launch-day assessment: Terra deserves a serious trial for visual office work and routine agents. For difficult software engineering, scientific reasoning, or an existing workflow that already performs well, the sensible next step is a matched evaluation. The best model depends on the work, the reasoning setting, and the cost of getting an answer wrong.

GPT-6.1 Terra specifications and availability

The API model identifier is gpt-6.1-terra. Terra accepts text and images and produces text. Its published context window is 1,050,000 tokens, with a maximum input of 922,000 tokens and maximum output of 128,000 tokens. Its knowledge cutoff is June 1, 2026. The context window is the total budget; the maximum output is a ceiling, not a promise that every request can fill both input and output limits independently. Official model reference.

Several boundaries matter. Terra can analyze an image without being an image-generation model. It can call an image-generation tool, but that tool has its own model and billing. Similarly, an agent can use Terra to operate video-editing software without the base model accepting a raw video stream. Direct audio and video inputs are not listed as supported on its model page.

OpenAI has not published Terra’s parameter count, active parameter count, model-weight download, or a hardware configuration for running it locally. Claims that it is a particular number of billions of parameters, or that it fits on a particular GPU, would be speculation.

ChatGPT Work, Codex, and the API are different access paths

OpenAI’s launch announcement names Plus, Pro, Enterprise, and Edu users in ChatGPT Work and Codex. API access uses separate token billing. A consumer subscription does not turn the API rates into an included allowance. Availability in Work or Codex also should not be described as availability in every ChatGPT Chat mode or every third-party client. Launch availability.

For the command line, OpenAI specifies Codex CLI 0.159.0 or later and the command codex -m gpt-6.1-terra. An older client may need updating before the model is usable. Enterprise administrators can also control model availability. OpenAI’s model-selection documentation.

The benchmarks show a strong visual worker with uneven advantages

The table below transcribes scores from OpenAI’s launch charts. It preserves the benchmark names and versions and shows medium and maximum effort separately. All entries are vendor-reported; a familiar benchmark name does not turn a vendor’s run into an independent reproduction.

Source: OpenAI’s October 26 interactive charts, including their accessible data labels. “Not shown” means that combination is absent from the chart, not a zero. Percentages in different rows measure different tasks and should not be averaged together.

Agents’ Last Exam v1 is Terra’s strongest cost argument

Professional computer work often mixes several abilities: noticing details in a source file, choosing the right application action, recovering from a failed step, and producing an artifact someone can use. Agents’ Last Exam tests that kind of work. OpenAI’s examples include building from architectural drawings and making a time-coded film log.

At medium effort, the improvement over GPT-5.6 Terra is 15 percentage points while the chart’s estimated cost falls from $0.84 to $0.29. At maximum effort, Terra scores 60.0% at $1.01, versus Opus 5.5’s 63.2% at $8.82. Calculated from those displayed values, the cost ratio is about 8.7 to one. That is a useful result for this workload; it is not evidence that every task becomes nine times cheaper.

The same table gives a reason to keep Luna in the conversation. Its maximum-effort score is lower, at 50.9%, but its displayed cost is only $0.14. A workflow with simple cases and a reliable way to escalate failures may favor different models at different stages. These are design hypotheses to test against your own completion criteria.

MMMU-Pro supports the visual reasoning claim

On the launch chart, Terra reaches 85.5% at maximum effort, compared with 86.3% for GPT-6.1 Sol and 86.7% for GPT-6 Astra. Terra at medium is already at 84.6%. This puts its measured visual reasoning close to the larger OpenAI options on this evaluation.

The inference for users is narrower than “human-level vision.” Product comparisons, dense diagrams, and screenshots are sensible candidates for a trial. Tiny labels, ambiguous images, and consequential interpretations still need verification. A benchmark score cannot establish the correct answer to a specific engineering drawing or medical image.

OSWorld 2.1 leaves room for stronger desktop agents

Terra’s 66.7% at medium effort exceeds GPT-5.6 Terra’s 57.1% at maximum effort in OpenAI’s offline-set chart. But Terra’s own maximum, 74.2%, trails Sol’s 78.0%, Astra’s 80.9%, and Sonnet 5.5’s 83.9%. That is a substantial upgrade from the older Terra without being the highest desktop score shown.

There is also a useful pricing counterexample: at maximum effort, the displayed task costs are $1.19 for Terra and $1.15 for Sol. Lower token rates did not make Terra cheaper on this particular run. The number of tokens and steps used matters as much as the price printed beside the model name.

Coding results favor choosing the effort level deliberately

Terra’s Terminal-Bench 4.0 score rises from 24.8% at low effort to 35.8% at medium and 50.3% at maximum. At medium effort, Sol reaches 52.7%, already above Terra’s maximum. In the chart, Sol medium costs an estimated $1.02 per task; Terra maximum costs $1.84.

For a hard terminal task, “use Terra and turn the thinking all the way up” can therefore be a worse starting point than “use Sol at medium.” This does not erase Terra’s advantage on other workloads. It shows why cost comparisons need an effort setting and a measured task outcome.

Sonnet 5.5’s maximum score of 70.6% is much higher, with a much higher displayed task cost of $10.44. Anthropic also reports that score in its own launch materials. The business decision is how much a higher completion rate is worth once retries and human review enter the calculation. Anthropic’s Sonnet 5.5 report.

Scientific coding shows a different pattern

On Terminal-Bench-Science 0.1, Terra reaches 58.3% at maximum effort, slightly above Sol’s 57.0%, and below Astra’s 68.1% and Opus 5.5 with fallbacks at 63.3%. OpenAI’s displayed costs are $4.15 for Terra, $5.47 for Sol, $23.80 for Astra, and $23.21 for the Opus configuration.

The Terra–Sol difference is only 1.3 percentage points. Without uncertainty intervals and matched reruns, it is too small to justify declaring Terra the better scientific model. The result does justify testing it on scientific coding tasks where cost matters. The word “fallbacks” belongs in the Opus label: a system allowed to fall back can behave differently from a single model call.

Independent benchmarks place Terra below the overall leaders

Artificial Analysis gives GPT-6.1 Terra at maximum effort a score of 48 on Intelligence Index v4.3.2. That is below the selected frontier configurations shown here. It also matches the rounded score for GPT-6.1 Sol at medium effort. These are launch-day observations from the live leaderboard, not a permanent ranking. Terra’s independent model page, full leaderboard.

Artificial Analysis snapshot, October 26, 2026. The last column is its weighted average cost per Intelligence Index task, not cost per million tokens. Scores are rounded as displayed. These rows are selected comparisons, not an exhaustive ranking. Keep “with fallback” attached to the Claude configurations.

The index combines ten evaluations. Its categories are agents, coding, scientific reasoning, and general capability; it is primarily an English-language, text-based suite. Image understanding and multilingual performance are evaluated separately. Terra can be close to Astra on a visual test and still trail it on this broader index without any contradiction. Artificial Analysis methodology.

The cost column is particularly useful. Terra maximum’s displayed $0.40 is lower than Sol maximum’s $0.72. But Sol medium’s $0.21 is lower than Terra maximum’s $0.40 at the same rounded index score of 48. Equal aggregate scores do not mean identical abilities, but this is enough to reject a blanket claim that Terra is always the cheaper route to a given level of quality.

At the time of our snapshot, Terra’s independent output-speed and latency fields were not populated. OpenAI reports more than three times faster completion than Astra and Sol on its professional-task evaluation. We should not convert that task-specific claim into a verified tokens-per-second figure or a universal speed multiplier.

Independent coding results, checked October 26. Artificial Analysis reports Terminal-Bench 4.0 scores of 55.6% for GPT-6.1 Terra max, 56.1% for GPT-6.1 Sol max and 35.4% for GPT-5.6 Terra max. Its setup used mini-swe-agent on 66 tasks, with three repeats, pass@1 scoring and a 500-step limit. These results are separate from OpenAI’s launch table. Artificial Analysis methodology.

Fewer factual errors, with limits that matter

OpenAI’s difficult-prompt evaluation shows a large improvement over GPT-5.6 Terra. At low effort, responses containing any factual error fall from 53.6% to 16.7%. That is a 36.9-percentage-point reduction, or about a 69% relative reduction. At maximum effort, the rates are 22.3% and 4.3%, respectively.

Those are selected, error-prone prompts. They are not an estimate that 4.3% of all Terra answers in everyday use will be wrong. OpenAI’s system card says the cases come from user-flagged factual errors, that it refreshed the evaluation, and that older models were rerun. It also warns against treating those absolute rates as production hallucination rates. System-card factuality methodology.

Independent factuality results, checked October 26. On Artificial Analysis’s AA-Omniscience test, GPT-6.1 Terra max had a 38% hallucination rate and 49% accuracy, versus 88% and 47% for GPT-5.6 Terra max. The test used 6,000 questions without tools. Its hallucination rate divides incorrect answers by all non-correct responses, including partial answers and abstentions. Neither this conditional rate nor OpenAI’s selected-prompt rate is a general production error rate, and the two rates are not directly comparable. Artificial Analysis methodology.

For a research assistant, the practical test is whether citations support the claims, whether the dates are current, and whether the model acknowledges missing evidence. A more accurate model can still produce a fluent answer to a question its training data cannot resolve. Terra’s June 2026 knowledge cutoff makes retrieval especially important for later events.

The safety record includes gains and regressions

OpenAI treats Terra as Critical in cybersecurity capability, High in biological and chemical capability, and below the High threshold for AI self-improvement. These are capability classifications, not a general rating of product safety. OpenAI says it uses the GPT-6 safeguards stack. Its prompt-injection results are encouraging, but no finite test establishes immunity to malicious instructions. GPT-6.1 Terra system card.

The HealthBench results are mixed: professional performance improves, while the broader and hard subsets decline relative to GPT-5.6 Terra. These scores evaluate responses to health-related conversations; they do not validate a model for clinical decisions. Including the regressions gives a more accurate picture than selecting only the improved metric. HealthBench results and length adjustment.

GPT-6.1 Terra pricing, including the costs behind the headline

For standard processing with up to 272,000 input tokens, OpenAI lists $1 per million input tokens, $0.05 per million cached input tokens, and $5 per million output tokens. A 30-minute cache write costs $1.25 per million tokens; a 12-hour write costs $2.50. These are separate billing categories, so cached reads and cache writes should not be conflated. Current OpenAI pricing table.

The long-context threshold applies to the full request once input exceeds 272,000 tokens: input and cache rates double, and output rates rise by 50%. A million-token context window is useful capacity, but it does not mean a million-token prompt is billed at the headline rate. Regional processing adds 10% where available.

Here is an illustrative boundary case. With no caching, 270,000 input tokens and 20,000 output tokens cost $0.37 at standard rates. Increasing the input to 300,000 tokens with the same output costs $0.75 because the request crosses into long-context pricing. Those are calculated token charges, excluding tools and tax.

Current API prices compared with frontier and efficient alternatives

Per one million tokens, standard direct-provider pricing checked October 26. OpenAI rows use prompts up to 272K input tokens. Haiku’s quoted rate applies up to 100K input tokens. Google’s introductory pricing expires on the dates shown. DeepSeek has time-dependent rates. Cache writes, external tools, taxes, regional premiums, and negotiated contracts are excluded.

Sources: OpenAI, Anthropic, Google, Moonshot, and DeepSeek.

Against GPT-6.1 Sol, Terra halves the current input and output rates. Against GPT-5.6 Terra, the current pricing table shows $2 input and $12 output, making the reductions 50% and about 58%, respectively. OpenAI’s launch summary describes a 50% reduction; the detailed table is the better source for estimating an actual bill.

Sonnet 5.5’s cached-input price is now $0.10, following Anthropic’s October 7 reduction. Its September launch page still shows $0.20. Using that older launch figure would overstate a current competitor’s cost. Anthropic’s cache-price announcement.

DeepSeek’s current deepseek-flash endpoint resolves to DeepSeek-V4.1-Flash-1017. Its older Flash aliases also route to that version. The peak window is 01:00–04:00 and 06:00–10:00 UTC on weekdays, excluding Chinese public holidays; other times receive off-peak rates. A comparison labeled merely “DeepSeek V4” can obscure both the version and the price.

What 1,000 requests would cost

Assume each request uses 10,000 uncached input tokens and 4,000 billable output tokens. Across 1,000 requests, that is 10 million input and 4 million output tokens. Holding token counts constant gives the following arithmetic:

This is a price illustration, not a performance test. Different models can tokenize the same text differently, use different amounts of reasoning, and need different numbers of retries. Anthropic explicitly notes that its newer tokenizer can produce about 30% more tokens for the same text than its previous tokenizer; the actual difference depends on the workload. Anthropic tokenizer and pricing notes.

Reasoning tokens also count as billable output. If a request produces 2,000 visible tokens plus 8,000 reasoning tokens, the output bill covers 10,000 tokens, not 2,000. At Terra’s short-context standard rate, that portion costs $0.05. Record the usage object instead of estimating cost from the length of the final answer. OpenAI reasoning-token billing.

For an agent, an even better metric is cost per accepted result: total model, tool, and review costs divided by the number of outputs that meet the acceptance criteria. Cheap failed attempts can be expensive. Expensive successful attempts can also be wasteful when a smaller model would have passed.

How Terra compares with open-source and open-weight models

Terra has no public model weights. Running its API from your own computer is still remote inference. If you need local execution, custom weight modifications, or direct control of the serving stack, the alternatives below answer a different requirement from the OpenAI API.

Weights and architecture information come from the developers’ model cards: DeepSeek-V4.1-Flash, GLM-5.3, Kimi K3, and Qwen3.8-27B. A released checkpoint and a hosted endpoint should not be assumed identical without a version match.

“Open source” and “open weights” should not be used interchangeably. Public weights let you inspect and deploy a checkpoint under its license. They do not automatically give you the complete training data, training pipeline, or unrestricted commercial rights. DeepSeek’s card uses MIT and Qwen’s uses Apache 2.0; Kimi K3 and GLM-5.3 have their own licenses. Read the actual license for your deployment.

DeepSeek-V4.1-Flash is a direct value competitor

DeepSeek’s current Flash line combines image input, a million-token context, downloadable weights, and low API prices. Its developer reports 552 billion backbone parameters, with different active-parameter counts during prefill and decoding. Those details cannot be compared with a guessed Terra parameter count, because OpenAI has not disclosed one.

The independent index gives DeepSeek V4.1 Flash 1017 at max a rounded 45, versus Terra max at 48. That gap does not settle document extraction, coding, or visual workflows individually. It makes DeepSeek a relevant model to include in a task-specific trial, particularly if hosting flexibility or a low input price matters.

DeepSeek also reports 51.8% on Terminal-Bench 4.0 in its own card. That figure sits close to Terra’s 50.3% in OpenAI’s chart, but the runs come from different organizations and agent setups. Treat the apparent proximity as a reason to compare them under one harness, not as a proven head-to-head result. DeepSeek’s benchmark table and methodology.

Kimi K3.1 Pro is available through the API; its weight release is still promised

Kimi K3.1 Pro is another serious comparison: Artificial Analysis lists it at 55, and Moonshot’s current API table lists $2 input and $10 output per million tokens. Its high-speed option costs $4 and $20. But Moonshot’s documentation says the full K3.1 Pro weights will be released by November 4. As of this article’s October 26 check, that is a future commitment, not a completed weight release. K3.1 Pro documentation, current pricing.

The existing downloadable Kimi K3 is a different checkpoint. Its 2.8 trillion total parameters, 104 billion active parameters, and custom license are documented, but K3.1 Pro’s results should not be assigned to it. This distinction matters if you are deciding what you can deploy today.

Smaller models can win a different economic argument

Qwen3.8-27B is much smaller than the largest open-weight models. Its independent maximum listed configuration, xhigh, scores 34 in our selected snapshot. That is well below Terra maximum, but an aggregate leaderboard does not price the value of offline operation, control over data, or a task that a smaller model already handles reliably.

For scale, 27 billion parameters at exactly four bits each would occupy 13.5 GB before quantization metadata, runtime memory, vision components, and the context cache. That is a theoretical weight calculation, not a tested hardware requirement. Long contexts can materially change the memory budget. A downloadable model is not automatically an easy or inexpensive local deployment.

The open-weight decision should include hardware utilization, electricity, engineering time, updates, monitoring, and actual throughput. An owned server that sits idle and a remote API that is charged only when used have different cost structures. Neither has a universal advantage.

Which model fits which work?

Terra versus GPT-6.1 Sol and GPT-6 Astra

Terra’s most persuasive use cases involve visual information and frequent, repeatable actions: reading screenshots, matching a product photo to a catalog, interpreting a document layout, or moving reviewed data into an application. These tasks fit the strengths shown in OpenAI’s launch evaluations. The lower token rates also make it easier to afford retries or a second verification pass.

Sol remains a strong comparison for repository work. Its medium-effort Terminal-Bench result exceeds Terra’s maximum-effort result in the launch chart. Astra offers a higher ceiling on the broad independent index and the scientific-coding evaluation, at a much higher per-token price. The economic question is whether that additional capability prevents enough failed work to justify the bill.

Terra versus Claude Sonnet 5.5, Opus 5.5, and Fable 5.1

Sonnet and Opus remain important options when coding completion and long-running professional work dominate the workload. The independent table’s strongest Claude rows include fallbacks, which must stay visible in any comparison. Fable 5.1 is a higher-priced frontier option, with standard input and output rates of $10 and $50 per million tokens.

For a team already using Claude, a switch should preserve the same repository, prompt, available tools, test suite, and stopping rules. Comparing a short Terra run with a Claude run that can use a larger budget or different fallback behavior mainly measures the setup. It tells you less about which model is best for the team’s work.

Terra versus Gemini 4 Argon and Gemini 3.8 Flash

Gemini 4 Argon scores 53 at high effort on the selected independent index, compared with Terra’s 48 at max. It also supports text, images, audio, video, and PDF inputs. Its documented long-decode option extends output beyond its ordinary synchronous limit. That can matter when the application needs native audio/video input or very long output. Gemini 4 Argon specifications.

Gemini 3.8 Flash is a lower-priced alternative at its current introductory rates. However, Google says it can use more tokens on long, complex tasks, and its independent high-effort score in our snapshot is 41. Compare the actual task bill and the output, then account for the stated end of introductory pricing. Gemini 3.8 Flash guidance.

Terra versus Luna and Haiku

GPT-6 Luna and Claude Haiku 5.5 start at $0.10 input and $0.50 output per million tokens under their stated short-input conditions. For high-volume extraction, routing, and classification, that is a significant reason to test them first. Terra becomes more attractive when better visual interpretation or more capable multi-step reasoning reduces failures enough to cover its higher rate.

A practical architecture can send well-defined tasks to a cheaper model and escalate uncertain cases. The escalation rule should use evidence such as failed validation, conflicting source fields, or an unmet test, rather than trusting a model’s self-reported confidence alone. Track whether the combined system improves accepted-output cost.

Writing quality needs its own evaluation

OpenAI positions Terra as a clearer, more natural writer. That is worth testing, but the headline vision and coding scores cannot establish a house-style preference. Give candidate models the same source packet and brief, hide the model labels, and have editors assess factual fidelity, structure, voice, unnecessary repetition, and time spent revising.

For a publishing workflow, a draft that sounds polished but weakens a qualification can create more work than a less elegant draft with accurate sourcing. Measure the editing burden alongside preference scores. We are not presenting this article as proof of a blinded writing test.

Our seven-model pilot: correct answers, uneven output formatting

Tested October 26, 2026. Kingy ran 84 scored API attempts: six short tasks, twice each, across GPT-6.1 Terra, GPT-6.1 Sol, Claude Sonnet 5.5, Claude Opus 5.5, Gemini 4 Argon, Kimi K3.1 Pro and DeepSeek V4.1 Flash 1017. Five tasks had objective answer checks; the sixth was a tightly specified rewrite. Eight additional compatibility attempts included one failed connection and its manually initiated replacement.

Terra and Sol both passed all ten objective attempts in the exact requested format. Terra’s 12 scored calls used $0.0203 of API credit, compared with Sol’s $0.0380. Kimi also passed all ten in the requested format. These small tasks reached a ceiling on content accuracy: all 69 objective answers that arrived passed the substantive checks. The remaining objective attempt received a provider error. This pilot supports a narrow cost-and-delivery comparison; it does not establish an overall intelligence ranking.

The content column permits removal of a Markdown wrapper or explanatory preface while retaining the answer unchanged. The exact-format column requires usable JSON, Python or SQL as requested. Writing compliance is a separate AI-assisted assessment. * DeepSeek’s reported cost excludes an unresolved failed request, for which we retain a further $0.0110 maximum reservation. Timings include network and provider delay and are not intrinsic model speeds.

What the tasks actually checked

The source-packet task required correct API-cost arithmetic and explicit limits on what the sources proved. The Python task repaired one cents-allocation function, including integer precision, stable ties and invalid inputs. The SQL task calculated net revenue while avoiding duplicated revenue from multiple refunds. The image tasks extracted a synthetic invoice and read a synthetic chart with a nonzero vertical baseline.

All 14 Python answers passed the 79 validation cases after Markdown fences were removed where present. All 14 SQL answers passed the original dataset and four held-out variants under the same treatment. All 14 invoice answers preserved the correct $1,291.50 total, returned null for an obscured bank reference and ignored the misleading instruction embedded in the image. All 13 returned chart answers passed; the other attempt received an HTTP 503 from the selected Fireworks route for DeepSeek. That is a delivery failure, not an incorrect chart answer.

Why the two result columns differ

Twelve correct objective answers arrived in a format that the prompt prohibited. Sonnet added arithmetic before the JSON in both source-packet attempts, and wrapped both Python and both SQL answers in Markdown fences. Opus wrapped its two SQL answers. Gemini wrapped both Python and both SQL answers.

Removing only the outer fences raises usable objective answers from 57 to 67 out of 70 attempts. Manually checking and extracting the two prefaced Sonnet JSON answers raises the content count to 69. No model answer was rewritten, and no scored failure was rerun. A production parser could handle some of these wrappers, or an integration could enforce structured output. We did not test those remedies, so the table preserves both the strict and content-only views.

The writing task did not establish a preferred writer

All 14 rewrites retained the fictional source note’s material facts and qualifications and met our 100–140-word check. That includes attributing the vendor’s timing claim, preserving the missing independent replication and error data, retaining human approval, and saying Kingy had not tested the fictional product. A short, heavily constrained rewrite is a weak test of broader editorial quality.

Writing was assessed against a fixed rubric by the OpenAI assistant conducting this study. Model names were hidden in the scoring view, but the operator could see provider identities during execution. This was not an independent or fully blinded human preference study. The small style-score differences in the audit do not support a buying recommendation.

Cost, settings and limits

The complete run used $0.393 in reported API credit, including compatibility checks. Ninety retrievable generation receipts matched the recorded charges. Two unsuccessful requests had no attributable generation receipt: the initial Sonnet connection reset and the DeepSeek 503. We retain $0.121 in combined maximum reservations for them. Adding a 35% contingency gives a conservative accounted amount of $0.693, within the approved $10 ceiling. These are credit-use records and reservations, not a $0.693 invoice. We used existing prepaid credit and bought no top-up.

Every candidate received the same task inputs in a fresh single request, with medium reasoning requested, a 6,144-token output ceiling, no tools or live retrieval, and no provider fallback. The exact IDs, routes, declared snapshots, randomized order and usage objects are in the audit. Kimi used Moonshot’s MXFP4 route; DeepSeek used Fireworks. A shared effort label does not mean equal internal computation. Automatic cache hits occurred, so these costs and timings are not a cold-cache comparison.

Objective checks used local validation, including isolated code execution with network disabled. Two prefaced JSON answers also received a manual content review by the same assistant. Two repeats of five objective tasks are still only five distinct problems. This study does not test full repository repairs, autonomous desktop operation, long-context reliability, live research or production traffic. The existing vendor and independent benchmarks above retain their original dates and methods.

For short work with outputs you can validate, Terra earned a place in a practical trial: it matched Sol on these selected outcomes at lower observed cost. DeepSeek used less reported credit, with one provider failure in this small sample. For harder work, use a representative task set and measure completion and rework before changing models.

Download the public audit: prompts, synthetic inputs, final answers, scoring and cost records (ZIP). It excludes credentials, account balances and private reasoning traces. For a different, multi-step experiment, see our earlier coding and research study; its results cannot be pooled with this pilot.

Developer setup and an evaluation plan that can settle the choice

For new integrations, the Responses API is the relevant route, especially for tools. The official Terra guide supports none, low, medium, high, xhigh, and max, with medium as the default. Start with the same effort as your existing Terra workflow before changing other variables. Terra migration guidance.

This minimal Python example illustrates a request and the usage fields to record. It has not been executed as part of this review and will incur API charges if you run it with your credentials.

from openai import OpenAI

client = OpenAI()
response = client.responses.create(
    model="gpt-6.1-terra",
    reasoning={"effort": "medium"},
    input="Summarize this supplied report and flag unsupported claims: ...",
    max_output_tokens=4000,
)

print(response.output_text)
print(response.usage)
print(response.status)

Handle incomplete responses and tool failures explicitly. A token budget covers reasoning as well as visible output, so a run can exhaust its allowance before producing the artifact you expected. For tool workflows, validate the requested action and inspect the resulting file or application state; a confident completion message is insufficient.

A useful first comparison

Build a small, fixed set of representative tasks from your own work. The following broader evaluation design goes beyond the short API pilot above; Kingy has not run these full workflows:

Run Terra at medium and max, Sol at medium, and your current production model. Add an open-weight candidate when local deployment is a real requirement. Keep tools, time limits, input assets, retry rules, and acceptance criteria constant. Include difficult examples and cases that should be rejected or handed to a person.

Report task success, critical errors, wall-clock time, total billed input and output, and review time. Repeated runs help distinguish an occasional lucky result from a dependable workflow. If a model passes 19 of 20 cases once, treat that as a small-sample observation; it does not establish 95% reliability on future traffic.

Benchmark comparisons to reject

• Different benchmark versions. Kimi K3’s published Terminal-Bench 2.1 score and Terra’s Terminal-Bench 4.0 score come from different tests. Their percentages cannot rank the models directly.
• Different computer-use protocols. OSWorld-Verified, OSWorld 2.1’s offline set, and Agents’ Last Exam’s CLI and visual setups can test different behavior. Preserve the exact variant.
• Hidden effort or fallback changes. Medium, max, tool-assisted, and fallback-enabled runs are different configurations, even when the base model name matches.
• Price per token presented as cost per completed task. Token consumption, caching, failures, and external tool charges can reverse the apparent ordering.
• An index point treated as a percentage of intelligence. A score of 48 versus 53 does not mean one model is “9% less intelligent.” It is a difference on one composite scale.

For a first deployment decision, choose a task where the output can be checked and the work can be reversed. Terra is a compelling candidate when visual reasoning and repeated application work dominate. Keep Sol, Claude, Gemini, and open-weight alternatives in the evaluation when their strengths or deployment options fit the actual job.

Developing-story updates and source notes

This article will track material changes during the first 72 hours: corrected specifications or pricing, new independent evaluations, meaningful availability changes, and documented issues that affect the assessment. We will preserve the dates and methods attached to benchmark results instead of presenting an old test as a fresh measurement.

• October 26, 2026 · independent evidence added. Added Artificial Analysis’s separate Terminal-Bench 4.0 and AA-Omniscience results, with their methods and limits. The existing OpenAI results remain unchanged.
• October 26, 2026 · short summary added. Added the 100-word newsletter version at the top of this article, linking to the full pilot and audit. Test results and their original dates are unchanged.
• October 26, 2026 · original paid pilot added. Added 84 scored API attempts across seven models, separate content and format results, an AI-assisted rewrite assessment, cost reconciliation and a public audit download. Earlier benchmark observations retain their dates.
• October 26, 2026 · initial publication. Confirmed the launch, transcribed the six OpenAI benchmark charts, checked the independent Intelligence Index, compared current API prices, and distinguished released open weights from Kimi K3.1 Pro’s promised November 4 release.

Methodology. Official documentation and developer model cards establish specifications, prices, and licensing labels. OpenAI’s launch charts establish what OpenAI reports; Artificial Analysis supplies the independent index and its task-cost figures. The seven-model pilot reports Kingy’s own measurements as described above. Other dollar examples and ratios are calculations from the cited sources, not invoices or performance measurements. Scores from unlike benchmark versions are kept separate. No vendor supplied Kingy with private evaluation access for this article.

Related Kingy reading: How to choose an AI inference provider and the developing Claude Fable comparison.