GPT-6.1 Terra for coding agents: half the price of Sol, and where that's enough

Published October 28, 20265 min read

OpenAI's model families now come in four sizes. From cheapest to most capable they are Luna, Terra, Sol, and Astra. 9to5Mac notes that Sol and Luna moved to the GPT-6 generation last month while Terra stayed on GPT-5.6 until this week. OpenAI's announcement pitches the new Terra mainly at computer use, describing a model that “understands what's on screen, takes action across apps, writes naturally.”

For developers, the more useful fact is the price. Terra now sits between Luna and Sol at a level that makes it a realistic default for agent steps that run hundreds of times a day. This piece covers what shipped, how the price compares with the models you're likely already using, and where we'd use it. We haven't run Terra on our own tasks yet, so the capability claims below are OpenAI's.

What shipped

According to OpenAI's model release notes, dated October 26, Terra “is rolling out in the OpenAI API as gpt-6.1-terra and in ChatGPT Work and Codex.” The announcement names Plus, Pro, Enterprise, and Edu as the ChatGPT plans that get it. The API model page lists the specifics:

• Context: 1,050,000 tokens in, up to 128,000 tokens out.
• Knowledge cutoff: June 1, 2026.
• Reasoning effort: none, low, medium (the default), high, xhigh, and max.
• Inputs: text and images. Output is text only, and fine-tuning isn't supported.
• Agent tools: hosted shell, apply patch, skills, computer use, MCP, and tool search, all through the Responses API only.
• Rate limits: 5,000 requests and 1,000,000 tokens per minute on the entry Build tier. The free tier isn't supported.

The same day, GitHub made GPT-6.1 Terra generally available in Copilot for Pro, Pro+, Max, Business, and Enterprise. It's in the model picker in VS Code, Visual Studio, JetBrains IDEs, Xcode, Eclipse, Copilot CLI, and the Copilot cloud agent. Rollout is gradual.

How the price compares

Standard API prices per million tokens, from OpenAI's pricing page and Anthropic's model pages for Sonnet 5.5 and Opus 5.5:

Terra has a few pricing rules worth knowing before you point a long-running agent at it. Prompts over 272,000 input tokens are billed at 2x input and 1.5x output for the whole request. Cache writes cost $1.25 per million tokens for 30-minute retention or $2.50 for 12 hours. Batch and Flex are half price, and Fast mode is double. All of that comes from the model page. We only checked these rules for Terra, so don't assume the other rows work the same way.

What it means per agent run

Per-token price isn't per-task cost, because models differ in how many tokens they burn to finish the same job. Still, a back-of-the-envelope run helps. Take a typical agent step that reads 200,000 tokens of repository context and writes 20,000 tokens of reasoning and code, with no cache hits:

• GPT-6.1 Terra: $0.20 input + $0.10 output = $0.30
• GPT-6.1 Sol or Sonnet 5.5: $0.40 + $0.20 = $0.60
• Opus 5.5: $0.80 + $0.40 = $1.20

Run that step 500 times a day across a team's CI and review bots and the gap is $150 versus $300 versus $600 a day. With prompt caching, which agent loops hit heavily, the input side shrinks for every model and output tokens dominate the bill. Keep a single request under 272,000 input tokens or Terra's long-context multiplier erases much of its advantage.

OpenAI also claims Terra finishes tasks more than three times faster on average than Sol or Astra, and that in ChatGPT Work and Codex the same plan allowance “goes further” with Terra. If you use Codex through a ChatGPT plan instead of the API, that allowance is the number that matters. OpenAI hasn't published how much further.

Where Terra fits in a coding workflow

OpenAI is unusually direct about the limits. Its announcement recommends Sol or Astra “for in-depth research or complex coding.” Coverage from DataCamp and Developers Digest reports, from OpenAI's charts, that Terra scored 50.3% on Terminal-Bench 4.0 at max effort, up from 21.5% for GPT-5.6 Terra. We couldn't confirm those figures in OpenAI's text, which only shows them as images, and nobody has published an independent run yet.

Our read, based on the pricing and OpenAI's own positioning:

• Good fit: subagents that search, summarize, or gather context for a stronger model; first-pass code review and lint-style feedback; CI failure triage; issue labeling; writing PR descriptions and changelogs; browser and UI testing that needs computer use.
• Try it, then measure: routine bug fixes and small features in a well-tested repository, where a failed attempt is cheap to retry and the test suite catches mistakes.
• Keep the bigger model: cross-cutting refactors, unfamiliar codebases, concurrency and security-sensitive changes, and long unattended runs where one wrong turn wastes hours. Our overnight agent run piece shows how much review those runs already need.

The pattern that tends to pay off is routing: a cheaper model does the high-volume steps, and a stronger one plans and makes the hard edits. Terra makes the cheap tier more capable without dropping all the way to Luna.

How to try it

Codex CLI. Pick it per session with the model flag, or use it for one non-interactive task:

codex -m gpt-6.1-terra
codex exec -m gpt-6.1-terra "triage the failing test in CI and propose a fix"

API. Use the Responses API if you want the agent tools. Start at the default medium effort and only raise it where you've measured a difference:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-terra",
    "reasoning": { "effort": "medium" },
    "input": "Summarize why this stack trace fails: ..."
  }'

Copilot. Choose it in the model picker once the rollout reaches you. Admins control access with the model policy in Copilot settings. New models are on by default unless an admin has turned off the global default. Note the billing line in GitHub's changelog: Terra is “billed at provider list pricing under usage-based billing,” so check what that means for your plan before making it a team default. Our Copilot metrics piece covers what Copilot's usage numbers can and can't tell you.

What we don't know yet

There's no independent coding benchmark for Terra yet, and OpenAI's comparison charts aren't readable as text. We don't know how many tokens Terra uses per task compared with Sol, Sonnet 5.5, or Opus 5.5, which decides the real cost more than the price list does. Support in third-party agents such as OpenCode, Aider, and Cline depends on each tool's model list, so check yours after updating. We'll revisit this page once there are reproducible results.

Sources

• OpenAI Developer Community: GPT-6.1 Terra announcement (October 26, 2026): availability, positioning, speed, and plan allowance claims.
• OpenAI Help Center: Model release notes: release date and rollout.
• OpenAI API docs: GPT-6.1 Terra: context, effort levels, tools, pricing rules, and rate limits.
• OpenAI API docs: Pricing: Luna, Terra, Sol, and Astra prices.
• GitHub Changelog: GPT-6.1 Terra in GitHub Copilot (October 26, 2026).
• Claude docs: Sonnet 5.5 and Opus 5.5: Anthropic prices.
• 9to5Mac (October 26, 2026): model family history.
• DataCamp and Developers Digest: secondary reporting of OpenAI's benchmark charts.