GPT-6.1 Sol and the Ultrafast Tier: A Guide for Agent Builders

1. The launch facts, and the naming

GPT-6.1 Sol is a text-and-image-in, text-out reasoning model with a 1,050,000-token context window, up to 128,000 output tokens and a knowledge cutoff of April 30, 2026, according to its model page. OpenAI’s changelog entry for September 29 describes it as built for complex coding and professional work at lower cost than GPT-6 Astra, and lists multi-agent as a beta feature.

About the names: they are confusing, and they are all real. The newest generation is gpt-6-astra, gpt-6.1-sol, gpt-6-sol and gpt-6-luna. The previous generation (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna) is still priced on the pricing page and still appears as the recommended replacement for several retiring models on the deprecations page. I found no gpt-6-terra on the pricing page. Use the exact id gpt-6.1-sol, with the dot.

2. What actually changed versus GPT-6 Sol

Three things moved and one thing got worse. The list price per token is the same as GPT-6 Sol ($2/$10), but cached input halves from $0.20 to $0.10 per million, which matters most for agents that resend a long prefix on every step. Quality moved up: Artificial Analysis scores GPT-6.1 Sol at max effort at 52 on its Intelligence Index, against 48 for GPT-6 Sol and 53 for GPT-6 Astra, as reported by The Batch.

What got worse is speed and flexibility. The Batch cites about 57.7 output tokens per second for GPT-6.1 Sol versus 87.6 for GPT-6 Sol, and the model cannot turn reasoning off: GPT-6 Sol accepts none, GPT-6.1 Sol does not, and OpenAI’s guide says to use low instead. Ultrafast looks like the knob OpenAI gives you to buy that speed back, but that pairing is my reading, not a reason the docs state.

The three moves

3. Evidence, with sources

Read the headline claim as vendor-reported: OpenAI says Sol nearly matches Astra on agentic coding, computer use and professional work. The independent signal is Artificial Analysis. Its Intelligence Index puts GPT-6.1 Sol (max) at 52, one point under Astra (53), at $0.72 per index task versus $3.26 for Astra, as relayed by The Batch.

The same coverage says that on the Coding Agent Index, GPT-6.1 Sol at xhigh running in Codex beat Astra by one point at under 15% of the cost per task, while Claude Sonnet 5.5 and Claude Opus 5.5 in Claude Code held the top two spots. On the general index Opus 5.5 scores 58 and Sonnet 5.5 scores 56, so this is a cost-efficiency story, not a leaderboard win.

4. Quickstart: Ultrafast in the Responses API

Ultrafast is a request parameter, not a different model: same checkpoint, with service_tier set to ultrafast on the Responses API. OpenAI’s Fast mode page uses exactly this shape with service_tier set to fast, and Ultrafast swaps the value. The response object carries a service_tier field, so log it and you can prove which tier served each call.

For agents, the Ultrafast guide strongly recommends WebSockets, because loops with many quick tool calls pay network overhead on every HTTP round trip. You keep one connection open and chain turns with previous_response_id, sending only the new input items. The first two snippets follow the documented examples (the guide’s own examples use gpt-6-astra and say gpt-6.1-sol is supported); the third is my own defensive pattern, not from the docs. I did not run any of them.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    input="Summarize the failing test output in two sentences.",
    reasoning={"effort": "low"},
    service_tier="ultrafast",
)
print(response.output_text)
print(response.service_tier)  # confirm which tier served the call

from openai import OpenAI

client = OpenAI()
previous_response_id = None
prompts = [
    "Find the function that parses the config file.",
    "Now list every caller of that function.",
]

with client.responses.connect() as connection:
    for prompt in prompts:
        connection.response.create(
            model="gpt-6.1-sol",
            service_tier="ultrafast",
            previous_response_id=previous_response_id,
            input=prompt,
        )
        for event in connection:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                previous_response_id = event.response.id
                print()
                break
            elif event.type in {"response.failed", "response.incomplete", "error"}:
                raise RuntimeError(event.to_json())
        else:
            raise RuntimeError("connection closed before the response finished")

from openai import OpenAI, RateLimitError

client = OpenAI()

# A GPT-6 Sol call that breaks on 6.1 Sol:
#   model="gpt-6-sol", reasoning={"effort": "none"}, temperature=0.2
# On GPT-6.1 Sol: no "none" (use "low"), drop temperature/top_p/logprobs.

def ask(prompt, latency_critical=False):
    kwargs = {
        "model": "gpt-6.1-sol",
        "input": prompt,
        "reasoning": {"effort": "low"},
    }
    if latency_critical:
        try:
            return client.responses.create(**kwargs, service_tier="ultrafast")
        except RateLimitError:
            pass  # Ultrafast pool exhausted: fall through to Standard
    return client.responses.create(**kwargs)

5. What to do this week

Treat this as two separate decisions: whether 6.1 Sol replaces your current default, and which few steps deserve Ultrafast. Take them in that order, because Ultrafast multiplies whatever your baseline already costs.

Verdict

GPT-6.1 Sol is the more interesting half of this story: near-Astra quality on independent indices at Sol prices, with cheaper cache reads. For most agent workloads it is the model to evaluate first, with the caveats that it cannot turn reasoning off and that it is not the speed champion at max effort.

Ultrafast is a tool, not a default. Six times the price buys a lower time between output tokens, and only the latency-critical path should pay for it. Keep a Standard fallback, log the tier on every call, and verify the claims on your own workload.