There are already plenty of GPT-6.1 Terra reviews. I wanted to understand where it fits in today's AI menagerie and which tasks make it worth choosing. To do that, I collected comments from an OpenAI employee, independent benchmarks ranging from programming to solving a Rubik's Cube, and visual comparisons of 3D work: the results, the time taken, and the cost.
OpenAI released GPT-6.1 Terra as a fast, economical model for everyday work. It sits between Sol and Luna in the lineup, handling a high volume of tasks: understanding documents and screens, acting in applications, and writing text and code. The model is already available in GPTunneL.
The article covers OpenAI's findings, including an employee's explanation of where the model is useful, a summary table of independent benchmarks, a closer look at those tests, and examples of Terra 6.1 working with a computer and 3D scenes.
I will start with the main takeaways:
Terra 6.1 performs unevenly across benchmarks. In some, it is around the level of DeepSeek V4.1 1017; in others, it comes close to Astra 6 and Sol 6.1, particularly in computer use and vision. The Rubik's Cube test illustrates this especially well. Its cost per task similarly falls between DeepSeek V4.1 1017 and Sol 6.1. Speed is another strength: Terra completes some tasks substantially faster than the larger models. Sol and Sonnet perform better on complex programming; Terra's reasoning effort settings also need testing separately.
I asked Terra 6.1 to draw a forest beside a lake in Paint. The drawing was ready in 2.5 minutes. It used about 12% of the five-hour usage allowance on a Plus subscription.

Terra 6.1's drawing in Paint.
OpenAI highlights four areas in the release:
- Screens and images. Terra is intended to understand visual material and move from understanding to action: reading drawings, filling out forms, and transferring invoice data into an accounting system. Controlling applications requires connected tools.
- More natural writing. The company promises clearer writing for everyday communication, such as drafting proposals.
- Programming. OpenAI claims a significant improvement over GPT-5.6 Terra, including tasks that an agent handles through the command line.
- More work within usage limits. According to OpenAI, the same usage allowance in ChatGPT Work and Codex covers more tasks than with GPT-5.6 Terra, and substantially more than with GPT-6.1 Sol or GPT-6 Astra.
OpenAI's release posts repeat that emphasis: speed, working across applications, and efficiency throughout the working day. Thibault (@thsottiaux) also highlights coding improvements, a stronger personality, and a more nuanced understanding of requests. These are the developers' assessments; below, we compare them with independent tests.
Where Terra fits in the lineup: an OpenAI employee's explanation
The key question is where to use Terra 6.1. The following data helps explain why that is not straightforward:

The chart shows Terra 6.1 Max entering the green area that balances intelligence and cost. But nearby are larger Sol models at different reasoning effort levels, some with a lower cost per task.
Does that leave Terra without a role? Of course not. An OpenAI employee points out that models trained later can benefit from newer data, methods, or architectures. In particular tasks, Terra can therefore match more powerful models while costing less.
OpenAI employee Ted Sanders explained on Hacker News that Luna → Terra → Sol → Astra remains the general starting point for choosing a model. If quality matters above all else, he recommends Astra; for moderate budget constraints, Sol; for tighter budgets, Terra or Luna. This is a broad guide: a newer, smaller model may outperform a larger one in individual tasks.
In Sanders' assessment, GPT-6.1 Terra is probably better than Sol and Astra at technical communication, roughly comparable in vision and computer use, and noticeably faster. He says it is slightly weaker at most other things. For developers, he describes Terra as a middle option between Luna and Sol, especially interesting for images, interfaces, and communication. This is an OpenAI employee's assessment rather than an independent comparison.
For subscribers, Sanders sees the release as a useful addition: Terra may help stretch usage limits, communicate more clearly, or work with a computer faster. He does not claim that it generally outperforms the larger models. For deep research and the most complex programming, OpenAI recommends GPT-6.1 Sol or GPT-6 Astra.
Sanders also makes an important distinction: model size, reasoning effort, and the number of agents are different ways to scale. Selecting Max for Terra and switching from Terra to Astra change different parameters; reducing both to a single intelligence scale would be misleading.
OpenAI's tests: computer use and vision
In the GPT-6.1 Terra release, OpenAI highlights three tests that explain its emphasis on images and applications. These are the company's main findings.
| Benchmark | What it measures | What OpenAI reports about GPT-6.1 Terra |
|---|---|---|
| Agents’ Last Exam v1 | Professional computer tasks, such as creating a 3D model from architectural drawings or making a timestamped film scene log | On Medium, the result is 15 percentage points higher than GPT-5.6 Terra. The company also reports reaching GPT-6 Astra's level |
| MMMU-Pro (vision) | Reasoning based on visual information | Terra beats GPT-5.6 Terra at every reasoning effort setting and nearly matches GPT-6 Astra and GPT-6.1 Sol |
| OSWorld 2.1 | Completing multistep tasks in desktop applications | Even on Medium, the new Terra beats GPT-5.6 Terra's best result |
Source: OpenAI. These are the model developer's results. Reasoning effort settings matter; percentage points describe an absolute difference between scores.
Agents’ Last Exam v1

Agents’ Last Exam v1: the light green GPT-6.1 Terra line sits above the previous Terra's line at a lower cost per task.
For Agents’ Last Exam, the company makes a separate speed claim: on Max, Terra completes tasks more than three times faster than GPT-6 Astra and GPT-6.1 Sol. This applies to OpenAI's test conditions and does not promise the same speedup in every application.
MMMU-Pro (vision)

MMMU-Pro: the new Terra narrows the gap to Sol and Astra in visual reasoning.
OSWorld 2.1

OSWorld 2.1, offline set. On all three charts, higher means better performance and further left means lower cost. Source: OpenAI; costs reflect its test conditions rather than GPTunneL pricing.
These tests explain Terra's positioning: seeing the material it is working with and taking action in applications. They complement the general intelligence index and coding tests. Independent measurements help show how much of this picture holds outside OpenAI's environment.
Terra, Sol, Sonnet and DeepSeek: summary comparison
The main results and costs per task are collected in one table. Reasoning effort settings appear beside the scores; costs in each row refer to that test and those model configurations.
Here is 6.1 Terra vs 6.1 Sol vs Sonnet 5.5 vs DeepSeek V4.1 Flash 1017.
| Metric | GPT-6.1 Terra | GPT-6.1 Sol | Claude Sonnet 5.5 | DeepSeek V4.1 Flash |
|---|---|---|---|---|
| AA Intelligence Index, points ↑ | 48 (Max) | 52 (Max) | 56 (Max, fallback) | 45 (1017, Max) |
| AA Cost per Task ↓ | $0.40 | $0.72 | $5.46 | $0.26 |
| AA Coding Agent Index v2.0, points ↑ | 48 (Xhigh) | 54 (Max) | 59 (Max) | 46 (High) |
| Terminal-Bench 4.0, tasks solved ↑ | 50.3% | 58.18% | 70.6% | No data in this snapshot |
| Agents’ Last Exam v1, pass@1 ↑ | 60% | 58.6% (Max) | No data in this snapshot | 35.4% (1017) |
| Bug Hunt Bench, fixed out of 105 ↑ | 40.7 (Max) | 44.3 (Max) | 51.3 (Max) | 39.2 (1017, High) |
| Noahbench, 20-task set ↑ | 50% | 61% | 52% | 55% (1017) |
| Cube Arena Index, Fast ↑ | 60.5 (Max) | 56.0 (Xhigh) | 59.0 (High) | 18.5 (Max) |
| Arena WebDev, Score ↑ | 1671 ± 16 (Max) | 1752 ± 11 (Max) | 1769 ± 11 (Xhigh) | 1666 ± 8 |
| Arena WebDev, Cost/Task (P50) ↓ | $0.41 | $1.61 | $2.95 | $0.13 |
↑ means higher is better; ↓ means lower is better. Bold marks the best numerical value among the configurations shown in each row. AA Cost per Task is the weighted average cost of an Intelligence Index task; Arena Cost/Task (P50) is the median cost of a WebDev task. These use different task sets and measures, and are not GPTunneL prices.
Coding Agent Index v2.0 combines FrontierCode v1.1, Terminal-Bench 4.0, and SWE-Atlas-QnA-AA. It evaluates the model together with its agent environment: Terra and Sol use Codex here, Sonnet uses Claude Code, and DeepSeek uses DeepSeek Harness.
The separate Terminal-Bench 4.0 row reflects a published summary of results, rather than one Artificial Analysis run. It does not specify reasoning effort levels or run conditions, so these percentages should not be mixed with the individual Terminal-Bench measurements within Coding Agent Index.
The Agents’ Last Exam v1 row uses pass@1: the share of tasks fully completed on the first attempt, with no partial credit. GPT-6.1 Sol Max scores 58.6%; this should not be confused with the previous GPT-6 Sol's 56.4%. For reference, Claude Opus 5.5 Max scores 63.2%, but its result has not been placed in Sonnet's column. The results table does not specify Terra's or DeepSeek's reasoning settings.
Terra's position depends on the task: it trails Sol and Sonnet in AA's general index, beats the configurations shown for them in Cube Arena, and costs substantially less in WebDev while scoring lower. This table can help choose a use case and setting, but adding scores from different tests into a single ranking would be invalid. The methods, charts, and limits of each comparison are discussed below.
What independent tests show
Terra has already been tested outside OpenAI. These tests help reveal where it approaches Sol and where a gap remains.
Reasoning effort matters when comparing models. The API defaults to Medium for Terra and Sol, and High for Claude Sonnet 5.5. Running them as supplied may therefore compare different settings. For my own test, I would specify the settings, give the models the same tasks and tools, and define success in advance. Identically named settings from different developers do not necessarily imply the same amount of computation.
Artificial Analysis: the overall Intelligence Index
Start with the overall assessment. Artificial Analysis Intelligence Index v4.3.2 combines ten tests covering documents, knowledge and reasoning, science, programming, and actions in applications. AA's chart places Terra among models from different developers:

Artificial Analysis chart dated October 26, 2026. The purple arrow in the upper panel marks the move from the previous Terra to the new one; higher scores are better. The lower panel compares the index with costs under AA's test conditions, rather than GPTunneL prices.
Here is Terra alongside neighboring OpenAI models:
| Model | Reasoning effort | Intelligence Index, points |
|---|---|---|
| GPT-6 Astra | Max | 53 |
| GPT-6.1 Sol | Max | 52 |
| GPT-6.1 Terra | Max | 48 |
| GPT-5.6 Terra | Max | 42 |
| GPT-6 Luna | Max | 38 |
Higher is better. Rounded scores from Artificial Analysis model pages, checked on October 27, 2026. Every row uses Max. This is a composite index, not a percentage of correct answers.
The new Terra gains 6 points over its predecessor. It remains 4 points behind Sol and 5 behind Astra. To me, that is a reason to try Terra for everyday tasks while keeping the larger models for work where a stronger result matters most.
Quality and cost per task
The next chart shows how Terra's balance of quality and cost changes with reasoning effort:

Artificial Analysis chart. The vertical axis is the overall Intelligence Index, where higher is better; the horizontal axis is weighted average task cost in AA's tests, where further left is cheaper. The horizontal scale is logarithmic. Costs reflect AA's conditions rather than GPTunneL prices.
Compare quality and Cost per Task for four models on Max:
| Model | Intelligence Index | AA Cost per Task |
|---|---|---|
| GPT-6.1 Terra | 48 | $0.40 |
| GPT-6.1 Sol | 52 | $0.72 |
| Claude Sonnet 5.5 | 56 | $5.46 |
| DeepSeek V4.1 Flash 1017 | 45 | $0.26 |
AA Cost per Task is the weighted average cost of an Intelligence Index task. Sonnet 5.5 uses standard fallback. AA model pages checked on October 27, 2026; costs reflect AA's conditions, not GPTunneL prices.
The dotted line marks the Pareto frontier: among the configurations shown, a higher index cannot be obtained for the same or lower cost. Terra's Low and Medium settings sit on that frontier. Artificial Analysis confirms this.
The chart suggests three conclusions:
- Low and Medium offer the best balance of quality and cost in this comparison. They score roughly 36 and 41 respectively. High, Xhigh, and Max score higher, but fall below the efficiency frontier among the models shown.
- The final few points cost substantially more. Moving from High to Max lifts the index from roughly 44 to 48, while task costs on the chart roughly triple. Max gives Terra its best result, but the quality gain comes with a substantial increase in spending.
- Disabling reasoning does not save money here. Non-reasoning sits below and to the right of Low: about 33 points against 36, at a higher cost per task. Less reasoning alone does not guarantee a cheaper solution.
For me, that supports starting an everyday task on Low or Medium and increasing effort if the quality is insufficient. This conclusion comes from AA's overall index: specific coding and computer-use tasks should be tested separately, and this chart says nothing about completion time.
Programming and factual answers
The separate Coding Agent Index v2.0 evaluates coding agent tasks:
| Model | Coding Agent Index v2.0, points |
|---|---|
| GPT-6.1 Sol | 54 |
| GPT-6.1 Terra | 48 |
| GPT-6 Luna | 31 |
Higher is better. These are composite index points, not a percentage of bugs fixed. Source: Artificial Analysis, October 26, 2026.
On this measure, Terra is considerably stronger than Luna but does not match Sol. The gap to Sol is 6 points; that cannot be translated into “6% worse at coding,” because the index uses a different scale.
The researchers also tested the tendency to invent an answer in AA-Omniscience:
| Model | Guessing when the model does not know the answer |
|---|---|
| GPT-5.6 Terra | 88% |
| GPT-6.1 Terra | 38% |
Lower is better. Source: the same Artificial Analysis report dated October 26, 2026. This measure concerns questions the model cannot answer, rather than all requests.
Both parts of the result are useful to me. Terra has improved over its predecessor, but that does not remove the need to check facts. Nor do these data support replacing Sol for every task simply because Terra's rate is lower.
Arena AI WebDev: user preferences in web development
WebDev Arena compares model outputs on web development tasks, including interface creation and multistep tool use. Rankings are based on user preferences between results. Score is a relative rating, not a percentage of tests passed or a review of all code quality.

WebDev Arena results. Score is the rating, Votes is the vote count, and Rank Spread is the range of plausible ranks given uncertainty. Cost/Task (P50) is median task cost under Arena's conditions, not GPTunneL pricing.
| Model | Effort | Score | Rank | Rank Spread | Votes | Cost/Task (P50) |
|---|---|---|---|---|---|---|
| Claude Sonnet 5.5 | Xhigh | 1769 ± 11 | 3 | 2-4 | 4 435 | $2.95 |
| GPT-6.1 Sol | Max | 1752 ± 11 | 4 | 3-5 | 4 073 | $1.61 |
| Claude Sonnet 5.5 | High | 1711 ± 9 | 7 | 6-8 | 6 341 | $1.25 |
| GPT-6.1 Terra | Max | 1671 ± 16 | 14 | 8-19 | 1 615 | $0.41 |
| DeepSeek V4.1 Flash | Not specified | 1666 ± 8 | 15 | 10-19 | 7 489 | $0.13 |
These figures refer to this ranking snapshot. Sonnet High and Xhigh are shown separately because reasoning settings affect results. DeepSeek's full dated version name and effort setting are not visible in this table fragment.
Terra scores lower here than GPT-6.1 Sol Max and either Sonnet 5.5 setting. The difference between Sonnet Xhigh and Sol Max is smaller: Sonnet has a higher central score, but the score intervals and rank spreads overlap. Arena's method explicitly uses Rank Spread to distinguish the current score position from uncertainty about rank.
This ranking complements bug-fixing tests by showing which web outputs users prefer. It cannot establish backend reliability, security, or how easy a project is to maintain.
Arena's Cost/Task (P50) is the median cost of a WebDev task. AA uses a different task set and a weighted average. Comparing model costs is useful within each test alongside quality; adding the two measures or treating them as the cost of the same task is invalid.
Bug Hunt Bench: 40.7 fixes on Max and 11.3 on Xhigh
In Paweł Huryn's Bug Hunt Bench, agents find and fix 105 planted bugs in two working repositories. The code change is what counts: reporting a bug without fixing it earns no points. Other real bugs are counted separately and do not increase the score.

The arrows show the change from GPT-5.6 Terra to GPT-6.1 Terra: the result improves on Max but declines on Xhigh and High. Source: Paweł Huryn, Bug Hunt Bench, October 26, 2026. Run costs in the image reflect the author's test conditions rather than GPTunneL pricing.
In the October 26 snapshot, Terra on Max came close to the larger models:
| Model and effort | Fixed out of 105 | Time, min |
|---|---|---|
| Claude Sonnet 5.5 Max | 51.3 | 287.1 |
| GPT-6 Astra Max | 45 | 89.8 |
| GPT-6.1 Sol Max | 44.3 | 139.3 |
| Claude Opus 5.5 Max | 41.7 | 66.9 |
| GPT-6.1 Terra Max | 40.7 | 37.3 |
| GPT-5.6 Terra Max | 32 | 159.7 |
| Claude Haiku 5.5 Xhigh | 18.3 | 24.1 |
More fixes are better; less time is faster. This is a selection from the author's table rather than the full ranking. Terra 6.1's figures average three runs. Times reflect the benchmark environment; parallel runs shared one laptop's resources.
The Max average hides a large gap to the other settings. Huryn published each run's result:
| Effort | GPT-6.1 Terra: three runs | GPT-6.1 Terra average | GPT-5.6 Terra: table result |
|---|---|---|---|
| Max | 34; 42; 46 | 40.7 | 32 |
| Xhigh | 11; 9; 14 | 11.3 | 20 |
| High | 11; 8; 10 | 9.7 | 18 |
Measured in planted bugs fixed out of 105. Settings and individual runs were checked against the benchmark data. Average times for the new Terra on Xhigh and High were 15.9 and 12.6 minutes.
Huryn's main conclusion: Max's combination of results, time, and cost does not hold at lower effort settings. On Xhigh and High, the new Terra trails its predecessor and even Haiku 5.5 Xhigh in this test. The published notes say these runs ended without errors or timeouts: the model stopped earlier of its own accord and took fewer steps.
In a separate post, Huryn attributes Sonnet 5.5 Max's lead to persistence: in his comparison, it takes about seven times as many turns as Astra. He links its high score to extended exploration and checking, rather than simply the model's overall capability. A turn here is another tool call or final response, not another bug found.
My practical takeaway is to test the specific reasoning effort setting when choosing a code-fixing agent. Terra Max's result cannot be applied to Xhigh or High. An average of 40.7 also does not promise that many fixes every time: even Max ranged from 34 to 46, and the test covers only two repositories and agent CLIs.
Noahbench v2™: task execution and comprehension
Noahbench v2™ is a benchmark by developer Noah (@itsnoahd) focused on practical coding work. Its results help assess whether a coding agent can complete the assigned task. The author discusses execution and comprehension separately and publishes pass rates, time, and costs.
Passed means the share of tasks passed within a particular set. It is not a general intelligence index: 50% in one set cannot be directly compared with 37% in another that contains different tasks. Terra's results across three sets:
| Set | Terra: solved | Passed | Rank in snapshot | Time in the author's table |
|---|---|---|---|---|
| 20-task set | 10/20 | 50% | 9 | 4 min |
| Homework / comprehension | 7/19 | 37% | 6 | 31 s |
| 28-task set | 13/28 | 46% | 5 | 4 min |
Source: Noahbench tables. Versions of the 20-task and 28-task sets are not labeled in the tables, so they are identified here by task count. Time reflects the author's measurements, not GPTunneL speed; the tables do not specify how it is averaged.

20-task set: Terra passes half the tasks. Chart costs relate to Noahbench's test and are not GPTunneL prices.
In Homework / comprehension, which the author identifies as a comprehension test, Terra scores 37%. In the same set, Sol scores 49%, Astra 54%, Opus 5.5 61%, and Fable 5.1 72%. Noah specifically calls comprehension the new Terra's weak point.

Task comprehension: Terra scores 7/19. This is a separate task set with its own ranking; costs reflect the test author's conditions.

28-task set: Terra passes 13 tasks. Some models had not finished their runs at the snapshot, so fifth place is provisional.
Noah's assessment: Terra is a fast, balanced executor suited to a subagent role with a bounded task. He observes small, clean changes split across multiple commits, with brief explanations. However, it often stops once the visible tests pass and can treat passing them as sufficient reason to finish.

The benchmark author's observations of Terra. This is his experience, not a GPTunneL test.
To me, this supports giving Terra specific tasks with clear acceptance criteria and checking the result separately. The author's test is useful for this practical picture, but small task sets do not make it a universal model assessment. The tables do not fully describe the tasks, repetitions, or reasoning effort settings.
Plotly: 40 out of 43 data analysis tasks
Plotly tested Terra on DataAnalyticsBench. Models answer questions about a database: calculating metrics, finding defects, and spotting hidden patterns. The table shows where Terra loses points:
| Tasks | GPT-6 Luna | GPT-6.1 Terra | GPT-6.1 Sol |
|---|---|---|---|
| Standard analytics questions | 20/20 | 20/20 | 20/20 |
| Ambiguous questions | 5/5 | 5/5 | 5/5 |
| Questions unanswerable from the data | 5/5 | 5/5 | 5/5 |
| Data quality problems | 3/3 | 3/3 | 3/3 |
| Statistical traps | 3/5 | 4/5 | 5/5 |
| Hidden patterns | 2/5 | 3/5 | 5/5 |
| Total solved | 38/43 | 40/43 | 43/43 |
| Median time per question | 18 s | 15 s | 18 s |
For solved tasks, higher is better; for time, lower is better. Plotly data dated October 26, 2026. Time was measured in the test authors' environment, not in GPTunneL.
Terra handled standard analytics and data quality checks. Its shortfall appeared when it had to spot something less obvious: it missed two hidden patterns and failed to establish why output differed across a group of wind farms. Sol passed every task in this run.
The test has methodological caveats: one run per model, a private exam, synthetic data, and a shared Plotly Studio Embedded environment. The authors warn that a difference of one or two answers may be noise. I would therefore avoid generalizing these scores to every spreadsheet or database.
Maximum reasoning did not always help with writing
There is also a small test by editor Thorsten Meyer, comparing Terra's settings when writing news from source material. In his test, the maximum setting performed worst: the model sought outside information and added facts beyond the source.
The author explicitly lists the limitations: a narrow task, a small collection of texts, one run through Codex, and two model judges. This observation is worth checking on your own material. For writing from meeting notes, I would start with a normal setting, check that the facts were preserved, and only then increase reasoning effort.
The Cube Arena Index: solving a cube from images
Cube Arena tests whether a model can solve a scrambled cube using only images and turns performed through MCP tools. It requires visual understanding, spatial planning, and tool use. The server verifies the cube's state and the solution, so the model simply declaring “done” is not enough.
In Interactive mode, the model receives a new image after a tool call and can adjust its actions. In One-shot, it submits the whole move sequence at once, and the final state is evaluated. In the verified runs, only cube tools are available, without custom code execution or a ready-made solver.

The Cube Arena Index, Fast set. Higher scores are better. Reasoning settings are shown for each model; Fast names the test set rather than measuring speed.
| Model | Effort | Cube Arena Index |
|---|---|---|
| Claude Opus 5.5 | Xhigh | 88.5 |
| GPT-6 Astra | Max | 87.5 |
| GPT-6.1 Terra | Max | 60.5 |
| Claude Sonnet 5.5 | High | 59.0 |
| GPT-6.1 Sol | Xhigh | 56.0 |
| GPT-5.6 Terra | Max | 22.3 |
| DeepSeek V4.1 Flash | Max | 18.5 |
Figures from Cube Arena's table. DeepSeek is listed under the ranking's name, without a version date. These scores belong to a separate benchmark and cannot be directly compared with AA's Intelligence Index.
In this snapshot, Terra ranks third, ahead of Sonnet 5.5 High and Sol Xhigh. It scores 100 in interactive 2×2 and 3×3 tasks, but only 35 in 3×3 One-shot. Sol shows the reverse pattern: 20 in interactive 3×3 and 100 in One-shot. The overall index therefore does not mean Terra is stronger than Sol in every version of the task. The new model leads the previous Terra by 38.2 points.
The Fast index weights five tests: interactive 2×2 contributes 20%, the two 3×3 modes contribute 30% each, and the two 4×4 challenges contribute 10% each. Scores reflect progression through difficulty levels. The 4×4 challenges unlock only after a model scores 100 in all three base tests. Terra did not meet that condition: its dashes mean no result, and those tests contribute zero to the index.
The result fits Terra's positioning: strong visual work and actions guided by feedback. The weaker One-shot result shows that successful step-by-step solving does not guarantee equally strong planning of the entire sequence. Cube Arena tests a puzzle with MCP tools; it cannot assess code quality or reliability in ordinary applications. Nor does this table establish OpenAI's claims about speed and efficiency.
3D comparisons: Terra, Sol and Opus
A 3D electric motor model
Rubens Soto compared GPT-6.1 Terra, GPT-6.1 Sol, and Claude Opus 5.5. The video shows three versions of a 3D electric motor, including an exploded view and internal components.
Video by Rubens Soto. The times and costs below are those reported for his runs.
| Model | Time | Author's cost |
|---|---|---|
| GPT-6.1 Terra | 3 min 25 s | $0.22 |
| GPT-6.1 Sol | 30 min 32 s | $0.96 |
| Claude Opus 5.5 | 52 min 36 s | $15.36 |
Costs reflect the author's test conditions and are not GPTunneL prices. The post does not specify reasoning settings or the number of attempts.
In this example, Terra finished roughly 9 times faster than Sol and 15 times faster than Opus. Costs were around 4.4 and 70 times lower respectively. This illustrates OpenAI's emphasis on speed and efficiency; the video lets you compare the detail and presentation of all three results. A single run does not establish a general ranking of 3D quality.
Alpine Gold 3D scene: EnvolDev's comparison
EnvolDev compared Opus 5.5, GPT-6.1 Sol, and GPT-6.1 Terra on the same Alpine Gold task. The video shows three versions of a scene with a seaplane, lake, and mountains: Sol at the top, Opus in the middle, and Terra at the bottom.
Video by EnvolDev. Times are rounded to minutes as in the author's post; costs refer to those runs.
| Model | Time, rounded | Author's cost |
|---|---|---|
| GPT-6.1 Terra | 43 min | $4.90 |
| GPT-6.1 Sol | 43 min | $3.62 |
| Claude Opus 5.5 | 2 h 45 min | $31.85 |
Here, Terra cost about 6.5 times less than Opus and was almost 3.8 times faster. Against Sol, however, there was no cost advantage: with similar completion times, Terra cost about 35% more. This run shows why the cost of a completed task should be checked separately from the per-token rate. The video lets you compare the three scenes' visual detail.
The post does not specify reasoning settings. The author's costs are not GPTunneL prices.
Drawing a car in Paint: Terra vs Sol
In another Rubens Soto comparison, the models draw the same car in Paint. Both use Extra High (Xhigh): GPT-6.1 Sol appears in the upper part of the video and GPT-6.1 Terra in the lower part.
Video by Rubens Soto showing the drawing process in Paint. Times and costs below are reported by the author for his runs.
| Model | Effort | Time | Author's cost |
|---|---|---|---|
| GPT-6.1 Terra | Xhigh | 6 min 22 s | $0.29 |
| GPT-6.1 Sol | Xhigh | 16 min 01 s | $0.80 |
Soto considers Terra's drawing better. In this comparison, it also finished roughly 2.5 times faster, at about 2.8 times lower cost than Sol. The video shows control of a graphics editor, rather than a separate image model generating a finished picture.
Costs relate to the author's test and are not GPTunneL prices.
Conclusions
Terra 6.1 looks like an economical working option for visual tasks and tool use, with a compromise in general capability relative to Sol and Sonnet.
Based on the collected results:
- Sol and Sonnet are stronger in the overall index, programming, and WebDev. Terra costs less in AA's and Arena's measurements.
- DeepSeek is cheaper still. Terra's advantage over it is more visible in vision and computer tasks: Cube Arena and Agent's Last Exam. In Noahbench, DeepSeek scores higher instead.
- Reasoning settings are critical. In Bug Hunt, Terra averages 40.7 fixes on Max but only 11.3 on Xhigh. A good Max result cannot be generalized to every setting.
- Speed depends on the scenario. Terra is substantially faster than Sol in the motor and Paint examples. In Alpine Gold, completion times are similar and Terra costs more. These examples do not support a universal speedup claim.
Sources
- OpenAI API Changelog: GPT-6.1 Terra release entry dated October 26, 2026.
- Introducing GPT-6.1 Terra: model positioning, test results, and limitations; checked October 27, 2026.
- OpenAI (@OpenAI) and Thibault (@thsottiaux): posts about Terra's positioning and behavior.
- Ted Sanders on Hacker News: Terra's place in OpenAI's lineup, strengths, and value to subscribers.
- GPT-6.1 Terra in the OpenAI API: use cases and supported capabilities; checked October 27, 2026.
- ChatGPT updates, October 26–30: Terra's availability in ChatGPT Work and Codex; checked October 27, 2026.
- Artificial Analysis: GPT-6.1 Terra: independent indices and testing of fabricated answers; October 26, 2026.
- Artificial Analysis: GPT-6.1 Terra and Intelligence Index v4.3.2: components of the overall index and model results; checked October 27, 2026. Other model pages are linked in the table.
- Bug Hunt Bench method and run data and notes: scoring rules, individual Terra runs, and measurement limits; checked October 27, 2026.
- Paweł Huryn, creator of Bug Hunt Bench: posts on Terra's results and Sonnet's persistence.
- Noah (@itsnoahd), creator of Noahbench: Terra's result tables and the author's comments on v2.
- Plotly: Terra on DataAnalyticsBench: results and examples of data analysis errors; October 26, 2026.
- Plotly: DataAnalyticsBench method: test design and comparison limits; October 14, updated October 26, 2026.
- Thorsten Meyer: testing Terra's effort levels on an editorial task: a small-sample test; October 26, 2026.
- Cube Arena repository and method: image-based cube solving, Interactive and One-shot modes, index components and weights; results table.
- Rubens Soto: Terra, Sol and Opus in 3D: three electric motor models, completion times, and the author's costs.
- Rubens Soto: Terra and Sol drawing a car in Paint: both models on Xhigh, the drawing process, times, and costs.
- EnvolDev: Alpine Gold scene comparison: Opus 5.5, Sol 6.1, and Terra 6.1 on the same task, including time and cost.
- WebDev Arena and Arena's ranking method: user comparisons of web outputs, ratings, and rank spread.



