← All guides AI Release RU Subscribe to @ai_release1

GPT-6.1 Terra vs GPT-6.1 Sol: Which to Choose for Work, Code, and API

Q: Do I need to rewrite my code to switch models?

No. With the `ROUTES` dictionary and the two environment variables, switching is a one-line change; only the execution path differs when a task is GUI-driven and has to run in the desktop product instead of the API.

Updated: 14.11.2026 · AI Release · @ai_release1

GPT-6.1 Terra vs GPT-6.1 Sol: Which to Choose for Work, Code, and API

TL;DR

Time to complete: 45 minutes
Difficulty level: Intermediate
You will need: macOS 13+/Windows 11/Ubuntu 22.04 with a terminal, Python 3.10+, pip install openai, curl, jq, an OpenAI API key with access to both model strings, ~1 GB free disk
The two source posts publish no price and no speed figures for GPT-6.1 Terra, so the only honest way to choose is to measure both models on your own task before you commit a budget.
Terra is positioned as a desktop-app agent: OpenAI scores it on OSWorld 2.1, a benchmark where the model has to perform multi-step tasks inside ordinary applications (the published example is assembling a 3D model from a technical drawing).
GPT-6.1 Sol is the model our channel covers for API work, automation scenarios and cost/access — see the full GPT-6.1 Sol overview.
Keep both model strings in environment variables: the switch between Terra and Sol then costs one line of code, not a refactor.

Requirements and setup

Operating system: macOS 13+, Windows 11, or Ubuntu 22.04 with a POSIX shell.
Python 3.10 or newer with pip.
The official OpenAI SDK: pip install --upgrade openai.
An API key whose account has access to both models. The GPT-6.1 Terra announcement at openai.com/index/introducing-gpt-6-1-terra/ does not publish an API model string — take the exact strings from your account dashboard or the docs, and do not guess them.
curl and jq for the account check below.
One real input file from your own workflow (for example tasks/task_01.txt) — a benchmark on someone else's prompt tells you nothing about your job.

Prepare the workspace and the checklist:

mkdir -p gpt61-pick/{tasks,results} && cd gpt61-pick
python3 --version && jq --version && curl --version | head -1

Expected output — three lines, versions only, no errors:

Python 3.10.13
jq-1.7.1
curl 8.5.0

[ ] python3 --version prints 3.10 or higher
[ ] pip show openai returns a package entry
[ ] Your API key is exported as OPENAI_API_KEY
[ ] Both model strings are written down from the docs, not from memory
[ ] tasks/task_01.txt contains a real task from your workflow
[ ] results/ exists and is writable

Confirm that your key actually sees both models before writing any code — this is the step most people skip and then spend an hour debugging a 404:

curl -s https://api.openai.com/v1/models \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  | jq -r '.data[].id' | sort | grep -iE 'sol|terra'

Example: if your account has both, you see two lines — one containing sol, one containing terra. An empty result means the key or the plan is wrong, not the script.

Why this works: /v1/models lists the model strings your key is allowed to call, so it separates "I typed the name wrong" from "my account has no access" in one command.

Step 1. Write the two-model harness and capture one baseline per model

What to do: create one .env, one prompt file per task class, and one script that sends the identical prompt to both models and writes a JSON record for each.

Why: a comparison only means something if the prompt, temperature settings and machine are identical. A harness enforces that and gives you timings you can re-run later.

Create .env:

OPENAI_API_KEY="sk-..."
SOL_MODEL="<model-string-from-docs-for-sol>"
TERRA_MODEL="<model-string-from-docs-for-terra>"

The two <…> values are placeholders: replace each with the exact string your dashboard shows. The Terra announcement page publishes none, so do not invent one.

Create bench.py:

import json, os, time
from pathlib import Path
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
MODELS = {"sol": os.environ["SOL_MODEL"], "terra": os.environ["TERRA_MODEL"]}
PROMPT = Path("tasks/task_01.txt").read_text()

for key, model in MODELS.items():
    t0 = time.perf_counter()
    try:
        # If the docs specify a different endpoint or a reasoning setting
        # (the Terra description mentions a "medium reasoning" mode),
        # change only this call — the measurement stays valid.
        r = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": PROMPT}],
        )
        out = r.choices[0].message.content
    except Exception as e:
        out = f"ERROR: {type(e).__name__}: {e}"
    dt = time.perf_counter() - t0
    rec = {"model_key": key, "model": model,
           "seconds": round(dt, 2), "chars": len(out), "output": out}
    Path(f"results/{key}.json").write_text(json.dumps(rec, indent=2, ensure_ascii=False))
    print(f"{key:6s} {dt:6.2f}s chars={len(out)}")

How to check: load the environment, then run it.

set -a; source .env; set +a
python bench.py
ls -l results/

Expected screen output — two lines, one per model, plus two files:

sol     4.12s chars=1830
terra  11.87s chars=2140
-rw-r--r-- 1 user staff  4211 results/sol.json
-rw-r--r-- 1 user staff  4870 results/terra.json

The seconds above are what your own run prints, not a published benchmark: OpenAI published no speed figures for Terra in the announcement.

Why this works: both calls read from the same task_01.txt and the same process, so the only variable left is the model itself.

Step 2. Route each task class to Terra or Sol

What to do: decide per task class, not per model, and encode the decision in one dictionary. Then pick the right execution path: API for text-shaped work, desktop product for GUI work.

Why: Terra is announced around OSWorld 2.1 — an agent that must drive normal desktop applications through several steps. A single API prompt cannot exercise that. Sol is what our channel's API and automation guides cover (text processing, service integration). Mixing the two up produces a "bad" benchmark that only reflects the wrong execution path.

Model	What differs (per the source posts)	Price
GPT-6.1 Terra	OpenAI's desktop-agent model, announced at `openai.com/index/introducing-gpt-6-1-terra/`; scored on OSWorld 2.1 with multi-step tasks in desktop apps (example: build a 3D model from a technical drawing); a "medium reasoning" mode is mentioned	Not published in the announcement — check the docs
GPT-6.1 Sol	Covered by our API how-to, automation-scenarios guide, pricing/access guide, and a Sol-vs-GPT-4o comparison	Not stated in these posts — see the [Sol overview](https://ai-release.org/guides/gpt-6-1-sol-polnyy-obzor.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide)

Routing table for the code:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

ROUTES = {
    "desktop_multi_step":  os.environ["TERRA_MODEL"],  # GUI tasks, OSWorld 2.1 style
    "text_batch":          os.environ["SOL_MODEL"],    # text processing
    "service_integration": os.environ["SOL_MODEL"],    # calls into your services
    "code_task":           os.environ["SOL_MODEL"],    # unverified, measure first
}

def run(task_class: str, prompt: str) -> str:
    model = ROUTES[task_class]
    r = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    return r.choices[0].message.content

print(run("text_batch", "Summarise tasks/task_01.txt in 5 bullets."))

Example: run python routes.py and you get a five-bullet summary back, produced by whichever string sits in SOL_MODEL. Change one line in ROUTES and the same call goes to Terra — no other edit.

Where this does NOT work: if your task is "open the CAD app, read the drawing, place the parts", the API harness cannot score it. Run that task in the desktop product and keep the API numbers for text-shaped work only. If you are still choosing the surrounding stack for agent runs, compare the workflow options in Jujutsu or Git for AI agent workflows and the model-selection article GPT-6 Astra vs GPT-6.1 Sol.

Why this works: the model string lives in exactly one place, so an A/B switch is a one-token change and your logs keep the model_key label.

Step 3. Aggregate the runs, compare, and lock the decision

What to do: repeat the harness over 5–10 real tasks per class, aggregate with jq, then write the decision down.

Why: one run is noise. A written decision log stops the team from re-litigating the choice every sprint.

jq -s 'map({model_key, seconds, chars})' results/*.json

Example output from your own run:

[
  { "model_key": "sol",   "seconds": 4.12, "chars": 1830 },
  { "model_key": "terra", "seconds": 11.87, "chars": 2140 }
]

Success looks like this:

[ ] Each model produced 5–10 recorded runs per task class
[ ] No ERROR: string inside any results/*.json
[ ] Quality judged blind: rename files to a.json / b.json before scoring so the model name does not bias you
[ ] A cost line in your decision log, filled from your account's billing page, not from an announcement
[ ] ROUTES committed with a comment naming the date of the last measurement

Why this works: jq -s merges all result files into one array, so time and output size sit side by side and you compare like with like.

Troubleshooting

Problem. One of the two calls returns 404 while the other works.

Error: openai.NotFoundError: Error code: 404 - The model '<your-model-string>' does not exist or you do not have access to it.
Cause: the Terra announcement page publishes no API model string, so a guessed name fails; or the key's plan does not include that model.
Solution: run the /v1/models check from Requirements. Still empty? Keep Sol on the API path and perform Terra's GUI tasks in the desktop product. Fix the string in .env, then re-run python bench.py.

Problem. The script crashes before any request is sent.

Error: KeyError: 'TERRA_MODEL'
Cause: .env was never loaded into the shell, so os.environ has no entry.
Solution: load it and confirm, then re-run.

set -a; source .env; set +a
python -c "import os; print(os.environ['TERRA_MODEL'])"

On PowerShell, set $env:SOL_MODEL and $env:TERRA_MODEL in the session instead.

Problem. The second model in the loop fails immediately.

Error: openai.RateLimitError: Error code: 429 - Rate limit reached for requests
Cause: both calls fire back to back and hit your organisation's request limit.
Solution: add a retry with backoff around the call, and run the loop sequentially.

import time
for attempt in range(4):
    try:
        r = client.chat.completions.create(model=model, messages=[{"role": "user", "content": PROMPT}])
        break
    except Exception:
        time.sleep(2 ** attempt)

Summary and next steps

Run one identical prompt through GPT-6.1 Sol and GPT-6.1 Terra with the harness above, keep both model strings in .env, and route per task class — API work to Sol, multi-step desktop-app work to Terra. Next, repeat the measurement on ten real tasks and record the winning route with the date, since no price or speed figure for Terra was published in the announcement.

FAQ

Is GPT-6.1 Terra better than GPT-6.1 Sol for coding?

Not answerable from the source posts: neither the Terra announcement nor our Sol guides publish a code-specific benchmark, and Terra's published evaluation is OSWorld 2.1 desktop tasks. Put your own repo task into tasks/task_01.txt and measure both.

How much does GPT-6.1 Terra cost?

The announcement publishes no price and no country list — it only describes the OSWorld 2.1 evaluation and a mention of a "medium reasoning" mode. Take the current figure from your account's pricing page or the docs.

Which model should I use for desktop automation?

Terra, because that is the capability OpenAI chose to demonstrate: multi-step tasks inside ordinary desktop applications, such as assembling a 3D model from a technical drawing. For text batches and service integrations, route to Sol.

Do I need to rewrite my code to switch models?

No. With the ROUTES dictionary and the two environment variables, switching is a one-line change; only the execution path differs when a task is GUI-driven and has to run in the desktop product instead of the API.

🤖 AI summary

AI Release Knowledge Layer
Machine-readable description · Version 1.0

Status: practical guide. Some statements come from vendors; verify in your environment.

1. Summary

Time to complete: 45 minutes Difficulty level: Intermediate

Inside: direct answers, key facts, entities, context, reliability, unknowns and sources.

Machine data: Citation Map JSON · JSON-LD · Semantic Embeddings — separate stage.

Full Knowledge Layer: sections 2–8

2. Direct answers

What is required?: Operating system: macOS 13+, Windows 11, or Ubuntu 22.04 with a POSIX shell.; Python 3.10 or newer with pip.; The official OpenAI SDK: pip install --upgrade openai.; An API key whose account has access to both models. The GPT-6.1 Terra announcement at openai.com/index/introducing-gpt-6-1-terra/ does not publish an API… → details (AR-GUIDE-GPT61TERRA-003)
How to do it?: Step 1. Write the two-model harness and capture one baseline per model → Step 2. Route each task class to Terra or Sol → Step 3. Aggregate the runs, compare, and lock the decision → details (AR-GUIDE-GPT61TERRA-004)
Which topics does it cover?: GPT-6.1 Terra, GPT-6.1 Sol, GPT-6.1 Terra или Sol, сравнение GPT-6.1 → details (AR-GUIDE-GPT61TERRA-002)
What are the key points?: Time to complete: 45 minutes Difficulty level: Intermediate → details (AR-GUIDE-GPT61TERRA-007)

3. Key facts

Time to complete: 45 minutes — evidence; status: заявление источника.
Difficulty level: Intermediate — evidence; status: заявление источника.
You will need: macOS 13+/Windows 11/Ubuntu 22.04 with a terminal, Python 3.10+, pip install openai, curl, jq, an OpenAI API key with access to both model strings, ~1 GB free disk — evidence; status: заявление источника.
The two source posts publish no price and no speed figures for GPT-6.1 Terra, so the only honest way to choose is to measure both models on your own task before you commit a budget. — evidence; status: заявление источника.
Terra is positioned as a desktop-app agent: OpenAI scores it on OSWorld 2.1, a benchmark where the model has to perform multi-step tasks inside ordinary applications (the published example is assembling a 3D model from a technical drawing). — evidence; status: заявление источника.
Operating system: macOS 13+, Windows 11, or Ubuntu 22.04 with a POSIX shell. — evidence; status: заявление источника.
Python 3.10 or newer with pip. — evidence; status: заявление источника.
The official OpenAI SDK: pip install --upgrade openai. — evidence; status: заявление источника.

4. Entities

Entity	Type	Role
GPT-6.1 Terra	продукт/модель	упоминается в заголовке, TL;DR или разделах гайда
GPT-6.1 Sol	продукт/модель	упоминается в заголовке, TL;DR или разделах гайда
GPT-6.1 Terra или Sol	продукт/модель	упоминается в заголовке, TL;DR или разделах гайда
сравнение GPT-6.1	продукт/модель	упоминается в заголовке, TL;DR или разделах гайда
Windows	платформа/технология	упоминается в заголовке, TL;DR или разделах гайда
macOS	платформа/технология	упоминается в заголовке, TL;DR или разделах гайда
Python	платформа/технология	упоминается в заголовке, TL;DR или разделах гайда
OpenAI	компания	упоминается в заголовке, TL;DR или разделах гайда
GPT-6.1	продукт/модель	упоминается в заголовке, TL;DR или разделах гайда
gpt-6	продукт/модель	упоминается в заголовке, TL;DR или разделах гайда

5. Context

Guide — describes → GPT-6.1 Terra vs GPT-6.1 Sol: Which to Choose for Work, Code, and API (AR-GUIDE-GPT61TERRA-001).
Guide — includes step → Step 1. Write the two-model harness and capture one baseline per model (AR-GUIDE-GPT61TERRA-001).

6. Reliability

Confirmed

No independent confirmation is provided; source claims and editorial conclusions are separated below.

Source claims

Product features, versions, prices and limits come from vendors and the guide.
Commands and steps are recommendations, not guaranteed results.

AI Release analysis

Structure, comparison and selection criteria are editorial.
The guide does not replace an independent audit or legal advice.

7. Unknowns

Current versions, prices and limits.
Independent benchmarks and quality checks.
Terms of use and data policy.

8. Sources

Source	Type	Role
api.openai.com	внешний источник	ссылка из тела гайда

Cite as: AI Release. GPT-6.1 Terra или GPT-6.1 Sol: что выбрать для работы, кода и API. ai-release.org.