OpenAI's Budget Model GPT-6.1 Terra Trades Accuracy for Speed and Cost in Head-to-Head Tests

On October 26, OpenAI introduced GPT-6.1 Terra, positioning it as an economical alternative within its GPT-6 lineup for high-volume production workloads. The company set Terra's pricing at $1 per million input tokens and $5 per million output tokens—exactly one-tenth of Astra's $10 and $50 rates. OpenAI also claims Terra executes tasks more than three times faster than Astra according to its Agents' Last Exam benchmark, though those computer-use results differ from the evaluation described here.

Early published benchmarks painted a mixed picture of Terra's capabilities. Plotly's analytics test found Terra identified three of five embedded patterns and answered 40 of 43 questions correctly overall. Artificial Analysis reported that Terra guessed on 38% of unanswerable questions rather than declining to answer, an improvement from the 88% guessing rate for GPT-5.6 Terra on the same test. DualEntry's accounting benchmark measured Terra's accuracy at 78.2%.

To examine how Terra and Astra actually perform under demanding conditions, three synthetic tasks were constructed and run through OpenAI's API with reasoning effort set to high. The tests were designed to isolate speed, estimated token costs, and accuracy differences between the two models. These single-run results on artificial tasks should not be interpreted as predictive of performance across all workloads or as measures of repeatability.

The tests

Each test was developed through multiple iterations and graded against verified answer keys. The final versions were selected after both models returned identical scores on easier variants, prompting the creation of harder versions to expose meaningful differences. GPT-5 Mini was used as a baseline reference. Usage figures include reasoning tokens in the output count; reasoning tokens are a subset of output, not an additional charge. Cost estimates derive from stated token rates at standard uncached input and output prices, excluding tool charges or billing adjustments, and are not verified invoice totals.

• SQL reasoning – Each model received 25 questions about a synthetic database containing 500 software builds, with complications including deleted records, retries, costs in three currencies, and time zone dependencies. Two questions lacked answerable solutions from the available data.
• Data validation – Models reviewed a spreadsheet of 4,950 fabricated customer records against 19 rules. Forty records violated at least one rule; ten records appeared problematic but actually complied with all rules.
• Incident log triage – Models analyzed approximately 7,000 lines of logs from a simulated outage spanning more than 20 services, with planted errors including clock drift, misleading error messages, and unrelated changes triggering alerts before the actual cause.

SQL reasoning

This test produced the most pronounced performance divergence. Astra achieved 48 of 50 points while Terra scored 26 of 50. Each of the 25 questions carried two points; only exact answers earned full credit, with partial answers and unanswered questions receiving zero. For the two unanswerable questions, the correct response was recognizing the data insufficiency.

Terra successfully processed all 500 rows and managed soft deletes, retries, and multiple currencies. Its sole numerical error involved calculating total run time for 151 builds in a single region. Astra's answer fell 406 seconds short of the correct 31,428 seconds, yielding 31,022—approximately 1.3% below the target. The discrepancy alone cannot reveal whether the error stemmed from addition mistakes, skipped rows, or misread values.

Astra demonstrated greater accuracy in this instance, though its incorrect total warranted verification. The model consumed 27,970 reasoning tokens and required 319.7 seconds—over five minutes—to complete the task.

Terra declined to calculate answers for six questions requiring cost or duration summation across all 500 rows, instead generating SQL queries for manual execution and marking each as uncalculated. While this approach avoided fabricating numbers, it shifted the computational burden to the user. This marked the first instance of an AI model returning work incomplete.

More concerning, Terra answered six questions incorrectly. Four involved counts off by only one or two, yet Terra presented these answers with identical confidence to its correct responses, providing no signal of potential error. Using such figures in reports would leave users unaware of which numbers required verification.

Given the substantial performance gap, the lower price and faster execution do not constitute clear advantages.

• Terra: 133.1 s, 21,060 in, 11,554 out (10,707 reasoning), $0.079
• Astra: 319.7 s, 21,060 in, 28,806 out (27,970 reasoning), $1.65

Data validation

Astra achieved a perfect 50 points; Terra scored 45. Forty points derived from the 40 rule-breaking records, with one point awarded per flagged record if the violated rule was correctly identified. The remaining ten points came from records appearing suspicious but actually compliant with all rules; models lost a point for each valid record incorrectly flagged.

Before responding, Terra cautioned that it could not reliably validate all 4,950 records against the ruleset and might miss violations—a concern that materialized. The input remained within the model's context window, and no output cap was imposed. Terra generated 1,841 reasoning tokens compared to Astra's 12,831. Response times were 31.4 seconds for Terra and 145.0 seconds for Astra; these elapsed times do not isolate pure reasoning duration.

Terra correctly identified 35 of the 40 invalid records while flagging none of the valid ones, achieving 87.5% recall and 100% precision in this run. Its 45 of 50 score represents test performance, not accuracy across the entire 4,950-record dataset. Three of the five missed records only violated rules when compared against other records in the file, such as a customer reusing another's phone number. Terra's results do not explain why these five invalid records escaped detection.

Astra caught all 40 invalid records but required more than four times longer and cost approximately 12 times more. Terra consumed fewer reasoning tokens and missed records in this run; this association does not establish causation.

• Terra: 31.4 s, 234,045 in, 2,336 out (1,841 reasoning), $0.25
• Astra: 145.0 s, 234,045 in, 13,369 out (12,831 reasoning), $3.01

Incident log triage

Both models tied with 50 points each. Grading relied on a 50-point checklist of required elements: tracing the outage to a settings change in the ledger service, identifying three servers with incorrect clocks, and avoiding false leads. Planted false leads included a fraud service update that was rolled back, a payments setting altered seconds before the actual cause, a database switchover, and an unrelated memory issue in the search service.

Error messages implicated the fraud service, yet both models correctly traced the outage to the ledger service settings change and spotted the three servers with clock problems. Neither accepted error messages at face value; both examined underlying evidence—the behavior expected from an engineer responding to a real outage.

Astra's cost ran approximately 11 times higher than Terra's, and completion took 2.6 times longer. Most of Astra's additional output tokens were reasoning tokens: 4,628 of the 6,650-token difference. Despite this disparity, both models earned identical scores, leaving open whether additional reasoning improved performance on the other tests.

• Terra: 94.3 s, 251,651 in, 7,508 out (5,114 reasoning), $0.29
• Astra: 244.5 s, 251,651 in, 14,158 out (9,742 reasoning), $3.22

Results

Across the three final high-effort runs, Terra generated fewer reasoning tokens and completed tasks faster than Astra. It scored lower on SQL reasoning and data validation but tied on incident log triage. This represents a measurable trade-off, though the results do not clarify whether Terra was overwhelmed or explain specific error patterns.

Combined execution times totaled 258.8 seconds for Terra and 709.2 seconds for Astra, making Astra approximately 2.74 times slower. At standard uncached rates, estimated token costs were $0.61 for Terra and $7.88 for Astra—Terra's cost amounted to roughly 7.8% of Astra's. Terra scored 121 of 150 points; Astra scored 148 of 150. The results demonstrate cost, time, and accuracy trade-offs but do not indicate whether OpenAI deliberately constrained reasoning to achieve them.

Terra matched Astra's performance on earlier easy and medium test variants, though this does not establish its accuracy across all tasks at those difficulty levels. On the final tests, caution is warranted before deploying Terra for unchecked numerical aggregation or exhaustive data validation. It may serve as an acceptable lower-cost option for certain workloads, including tasks resembling the incident triage tested here, provided results receive verification. Astra's incorrect SQL total similarly underscores the importance of validating its output.