GPT-6.1 Terra vs GPT-6.1 Sol comes down to one trade: Terra costs exactly half of Sol per token and, by OpenAI’s account, runs more than three times faster, while Sol scores 54 to Terra’s 48 on a third-party coding agent benchmark. OpenAI released Terra on October 26 as gpt-6.1-terra, the new middle tier between Sol and GPT-6 Luna.
If you run one coding agent, pick the model you trust and move on. If you run a dozen, the default matters more than the exception, because the default is what most of your agent steps bill at. This post gives you a routing rule for a Crew in Sharkly: Terra as the default for members, Sol for the leader and the hard tail, and the cost per 1,000 agent steps for each mix.
TL;DR
Make GPT-6.1 Terra the default runtime model for Crew members doing routine coding, writing, and computer-use work. Keep GPT-6.1 Sol on the Crew leader and on Tasks that failed twice on Terra. On our illustrative step profile, all-Sol costs $26.55 per 1,000 agent steps, all-Terra costs $13.28, and Terra members under a Sol leader cost $14.60. A Terra-first rule with Sol escalation stays cheaper than all-Sol until half your Tasks escalate.
GPT-6.1 Terra vs GPT-6.1 Sol at a glance
| GPT-6.1 Terra | GPT-6.1 Sol | |
|---|---|---|
| API id | gpt-6.1-terra |
gpt-6.1-sol |
| Input / cached / output per 1M tokens | $1 / $0.05 / $5 | $2 / $0.10 / $10 |
| Coding Agent Index (Artificial Analysis) | 48 | 54 |
| Speed (OpenAI) | over 3x faster on average | baseline |
| Lowest effort level | none |
low |
| OpenAI’s positioning | computer use, writing, visual understanding | the most complex coding |
Every price line is exactly half. That makes the cost side of the decision easy, and it moves the real question to quality: how often does Terra’s lower coding score turn into a rerun?
A few Terra pricing details matter for long agent loops. Batch and Flex cost half the list rate, and Fast mode costs double. A request with more than 272K input tokens bills at 2x input and cache rates and 1.5x output for the whole request. The full card is on OpenAI’s pricing page.
What a default runtime decides
A default runtime model is the model an Agent uses when nobody picks one for a specific run. In a Crew, it decides what the bulk of your steps cost, how long queued Tasks wait, and how many results land in review per day.
An agent step here means one model call inside an agent loop: read context, think, emit a tool call or an edit. A single Task can take dozens of steps. That is why per-step math is more useful than per-Task math when you compare runtimes: Task length varies wildly, step shape does not.
Cost per 1,000 agent steps
To compare mixes, fix one illustrative step: 30K input tokens, of which 85% hit the prompt cache, plus 1,500 output tokens including reasoning. Long agent loops resend the same repository context every step, so a high cache rate is typical once a session warms up.
On list prices with API-key billing, one such step costs $0.0133 on Terra and $0.0266 on Sol. Scaled to 1,000 steps:
| Crew mix | Share of steps on Sol | Cost per 1,000 steps |
|---|---|---|
| All Sol | 100% | $26.55 |
| Terra members, Sol leader | 10% | $14.60 |
| Terra members, Sol leader and hard tail | 25% | $16.59 |
| All Terra | 0% | $13.28 |
| All Terra at higher effort (3,000 output tokens) | 0% | $20.78 |
Two readings stand out. First, moving the leader to Sol costs about $1.30 per 1,000 steps over all-Terra, because a leader plans and delegates, so it takes a small share of the steps. Second, Terra at higher effort still undercuts Sol at its default: doubling output tokens on Terra costs less than switching models.
These figures exclude cache-write charges. If your Computers sign in with a ChatGPT plan instead of an API key, the saving shows up as more runs before you hit plan limits rather than as dollars. OpenAI says Terra is “available to all Plus, Pro, Enterprise, and Edu users in ChatGPT Work and Codex”; Free and Go plans do not include it.
The routing rule for a Sharkly Crew
A Crew in Sharkly is a reusable group of People and Agents coordinated by one leader Agent. Execution is leader-first: the leader reads the Task and the Crew instructions, then handles the work or mentions Agent members for specific pieces. That structure maps cleanly onto two runtimes.
- Leader on GPT-6.1 Sol. The leader interprets an ambiguous goal and decides who acts next. A wrong plan sends every member in the wrong direction, so this seat gets the stronger model. Our Crew leader guide covers why the leader seat is the cheap one to upgrade.
- Members on GPT-6.1 Terra at
medium. Routine coding, refactors, tests, docs, PR descriptions, and computer-use Tasks start here. - Escalate on the second failure. When a Terra member fails a Task twice, a person reassigns it to the Sol variant. Do not let Agents escalate themselves on a hunch; you want the decision visible on the Task.
- Track escalations by Task type. If one class of Task, such as cross-service migrations, escalates every time, route that class to Sol from the start.
- Drop triage to Luna. Labeling and first-pass sorting can move one tier down; the GPT-6 Luna guide covers that lane.
This is a starting rule, not a benchmark result. Run it for a Sprint and let your own escalation rate decide where the line sits.
When Terra-first stops paying
Escalation has a cost: a failed Terra attempt is money spent before the Sol run starts. Price the worst case, where the Terra attempt burns as many steps as a full Sol run would. A Sol run costs S. A Terra attempt costs 0.5S. If a share f of Tasks escalates, the expected cost per Task is 0.5S + f times S.
That equals all-Sol when f reaches 0.5. So Terra-first stays cheaper until half your Tasks escalate. The same arithmetic covers longer runs: Terra stays cheaper per Task until it needs twice as many steps as Sol to finish.
The money break-even sits far out, so the binding limit is usually human time. Every failed attempt is a diff someone may open, a log someone reads, a reassignment someone makes. If your escalation rate passes 20% on a Task type, move that type to Sol even though the token math still favors Terra.
Speed shifts the math too. A model that finishes over three times faster frees the Computer sooner, so queued Tasks start earlier and more runs finish inside a per-Task timeout.
How to set the rule up in Sharkly
Sharkly does not sell tokens. Runs bill against the Codex plan or API key already attached to the Runtime on each Computer, so first confirm Terra works there: Codex CLI 0.159.0 or later, then codex -m gpt-6.1-terra in a terminal.
In Sharkly, the Agents documentation says an Agent “follows the Runtime’s model by default,” and the Model row lets you pick another model from the catalogue that Runtime reports. You can also set the model in Custom arguments on the Agent or Runtime.
Build the rule out of variants rather than edits. A sketch of the three settings:
Agent "Codex, routine" Custom arguments: --model gpt-6.1-terra effort: medium
Agent "Codex, hard tail" Custom arguments: --model gpt-6.1-sol effort: medium
Crew leader Custom arguments: --model gpt-6.1-sol
The docs list “use a different default model” as a reason to create an Agent variant: it keeps the original’s instructions and repositories and overrides the model alone. Two variants keep the board readable, because every Task shows which lane ran it. For a one-off test, the per-run model pick in the Assignee picker overrides the Agent’s default for that run only.
Sharkly keeps context, progress, blockers, results, and human review on the Task whichever model ran it, which is what makes an escalation rate countable in the first place.
What the cheaper default does not change
Terra lowers the cost of producing a change. It does not lower the cost of accepting one. Half-price runs at three times the speed can mean more diffs waiting on a person by Friday. Check your review queue before you add members; human review is the bottleneck covers that side.
It also does not settle the hardest work. OpenAI itself recommends Sol or GPT-6 Astra for the most complex coding, and the six-point gap on the Coding Agent Index points the same way. The rule above keeps that work on Sol by design.
Conclusion
Make Terra the default and Sol the exception. On our step profile, that cuts the bill roughly in half versus all-Sol, with the leader and the hard tail still on the stronger model. Watch the escalation rate, not the token price, to decide when a Task type moves.
Your next step: create one Terra variant of a Codex Agent, put it in a Crew under a Sol leader, and run one Sprint. Sharkly is currently free for organizations of up to 5 people, per the pricing page.
FAQ
Is GPT-6.1 Terra better than GPT-6.1 Sol for coding?
No. Sol scores 54 on Artificial Analysis’s Coding Agent Index and Terra scores 48. Terra wins on price and speed, which is why it suits routine coding rather than the hardest Tasks.
How much cheaper is GPT-6.1 Terra than GPT-6.1 Sol?
Exactly half on every line: $1 versus $2 input, $0.05 versus $0.10 cached, and $5 versus $10 output per million tokens.
Should the Crew leader run on Terra?
Start it on Sol. A leader takes a small share of steps, so the upgrade costs little, and a wrong plan misdirects every member.
Can I use effort none on Sol?
No. GPT-6.1 Sol dropped none, and its lowest level is low. Terra brings none back.
Is GPT-6.1 Terra free?
No. There is no free API tier, and ChatGPT Free and Go plans do not include it. Our post on running GPT-6.1 Sol without an API key explains plan usage versus per-token billing.
How do I switch one Task to Sol without changing the Agent?
Use the per-run model pick in the Assignee picker. It overrides the Agent’s default for that run only.
