GPT 6.1 Terra Hands-On: Three Times Faster, Half the Cost, but Prone to These Mistakes

OpenAI released its new model GPT 6.1 Terra this Monday, claiming it costs only half as much as its sibling Source, completes computer-operation tasks more than three times faster, and comes close to or even surpasses Source on benchmarks. But after running an identical set of tasks to Source's, Terra's performance showed a clear two-sided nature: it is fast and cheap on tasks with clear goals and unambiguous right answers, but once it needs to make design decisions on its own, it cuts corners.

Test Setup and Speed Advantage

The test reused the tasks previously run against 6.1 Source in the Gemini 4 Argon review: five visualization tasks plus one bug-fixing coding task, all in the same Codex command-line environment and the same Hai reasoning level. Note that the Source data comes from the previous review, nearly a month ago, so its speed may have changed; the side-by-side comparison is only a reference.

The speed gap is striking. The gear transmission box took Terra just 48 seconds, the element sandbox 42 seconds, and the "Tihu riding a bicycle" 32 seconds—while Source routinely took three to five minutes. The snowy village scene was submitted in under a minute, 7 to 8 times faster than Source. Across all tasks, Source took 36 minutes and Terra just over four minutes; with unit price halved and output tokens at half, the credit-based consumption dropped by three quarters. Running the entire evaluation consumed only 6% to 7% of the author's Plus account five-hour quota.

The Three Tasks It Passed: Adequate but Minimal

The minimum bar for the gear transmission box is correct motion pattern and correct engineering values. Terra built a four-gear solution with correct program-tested values, no motion-trajectory problems, a clean interface, and just one RPM slider. It didn't add extras like the piston displacement curve that Source designed; it delivered a minimal version that just meets the requirements.

The element sandbox tests physical logic: sand sliding, floating and sinking on water, water-fire reactions, and fire must not burn through stone. Several previous models simply burned the stone away; Terra got it completely right.

"Tihu riding a bicycle" had no egregious errors, but the wings were stuck flat against the body and the handlebars weren't even held—a classic "submit fast, do less, err less." All three tasks passed, yet the completion speed was astonishingly fast—Source typically takes minutes on similar tasks, and Terra's time savings far exceed the officially advertised 3x.

The Two Tasks That Exposed Problems: Design Decisions and Missing Checks

The snowy village scene took under a minute, with wooden cabins, window light, snow-covered trees, and falling snow all present, and drag, zoom, and auto-orbit working normally. But the problems were equally obvious: the code defines a moon, but its elevation is so high the camera can't see it at all—the exact same mistake made in the earlier Gemini 4 Argon review. Zooming in from several angles revealed triangular fragments poking out from the eaves, tree leaves clipping through the front of the houses, and snow on the trees sliced into segments.

The reason is that it didn't do occlusion testing; instead it sorted all polygons by distance and drew them from far to near. This approach is simple and cheap, but once polygons intersect, the display goes wrong. Source used WebGL last time, which has depth testing, and the image was clearly more refined. Terra only partially passes this task.

The Super Mario-style pixel game had even more serious problems. Source built a 12-segment long level last time, taking over 13 minutes; Terra took only 83 seconds. The opening screen and in-game controls felt passable, but the design laziness quickly showed: the first few segments repeat the same combination over and over, all the question blocks sit directly on top of brick blocks as pure decoration, and mushrooms hidden inside can't be hit at all, so you can't grow big. When you reach the first pipe, no matter how you jump you can't get over it—the character's jump parameter maxes out at 76.7 pixels, while the pipe is 80 pixels tall, and the pipe appears at 13% into the level, with five more of the same height after it. This makes the game design-wise unplayable, and Terra fails this task.

Occlusion Testing and the Painter's Algorithm

The "occlusion testing" mentioned in the article corresponds to the Depth Testing mechanism in computer graphics: when rendering each pixel, its depth value is compared with the value recorded in the depth buffer, and only fragments closer to the viewer are written, ensuring correct front-to-back occlusion.

Terra's approach of "sorting by distance and drawing from far to near" is the classic Painter's Algorithm. Its advantage is simple implementation with no extra buffer, but it has a fatal flaw: when two polygons intersect in space, there is no overall "who is in front" order, and no matter how you sort, some regions will be incorrectly overwritten. This is exactly the root cause of the eave triangular fragments, leaves penetrating houses, and sliced snow described in the article. Source used WebGL last time, which supports depth buffering by default, hence the more refined image—at the cost of needing to correctly handle depth precision, transparent object sorting, and other extra issues.

Bug-Fixing Task: Three Perfect Scores

The pure coding task provided a pixel game project, requiring the model to locate and fix four types of embedded bugs based on player complaints. The test was run three times, and Terra scored full marks all three times, fixing the hidden bugs at the root. Last time, both Opus and Argon only fixed half on this task. Terra took only about 40 seconds each time, while Source took three to four minutes. This shows that on tasks with clear goals and verifiable correctness, Terra's capability is very close to Source.

Where Speed and Savings Come From: Heavily Compressed Thinking

At the same Hai reasoning intensity, Source's thinking tokens on various tasks were generally several thousand, with the largest task approaching 8,000; Terra's were at most a few hundred, and on the kill task only 56. That's the price of "fast and cheap"—it doesn't think much, doesn't double-check, does whatever is easiest and fastest, and quality is left to chance.

Thinking Tokens and Reasoning Cost

The "thinking tokens" in the article refer to the tokens consumed by the internal reasoning content the model generates before giving its final answer. On models that support extended thinking, these tokens are also billed as output and often make up the bulk of output. Source's several thousand thinking tokens per task, up to nearly 8,000, means it performs multiple rounds of self-verification, plan comparison, and backtracking while solving; Terra's compression to a few hundred or even a few dozen tokens is equivalent to skipping these steps and giving the first version directly.

This explains two phenomena: first, the dramatic drop in speed and cost—output tokens halved, unit price halved again, so overall consumption naturally falls to a quarter; second, the divergence in quality—for tasks like bug fixing that have "clear goals and verifiable correctness," the first version is often correct enough, and compressing thinking costs almost nothing; but for open-ended tasks requiring design decisions, the lack of self-checking leaves errors directly in the deliverable.

Positioning and Use Cases

Terra is very close to Source on tasks with clear goals and unambiguous correctness, scoring full marks on the bug-fixing task just the same; but when a task requires it to make many design decisions itself—such as what drawing method to use for a 3D scene or how to lay out a level—it clearly cuts corners. Overall, task results are stable but somewhat worse than Source. OpenAI's own wording is also tactful, essentially recommending Source and Astral for complex coding tasks.

If your main model is 6.1 Source, Terra probably can't fully replace it. In fact, OpenAI's main positioning for Terra is computer operation and image understanding—Codex itself is already strong at computer operation, and even Luna can handle most daily tasks, just a bit slower. 6.1 Terra is faster and cheaper, bringing a better experience in such scenarios.

Codex and Model Tiers

Codex in the article is OpenAI's agent product/command-line environment for coding and computer operation, where the model is responsible for planning operation steps, calling tools, and executing tasks. The same product can mount models of different tiers: Source leans toward capability ceiling, Terra toward speed and cost, and Astral is positioned higher.

This also explains why the official positioning for Terra is computer operation and image understanding: each step in these tasks has a clear goal and immediately verifiable results (whether the click lands, whether the interface changes), which falls exactly in Terra's sweet spot; while complex coding tasks require many architecture-level design decisions, exactly where it tends to fail after compressing thinking. So the key to model selection isn't "who is stronger," but whether the task requires the model to do open-ended design itself.