If you still point production code or Codex at a GPT-5.x model, the default replacement is now gpt-6.1-sol: OpenAI’s docs describe it as “near-Astra performance for complex work at a lower cost,” at $2 input / $10 output per 1M tokens. The model-ID change is one line. The parts that actually break are four request details: GPT-6.1 Sol rejects the none and minimal reasoning efforts, tool calling only works through the Responses API, temperature/top_p/logprobs must go, and prompt caching uses prompt_cache_options.ttl instead of prompt_cache_retention. This guide walks through each one with working requests from OpenAI’s documentation, then covers Codex.

Key facts (from OpenAI’s docs, checked October 19, 2026):

• Three current API models: gpt-6-astra (most capable, $10/$50), gpt-6.1-sol (balanced, $2/$10), gpt-6-luna (cheapest, $0.10/$0.50). All three have a 1.05M-token context window and 128K max output.
• GPT-6.1 Sol shipped September 29, 2026. It replaces the older gpt-6-sol (September 22) as the recommended Sol model, at the same base price but with cheaper cache reads ($0.10 vs $0.20 per 1M).
• Astra and GPT-6.1 Sol support reasoning efforts low, medium, high, xhigh, max. No none. Luna and the old GPT-6 Sol still accept none.
• Prompts over 272K input tokens are billed at 2x input and cache rates and 1.5x output for the whole request.
• Codex: GPT-5.5 retired from Codex for ChatGPT sign-ins on October 14, 2026. Use codex -m gpt-6.1-sol or model = "gpt-6.1-sol" in config.toml. API-key sessions are not affected.

More model-switching guides are linked from the 7minai homepage. If you are coming from GPT-5.5 rather than 5.6, our earlier GPT-5.6 switching guide explains the Sol/Terra/Luna naming that GPT-6 continues.

1. Pick the right GPT-6 model

OpenAI’s model catalog says to start with Astra for complex reasoning and coding, choose GPT-6.1 Sol “to balance intelligence and cost,” and use Luna for cost-sensitive, high-volume workloads. Here are the numbers from each model page:

	GPT-6 Astra	GPT-6.1 Sol	GPT-6 Luna
Model ID	gpt-6-astra	gpt-6.1-sol	gpt-6-luna
Released (API)	Sep 3, 2026	Sep 29, 2026	Sep 22, 2026
Input / output per 1M tokens	$10 / $50	$2 / $10	$0.10 / $0.50
Cached input per 1M	$1.00	$0.10	$0.01
Cache writes per 1M	$12.50	$2.50	$0.125
Reasoning efforts	low, medium, high, xhigh, max	low, medium (default), high, xhigh, max	none, low, medium (default), high, xhigh, max
Context / max output	1.05M / 128K	1.05M / 128K	1.05M / 128K
Knowledge cutoff	Apr 30, 2026	Apr 30, 2026	May 18, 2026

All three take text and image input and return text. The catalog lists functions, web search, file search and computer use as tools for each of them.

A practical way to choose:

• Default to gpt-6.1-sol for coding agents, computer use and document work. OpenAI’s Codex model guide recommends it “for repeated, long-running work across code, apps, and documents” when cost matters.
• Use gpt-6-astra for your hardest end-to-end tasks, and test it against Sol on your own workload. At 5x Sol’s per-token price, Astra has to earn its place. OpenAI’s own maintenance case study, which we covered in GPT-6.1 Sol at 14% of Astra’s cost, is a useful example of running that comparison.
• Use gpt-6-luna for extraction, classification, transformation and structured summaries, where you know what a good answer looks like. It is the only current flagship that still supports reasoning.effort: "none".

2. Make the one-line switch in the Responses API

OpenAI’s GPT-6 guide says: “To get started, set model in a Responses API request.” With the official Python SDK, a minimal request looks like this:

from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY from the environment

response = client.responses.create(
    model="gpt-6.1-sol",
    reasoning={"effort": "medium"},
    input="Summarize the risks in this migration plan: ...",
)
print(response.output_text)

The same request with curl:

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.1-sol",
    "reasoning": {"effort": "medium"},
    "input": "Summarize the risks in this migration plan: ..."
  }'

medium is GPT-6.1 Sol’s default, so you can omit reasoning entirely. If you are on Chat Completions without tools, the model also works there; the effort parameter is then the top-level reasoning_effort field rather than reasoning.effort.

OpenAI also ships a migration helper. If you use Codex, the guide says it can apply the recommended changes with the OpenAI Docs skill:

$openai-docs migrate this project to the GPT-6 model family

Review the diff it produces against the checklist below rather than merging it blind.

3. The migration checklist: four things that break

The migration quickstart lists these checks after you set the model to gpt-6-astra, gpt-6.1-sol or gpt-6-luna. Each one is a request that worked on GPT-5.x and can fail or misbehave on GPT-6.

Step 1: Replace none and minimal reasoning effort

GPT-6 Astra and GPT-6.1 Sol do not accept none. OpenAI’s instruction is to “use low instead.” If you used minimal, start with low and compare results on representative tasks.

# Before (GPT-5.6 / GPT-6 Sol)
reasoning={"effort": "none"}

# After (GPT-6.1 Sol or Astra)
reasoning={"effort": "low"}

If your workload really needs none, for example a latency-critical classifier, that is a signal to route it to gpt-6-luna instead, which still supports it.

Step 2: Move tool calling to the Responses API

This is the change most likely to break a working app. In OpenAI’s words: “GPT-6 Astra and GPT-6.1 Sol support Chat Completions, but tool calling requires Responses.” The older GPT-6 Sol and GPT-6 Luna allow function calling in Chat Completions only with reasoning_effort: "none".

So if you have a Chat Completions request with a tools array, switching the model string to gpt-6.1-sol is not enough. Port that call to client.responses.create(...). Requests without tools can stay on Chat Completions.

The same constraint shows up in Codex: the Codex model docs say current Codex releases don’t support wire_api = "chat" or a Chat Completions-only endpoint when you configure a custom provider or gateway.

Step 3: Remove sampling and logprob parameters

When reasoning effort is anything other than none, which on Astra and GPT-6.1 Sol is always, remove:

• temperature
• top_p
• top_logprobs
• logprobs (Chat Completions)
• message.output_text.logprobs from the include array (Responses)

The Astra launch note in the API changelog states it plainly: GPT-6 Astra “does not support custom temperature or top_p values or log probabilities.” If an evaluation harness depends on logprobs, keep that harness on a model that supports them, or rework the metric.

Step 4: Update the prompt-cache field

If you are migrating from GPT-5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl set to "30m". Per the prompt caching guide, 30m is both the only supported value and the default on GPT-5.6 and later: a cached prefix stays eligible for reuse for 30 minutes after its most recent write or reuse.

# Before (GPT-5.5 and earlier)
prompt_cache_retention="24h"

# After (GPT-5.6 and later, including the GPT-6 family)
prompt_cache_options={"ttl": "30m"}

Two billing details change with it. Cache writes now cost 1.25x the uncached input rate, and cache reads on GPT-6.1 Sol cost 0.05x the input rate (0.1x on other GPT-5.6+ models). Track usage.input_tokens_details.cached_tokens and usage.input_tokens_details.cache_write_tokens before and after the switch to see your real cost. On GPT-5.6 and later, OpenAI routes caches automatically, so prompt_cache_key is only needed if you want separate cache accounting per customer or user.

Coming from gpt-6-sol? Two extra checks

The gpt-6-sol model page now says “See GPT-6.1 Sol for the newer Sol model.” The base price is identical ($2/$10), but the two are not drop-in identical:

	gpt-6-sol	gpt-6.1-sol
none effort	Supported	Not supported
Function calling in Chat Completions	Only with reasoning_effort: "none"	Not supported; use Responses
Cached input per 1M	$0.20	$0.10
Knowledge cutoff	Apr 20, 2026	Apr 30, 2026
Ultrafast mode	Not listed	Supported

If your gpt-6-sol code relied on none plus Chat Completions function calling, you must port it to Responses with at least low effort before switching.

4. Know what you will actually pay

Every GPT-6 price above applies to prompts up to 272K input tokens. Beyond that, OpenAI bills the full request at 2x input and cache rates and 1.5x output. For GPT-6.1 Sol, from the pricing page:

GPT-6.1 Sol tier	Input	Cached input	Cache writes	Output
Standard, short context	$2.00	$0.10	$2.50	$10.00
Standard, long context (>272K)	$4.00	$0.20	$5.00	$15.00
Batch / Flex, short context	$1.00	$0.05	$1.25	$5.00
Fast, short context	$4.00	$0.20	$5.00	$20.00
Ultrafast, short context	$12.00	$0.60	$15.00	$60.00

Prices are per 1M tokens. Regional processing (data residency) endpoints add a 10% uplift for models released on or after March 5, 2026.

Two consequences for coding agents. First, an agent that drags a whole repository or long tool transcript into every turn can cross 272K and quietly pay the long-context column; measure input length per request before you trust the $2/$10 headline. Second, because cache reads are only $0.10 per 1M on Sol, a stable prompt prefix (system prompt, tool definitions, reference docs first; changing user state last) is the cheapest optimization you have. Our GPT-6 Sol and Luna launch brief has more on the 272K boundary.

5. Use Fast or Ultrafast mode when latency matters

Both are service tiers you set per request with service_tier.

Fast mode (formerly Priority processing, renamed July 30, 2026) promises “up to 2.5× faster speeds” at 2x Standard price. The Fast mode guide shows:

response = client.responses.create(
    model="gpt-6.1-sol",
    input="Draft release notes from this changelog: ...",
    service_tier="fast",
)

service_tier="priority" still works with the same behavior on supported models.

Ultrafast mode is the fastest tier, available for GPT-6 Astra and GPT-6.1 Sol at 6x Standard price. It was added for GPT-6.1 Sol on October 8, 2026 and is open to all API users, with separate rate limits from Standard and Fast. OpenAI strongly recommends a WebSocket connection, especially for agents that make many quick tool calls. This is OpenAI’s Ultrafast example with the model set to Sol, which the guide lists as supported:

# pip install --upgrade "openai[realtime]"
from openai import OpenAI

client = OpenAI()
previous_response_id = None
prompts = [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
]

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

Data residency differs by model. Fast mode supports EU data residency for GPT-6.1 Sol, GPT-6 Sol and GPT-6 Luna, but not Astra. Ultrafast for GPT-6.1 Sol supports US and EU data residency and global processing; Astra’s Ultrafast supports US data residency and global processing only. If you are bound to EU processing, GPT-6.1 Sol is the only model that gives you the fastest tier.

6. Change reasoning effort mid-conversation without losing the cache

GPT-6 adds a configuration_update input item. Instead of changing reasoning.effort on the request, which changes the prompt prefix that caching depends on, you insert an update before the next user message. From OpenAI’s reasoning guide, adapted to GPT-6.1 Sol:

model = "gpt-6.1-sol"

first = client.responses.create(
    model=model,
    reasoning={"effort": "low"},
    input="Draft a database migration plan.",
    store=True,
)

second = client.responses.create(
    model=model,
    previous_response_id=first.id,
    reasoning={"effort": "low"},  # keep the request-level setting unchanged
    input=[
        {"type": "configuration_update", "reasoning": {"effort": "high"}},
        {"role": "user", "content": "Analyze the failure modes and propose rollback steps."},
    ],
    store=True,
)
print(second.output_text)

The new effort applies to that response and later ones until another update overrides it. The rules to know:

• It works in standard, single-agent mode and changes only reasoning effort.
• The response’s reasoning.effort keeps reporting the request-level value, not the one the update selected, so don’t use it to verify the switch.
• The API rejects two configuration_update items placed directly next to each other.
• Don’t combine updates with automatic compaction or automatic truncation; the standalone /responses/compact endpoint rejects histories that contain them. After an explicit compaction, add a fresh update before the next user message.

This pattern suits agents that do cheap routine steps at low and only need high for a hard planning turn.

7. Switch Codex to GPT-6.1 Sol

GPT-5.5 retired from Codex for users signed in with ChatGPT on October 14, 2026, at noon PDT (19:00 UTC). OpenAI’s Codex model page says Plus, Pro, Business, Enterprise and Edu users should choose gpt-6.1-sol, and Free and Go users should choose gpt-6-luna in the desktop app. Codex sessions authenticated with an API key, and the API itself, are not affected.

One session, from the CLI:

codex --model gpt-6.1-sol
# or for a non-interactive run
codex exec -m gpt-6.1-sol "Review the current changes"

Inside an interactive session, /model switches models or adjusts effort. To see Max or Ultra, choose a model in /model and then select More reasoning….

As your default: the ChatGPT desktop app, Codex CLI and IDE extension share one config.toml. Add:

model = "gpt-6.1-sol"

Then search everything else that hardcodes a model. OpenAI’s list for the GPT-5.5 retirement is workspace defaults, saved model settings, managed configurations, custom agents, scheduled tasks and scripts. A quick way to find stragglers in a repo:

grep -rn "gpt-5\.5\|gpt-5\.4\|gpt-5\.3-codex" --include="*.toml" --include="*.json" --include="*.yml" --include="*.yaml" --include="*.sh" .

Plan and rollout details from the same page:

• The GPT-6.1 Sol rollout covers Plus, Pro, Business, Enterprise and Edu in Codex (desktop app and CLI) and ChatGPT Work. Free and Go were not included at launch.
• Enterprise and Edu keep GPT-6.1 Sol off by default until an administrator enables it. If the model doesn’t appear, that’s the first thing to check.
• Ultrafast in Codex is limited to Pro $500 and eligible Enterprise and Edu plans.
• In ChatGPT, GPT-6.1 Sol, GPT-6 Sol and GPT-6 Luna are available in Work and Codex, not in regular Chat.
• For effort, OpenAI suggests starting GPT-6.1 Sol at your client’s default, Luna at High, and Astra at Light (low in config). Efforts “don’t map exactly between model generations,” so re-test a familiar task rather than copying your old setting.

Before you give a cheaper, faster model more autonomy, keep the same review boundary you had before. Our Codex Security guide covers least-privilege credentials and patch review for Codex agents.

8. Adjust your prompts for GPT-6 behavior

OpenAI’s guide lists behaviors it observed with GPT-6 Astra and suggests testing the same prompts on whichever GPT-6 model you choose:

• It asks more questions. Astra is “more likely to ask the user a question when additional input could materially change the result,” which can make an agent stop where GPT-5.x would have assumed and carried on. OpenAI provides an autonomy prompt that starts: “You should infer the user’s intent and task scope from the instructions and prior conversation context. Your job is to bias towards action and carry the user’s intended task to completion.” Add it to your system prompt if your harness needs fewer pauses.
• It follows instructions in files more closely. The guide warns Astra “can be more sensitive to instructions contained in skills and other files, such as AGENTS.md,” and recommends auditing those files. Stale or conflicting instructions in an old AGENTS.md are a common cause of an agent stopping early after the switch.
• It delegates less than you might want. If you run a multi-agent harness, tell it when to use subagents.
• It tests thoroughly. For small changes this can mean broader test runs than needed; OpenAI’s suggested prompt tells the model to run tests appropriate to the change and only broaden testing when new failures justify it.
• It formats heavily. Expect lists and tables by default; specify prose if your product needs it.

Troubleshooting

My Chat Completions request with tools fails after switching to gpt-6.1-sol. Expected. Tool calling on Astra and GPT-6.1 Sol requires the Responses API. Port the call, or keep that endpoint on a model that supports Chat Completions function calling.

The request is rejected for its reasoning effort. You are sending none or minimal to Astra or GPT-6.1 Sol. Use low, or move the workload to gpt-6-luna, which accepts none.

A parameter error mentions temperature, top_p or logprobs. Remove those fields (and the message.output_text.logprobs include on Responses). They aren’t supported when the model is reasoning.

My bill went up even though Sol is $2/$10. Check three things: whether requests exceed 272K input tokens (the whole request is then billed at the long-context rates), how many tokens appear in cache_write_tokens (writes cost 1.25x input), and whether you set service_tier to fast or ultrafast somewhere.

gpt-6.1-sol doesn’t show up in Codex. On Enterprise or Edu, an admin must enable it first. On Free or Go, it wasn’t part of the launch rollout; use gpt-6-luna. If you sign in with an API key, availability follows your API organization and project.

Codex stopped working after October 14. If your config, a custom agent or a script still says gpt-5.5 and you sign in with ChatGPT, that model has retired from Codex. Replace it as shown in section 7.

Ultrafast requests are throttled. Ultrafast has separate rate limits from Standard and Fast. Check your organization’s limits before shifting traffic.

FAQ

Is GPT-6.1 Sol better than GPT-6 Astra? No. OpenAI positions it as near-Astra performance at a lower cost. Astra remains the most capable model; the choice is a cost and quality tradeoff you should test on your own tasks.

Should I still use gpt-6-sol? It still has a model page, but OpenAI points to GPT-6.1 Sol as the newer Sol model, and 6.1 has cheaper cache reads at the same base price. Stay on gpt-6-sol only if you depend on none effort or Chat Completions function calling and can’t port yet.

Does the GPT-5.5 retirement affect my API calls? No. It applies to Codex with ChatGPT sign-in. The OpenAI API and API-key Codex sessions still have GPT-5.5.

Is there a GPT-6 Terra? OpenAI’s GPT-6 docs don’t list one. The current flagship lineup in the catalog is Astra, GPT-6.1 Sol and Luna. If you used gpt-5.6-terra as a middle tier, GPT-6.1 Sol is the closest current fit by price.

Can I use pro mode, multi-agent and Programmatic Tool Calling with GPT-6? OpenAI says GPT-6 supports the existing GPT-5.6 API capabilities, including computer use, Structured Outputs, streaming, Programmatic Tool Calling, multi-agent orchestration, prompt caching, persisted reasoning, compaction and pro mode. GPT-6.1 Sol’s launch note specifically mentions Multi-agent in beta.

Sources

• OpenAI: Using GPT-6 (model guide and migration quickstart)
• OpenAI API model catalog and the model pages for GPT-6.1 Sol, GPT-6 Astra, GPT-6 Luna and GPT-6 Sol
• OpenAI API pricing
• OpenAI developer changelog (GPT-6 Astra on Sep 3, GPT-6 Sol and Luna on Sep 22, GPT-6.1 Sol on Sep 29, GPT-6.1 Sol Ultrafast on Oct 8, 2026)
• OpenAI prompt caching guide
• OpenAI reasoning guide: change reasoning mid-conversation
• OpenAI Fast mode guide and Ultrafast mode guide
• OpenAI Codex models and GPT-5.5 retirement

Related on 7minai: How to switch to GPT-5.6 · GPT-6 Sol and Luna launch brief · OpenAI’s GPT-6 maintenance playbook · How to switch to Claude Opus 5