GPT-6.1 Terra costs half as much per input token as GPT-5.6 Terra and, as per OpenAI benchmarks, performs on par with GPT-6 Astra, which costs ten times more.
This raises two questions.
In this article, then, we put GPT-6.1 Terra up against GPT-5.6 Terra and GPT-6 Astra in coding, writing and vision tests.
GPT-6.1 Terra is OpenAI's new mid-range model, replacing GPT-5.6 Terra. It sits between Luna, the smallest and fastest model in the lineup, and Sol, a more advanced model designed for professional work.
GPT-6.1 Terra is a multimodal model that can process text and images, but not video. It's primarily designed for everyday tasks and computer use, with computer vision being one of its main strengths. We'll put that to the test later in this article.
I don't know about you, but I use AI for a lot of writing, from emails to reports. If you do too, you'll be glad to hear that OpenAI has also worked on making Terra's writing clearer and more natural. We'll see how much of a difference that makes and compare its writing capabilities with other models.
Before looking at the tests, let's look at the benchmarks to see where the biggest areas of improvement are compared with the previous generation:
| Benchmark | GPT-6.1 Terra | GPT-5.6 Terra |
|---|---|---|
| Terminal-Bench 4.0, max reasoning effort | 50.3% | 21.5% |
| Factual error rate, low reasoning effort | 16.7% | 53.6% |
| AA-Omniscience hallucination rate | 38% | 88% |
| Cost per Intelligence Index task | $0.40 | $1.40 |
Compared to GPT-5.6 Terra, the new model shows its biggest improvements in coding and factual accuracy.
On the Artificial Analysis Intelligence Index, an independent benchmark of overall model capabilities, GPT-6.1 Terra scores 6 points higher than GPT-5.6 Terra and just 4 points below GPT-6.1 Sol.
Finally, on Agents' Last Exam, a benchmark of multi-step agent tasks, GPT-6.1 Terra performs on par with GPT-6 Astra while completing tasks more than three times faster. In practice, this suggests that Terra could handle long-running agent tasks with roughly the same reliability as the flagship model, but much faster and at a significantly lower cost.
In the OpenAI API, GPT-6.1 Terra's cached input costs $0.05 per million tokens.
| Model | Input, per 1M tokens | Output, per 1M tokens |
|---|---|---|
| GPT-6.1 Terra | $1 | $5 |
| GPT-5.6 Terra | $2 | $12 |
| GPT-6 Astra | $10 | $50 |
Meanwhile, in ChatGPT, GPT-6.1 Terra is included in the Plus, Pro, Enterprise and Edu plans. In Overchat AI, a message to GPT-6.1 Terra costs 3 credits on a paid plan.
Now let's look at the tests. Each test was a single prompt generation run in Overchat AI. In the coding tasks, each model had to return a single HTML file that runs in Chrome without any setup.
GPT-6.1 Terra is always on the left, GPT-5.6 Terra is in the middle and GPT-6 Astra is on the right.
The first task is a side-scrolling platformer in the style of 8-bit console games, which an AI plays by itself. The level is generated from a seed, and the AI has to control the hero with the same buttons a player would use.
The prompt:
Create a single self-contained HTML file (no external libraries and no image files: draw everything in code) with a side-scrolling platformer in the style of classic 8-bit console games, played by an AI. Use original characters only: the hero is a small fox in a red scarf.
The level is at least 6 screens long and built procedurally from a seed. It must contain: ground with bottomless pits of different widths, staircases of blocks, floating brick platforms, glowing crystal blocks that release a gem when the hero hits them from below, stone pillars of different heights, a platform that moves back and forth over a wide pit, two kinds of enemies (a beetle that patrols and walks off ledges, and a frog that hops toward the hero), and a goal gate with a waving banner at the end. Add a parallax background with hills and clouds, a pixel-art look and a smooth camera that follows the hero.
Physics: gravity, acceleration and friction, variable jump height. Landing on an enemy defeats it and bounces the hero up; touching an enemy from the side costs a life.
The AI controls the hero only through the same virtual inputs a human would use (left, right, jump, holding jump); it never moves the hero directly. It has to plan jumps over pits and enemies, time the moving platform, stomp enemies when it can, hit crystal blocks to collect gems and reach the goal gate. At the gate, play a short victory animation with fireworks, then build the next level from a new seed with a slightly harder layout and keep playing. HUD: score, gems, world number, time and lives. Pressing the arrow keys or space hands control to a human.
It must start automatically and run smoothly. Return only the complete code in a single ```html code block.
GPT-6.1 Terra wrote the game in about two minutes, and its AI makes no mistakes in the first minute. The fox collects gems, jumps over pits, rides the moving platform and reaches the goal gate after about 40 seconds with all three lives left. After that, the game builds the second world and keeps going.
GPT-6 Astra spent almost six minutes on the task, and its game has the most visual details. It has its own title, mountains and a sun in the background, a progress bar for the AI and a "Trail complete!" banner with fireworks after the first level. However, its AI keeps running into enemies, and after a minute the fox has one life left out of five.
GPT-5.6 Terra answered in 33 seconds, and its game doesn't start. The code uses a variable that was never declared, so the page freezes on the first frame, with plain rectangles in place of the hero and the level.
The second task is a 30-second animated story in Three.js, built from more than 100,000 cubes: a fishing village on a volcanic island, an eruption, lava that flows down the slopes and breaks houses apart, new land where the lava reaches the sea, and nightfall.
The prompt:
Create a single HTML file with a cinematic voxel simulation in Three.js. Load it with an import map from https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js (addons, if you need them, from https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/); no other libraries. Build everything from cubes and use InstancedMesh so it stays fast with 100,000+ voxels.
The scene: a volcanic island with a fishing village on its slopes: at least 20 voxel houses with roofs and lit windows, trees, a wooden pier with boats, and the sea around the island with moving waves. The simulation plays as one 30-second story:
1. Calm evening, smoke rising from the crater.
2. The ground shakes and the volcano erupts: glowing lava bombs fly out on ballistic arcs and blast voxels out of the ground where they land.
3. Lava flows downhill as a voxel cellular automaton that follows the real terrain. It sets trees on fire and breaks houses apart into debris voxels that tumble with simple physics.
4. Where the lava reaches the sea it cools into dark rock and throws up clouds of steam, so the coastline visibly grows.
5. Night falls; the lava keeps glowing and lights the scene.
Add ash and smoke particles, emissive lava with bloom, camera shake during the eruption, and a cinematic camera that orbits the island and moves closer for the key moments. After the story ends, the island resets and the story replays with a new random seed.
It must start automatically and run smoothly. Return only the complete code in a single ```html code block.
GPT-6 Astra's island has 236,710 cubes and a volcano with a clear cone. Rivers of lava run down every side, clouds of steam rise where the lava meets the sea, and each stage of the story gets its own chapter title on the screen. In the first stage, heavy fog hides most of the island.
In GPT-6.1 Terra's scene, lava bombs fly out of the crater, lava spreads down the slopes, houses break into flying debris, and night falls before the island resets. There's no steam, though, the sea is a flat grey slab, and the volcano has almost no cone.
GPT-5.6 Terra returned a short file in 18 seconds. It draws a still pile of brown cubes on a white background, with no village, lava or sea.
We tested writing with two tasks: a proposal email to a client and an explanation of how AI image generators work.
The models had to turn notes from a client call into a proposal email of up to 300 words without adding anything that isn't in the notes. One line in the notes is internal and must stay out of the email: a developer's vacation, which the team planned to cover by padding the timeline.
The prompt:
Turn my notes from a client call into a proposal email to the client. Keep it under 300 words, friendly but professional, with a clear price and a clear next step. Don't add anything that isn't in the notes.
Notes:
- call w/ Dana Whitfield (ops lead, Harbor & Pine: 3 coffee shops in Portland, 4th opening in March)
- problem: online orders come in from 3 places (website, phone, DoorDash), baristas retype them into the POS, ~15 wrong orders a week, Saturdays are the worst
- they want: one queue for all orders on a tablet behind the counter + a text to the customer when the order is ready
- DoorDash part: their API needs partner approval, can take 4-6 wks -> do it as phase 2
- phase 1 (website + phone): 5 weeks, $14,500
- phase 2 (DoorDash): +$4,000 once approved
- support: $350/mo, first 2 months free
- Dana's boss (Marcus, owner) signs anything over $10k, needs something he can read in 2 min
- she asked if we can start before Thanksgiving -> yes, if signed by Nov 7
- internal, DON'T put in the email: our dev Kev is out Nov 20-27, we'd pad the timeline for that
- next step: 30-min call w/ Marcus, Dana suggested Tue or Thu morning
All three emails have every price and date and leave out the developer's vacation. GPT-6.1 Terra wrote the shortest email in 8 seconds: 114 words, with the price of each phase on its own line, which fits the note that the owner needs something he can read in two minutes:
Subject: Proposal for Harbor & Pine's order queue
Hi Dana,
Thanks for the call. Here's a brief proposal for bringing Harbor & Pine's orders into one queue on a tablet behind the counter, with a text to customers when their order is ready.
Phase 1: Website and phone orders
Five weeks · $14,500
Phase 2: DoorDash orders
$4,000, once DoorDash partner approval is granted. Approval can take 4–6 weeks.
Support: $350 per month, with the first two months free.
We can start before Thanksgiving if the agreement is signed by November 7.
As a next step, let's schedule a 30-minute call with you and Marcus. Would Tuesday or Thursday morning work?
Best,
[Your name]
GPT-6 Astra wrote 178 words in 12 seconds and was the only model that restated the client's problem, about 15 wrong orders a week. It also explained why Marcus has to join the call:
Subject: Proposal: A single order queue for Harbor & Pine
Hi Dana,
Thanks for the call. With three Portland shops and a fourth opening in March, the goal is to reduce manual order entry and the roughly 15 wrong orders each week—especially on Saturdays.
Here's the proposed approach:
Phase 1: Website + phone orders — $14,500
Phase 2: DoorDash — an additional $4,000
Support: $350/month, with the first two months free.
We can start before Thanksgiving if the proposal is signed by November 7.
Since Marcus signs off on projects over $10,000, the next step is a 30-minute call with you and Marcus to review the proposal. Would Tuesday or Thursday morning work for you both?
Best,
GPT-5.6 Terra wrote its email in 9 seconds. It opens with filler and splits a short message into sections with document-style headings, such as "Proposal Overview" and "Next Steps", which look out of place in an email to a client:
Subject: Proposal for Order Management Solution
Hi Dana,
Thank you for the productive call! I'm excited about the opportunity to streamline the order management process for Harbor & Pine.
Proposal Overview
Phase 1: Website & Phone Orders
Phase 2: DoorDash Integration
We will set up a unified queue for all orders on a tablet behind the counter, along with a text notification system for customers when their orders are ready.
Support
Ongoing support will be available for $350 per month, with the first two months free.
Next Steps
To get things moving, I recommend a 30-minute call with Marcus to discuss further. Dana, you mentioned Tuesday or Thursday morning might work well. Please let me know what suits him best.
If we can finalize the agreement by November 7, we can kick off the project in time for Thanksgiving.
Looking forward to your thoughts!
Best,
[Your Name]
[Your Contact Information]
[Your Company Name]
We asked the models to explain how an AI image generator works. It's a surprisingly tricky question, as AI models often give vague, fluffy explanations instead of describing the actual technology behind image generation.
How does an AI image generator work?
GPT-6.1 Terra answered in 6 seconds, with 172 words:
Most modern AI image generators use a model called a diffusion model. In simple terms, they learn how to turn random visual noise into an image that matches a description.
The model doesn't usually retrieve and assemble existing images; it generates new pixels based on patterns learned during training. That said, it can sometimes reproduce elements of its training data, especially if they appeared frequently.
GPT-6 Astra wrote 378 words in 16 seconds, making its answer considerably more expensive, both because the model itself costs more and because it generated a much longer response:
1. They learn from images and descriptions
During training, the model processes large collections of images, often paired with captions. It learns statistical relationships between words and visual features—such as what foxes tend to look like, how shadows behave, and what distinguishes pixel art from a photograph.
That knowledge is stored in the model's numerical parameters, rather than as a searchable photo library. It generally creates new combinations of learned patterns, though models can sometimes reproduce memorized training material.
2. They interpret your prompt
A text encoder converts your words into numbers that represent their meaning. These representations guide what should appear in the image, including subjects, colors, composition, and style.
3. They build an image from noise
Many generators use diffusion, or a closely related method.
During training, a diffusion model learns to recover structure from images that have been corrupted with random noise. During generation, it runs a similar process starting with nearly pure noise:
Random noise → rough shapes → recognizable objects → finer details
At each step, the model adjusts the image toward something consistent with your prompt. It isn't simply uncovering a hidden picture—the picture is being constructed through those adjustments.
4. They turn the result into pixels
Many models do this work in a compressed representation called a latent space, which is cheaper to process than a full-resolution image. A decoder then converts that representation into visible pixels. Optional steps can enlarge or refine the result.
Why can the same prompt produce different images?
The starting noise varies. A seed determines that starting randomness, so keeping the seed and other settings fixed often lets you reproduce a result.
GPT-5.6 Terra gave the longest answer, 522 words, in 12 seconds:
3. It starts with random noise
Many popular generators use a technique called diffusion.
They begin with an image that is essentially random visual static—like television noise. Then, across many steps, the AI repeatedly adjusts that noise into something more consistent with your prompt.
Very roughly:
This is called denoising. The AI learned how to reverse noise during training by being shown clean images that were progressively corrupted with noise.
4. Settings guide the result
Several common controls influence the process:
Other approaches
Diffusion is the most common approach today, but others exist:
For the vision test, we made two engineering drawings of a metal bracket and calculated the correct answers in advance. Each drawing shows the part in three views and has one dimension that contradicts the others. To answer, a model has to "imagine" the part in 3D, find the wrong dimension and calculate the part's mass. To make this more accurate, we ran every image three times.
| Drawing, correct runs | GPT-6.1 Terra | GPT-5.6 Terra | GPT-6 Astra |
|---|---|---|---|
| Mounting bracket | 3 of 3 | 0 of 3 | 3 of 3 |
| Support bracket (harder) | 3 of 3 | 0 of 3 | 3 of 3 |
Granted, not everyone will use the model for engineering work (and please don't), but it's a challenging test that really puts its computer vision capabilities to the test.
Here's the input:
And the prompt:
This is a manufacturing drawing of a part (third-angle projection, all dimensions in mm).
1. Describe the part's 3D shape: what features it has and how many of each.
2. One dimension on this drawing contradicts the others. Find it, say which value is correct and explain how you know.
3. Using the correct dimensions, calculate the part's volume in cm³ and its mass in grams. The material is aluminum 6061 (density 2.70 g/cm³). Show your calculation step by step and give the final mass rounded to the nearest gram.
GPT-6.1 Terra and GPT-6 Astra both found the 85 mm dimension every time and proved the 80 mm depth with the top view and its chain of dimensions. Both calculated the correct mass.
GPT-5.6 Terra, on the other hand, read the two narrow ribs at the ends of the part as one ramp across its whole width, so all of its masses were too high: 801, 838 and 898 g. In two runs, it also decided that 85 mm was correct and the top view's 80 mm was the mistake.
Let's ramp up the difficulty a bit. Now, the holes have counterbores that are marked only with drafting symbols, the wall has a chamfer and a slot with round ends, and the depth of the pocket is given only on hidden lines. As a result, the wrong dimension can't be found by adding up a chain: the front view gives the height of the ribs as 55 mm, and the correct 50 mm can only be worked out from the geometry, either from the 45° angle of the ribs or from the chamfer and the wall above them. The correct mass of this part is 708 g.
The prompt:
This is a manufacturing drawing of a part (third-angle projection, all dimensions in mm).
1. Describe the part's 3D shape: every feature and how many of each.
2. Exactly one dimension on this drawing contradicts the others. Find it, give the correct value and prove it from the other dimensions.
3. Using the correct dimensions, calculate the part's volume in cm³ and its mass in grams. The material is aluminum 6061 (density 2.70 g/cm³). Show your calculation step by step and give the final mass rounded to the nearest gram.
GPT-6.1 Terra and GPT-6 Astra proved the rib height in two independent ways: a 30 mm rise at 45° from the 20 mm base gives 50 mm, and so does the overall height of 70 mm minus the 10 mm chamfer and the 10 mm of wall above the ribs. Both also read the counterbores correctly from the symbols.
GPT-5.6 Terra named the 55 mm dimension in two runs out of three, but in one of them it took this dimension for the top of the slot, and none of its masses were correct: 724, 837 and 796 g. In the third run, it decided that the overall height of 70 mm was wrong.
GPT-6.1 Terra was faster than GPT-6 Astra in every task, especially in code: GPT-6 Astra reasoned for about three minutes before the first line of code appeared, and GPT-6.1 Terra for about 27 seconds.
GPT-5.6 Terra completed the coding tasks the fastest, but that doesn't count because its code was broken.
| Task | GPT-6.1 Terra | GPT-5.6 Terra | GPT-6 Astra |
|---|---|---|---|
| Self-playing platformer | 125 s | 33 s | 356 s |
| Voxel volcano eruption | 122 s | 18 s | 350 s |
| Proposal email | 8 s | 9 s | 12 s |
| Image generator explanation | 6 s | 12 s | 16 s |
| Mounting bracket, average of 3 runs | 19 s | 55 s | 26 s |
| Support bracket, average of 3 runs | 29 s | 75 s | 40 s |
In our writing and computer vision tests, GPT-6.1 Terra performed just as well as GPT-6 Astra, but responded faster and cost a fraction of the price.
GPT-6 Astra is worth using when the task is difficult enough to justify the extra time and cost, such as generating a large program in one go or solving a particularly complex problem.
As for GPT-5.6 Terra, there's little reason to keep using it. The new model outperforms it across the board.
You can use GPT-6.1 Terra in Overchat AI on a paid plan:
Below are short answers to common questions about GPT-6.1 Terra.
GPT-6.1 Terra is OpenAI's mid-range large language model, built for everyday work and computer use. It accepts text and images, answers with text and sits between GPT-6 Luna and GPT-6.1 Sol in OpenAI's lineup.
OpenAI released GPT-6.1 Terra on October 26, 2026, as a replacement for GPT-5.6 Terra. On the same day, the model became available in ChatGPT, in Codex and in the OpenAI API.
In the OpenAI API, GPT-6.1 Terra costs $1 per million input tokens and $5 per million output tokens. In ChatGPT, it's included in the Plus, Pro, Enterprise and Edu plans, and in Overchat AI, a message to GPT-6.1 Terra costs 3 credits on a paid plan.
Yes. GPT-6.1 Terra scores more than twice as high on Terminal-Bench 4.0, makes far fewer factual errors and costs less. Both programs it wrote for this comparison worked, and it read both engineering drawings correctly, which GPT-5.6 Terra failed to do in six attempts.
On the writing tasks and engineering drawings in this comparison, GPT-6.1 Terra matched GPT-6 Astra. In coding, Astra's game and 3D scene had more visual detail, but it took almost three times longer and costs ten times more per token.
GPT-6.1 Terra is available in ChatGPT on the Plus, Pro, Enterprise and Edu plans, in Codex, in the OpenAI API, on OpenRouter and Vercel AI Gateway, and in third-party apps such as Overchat AI.
