gpt-6-sol

GPT-6 Sol

The flagship's training methods, at the tier you reach for often.

Where Sol Sits

OpenAI describe a three-tier structure, and each tier has a stated job.

Sol is positioned by frequency rather than by capability ceiling. Not "when the task is hard" but "when you would otherwise hesitate to call the flagship."

And both Sol and Luna were trained with similar methods to Astra — the positioning is that the flagship's training was brought down a tier, with the savings passed on rather than the capability held back.

It is also the designated replacement for the previous generation in ChatGPT, which retires on 14 October 2026 across consumer and enterprise plans.

The Cache Change Is the Feature

The most consequential thing in this release is not in the model.

Reasoning effort and tool availability can be changed mid-conversation without breaking the cache.

Why that has mattered until now. Prompt caching works by recognising an unchanged prefix. Any change to the request that alters that prefix invalidates the cache, and the whole context is reprocessed at full cost.

Reasoning effort and tool definitions were both in that category. An agent that wanted to raise its effort on a difficult step, or add a tool partway through a task, paid for the entire conversation again.

Which made a natural pattern expensive. Start cheap, escalate only where the task demands it — obviously correct, and until now it cost you the cache every time you escalated.

Now it does not. Begin a long agent run at low effort with a minimal toolset, raise both when a step turns out to be hard, and the accumulated context stays cached.

The rest of the caching changes

A 90% discount on cached reads.

Higher default hit rates — more of what you send is recognised without configuration.

Explicit cache breakpoints, so you can mark where a stable prefix ends rather than relying on inference.

A prompt caching dashboard with a diagnostics tool, which turns cache behaviour from something you deduce from a bill into something you can inspect.

Read all four together and the target is clear: long-running agents that repeatedly resend instructions, files, conversation history, and tool definitions. That resending is a dominant cost in agent products, and this release attacks it from four directions at once.

⚠️ 1.05M Total, 922K Input

The context figure comes with a sub-limit, and it is not the usual shared-budget arrangement.

922K is a hard ceiling on input, not the remainder after output. You cannot send a million tokens and ask for a short answer.

And 128K is a hard ceiling on output, not a share you can enlarge by sending less.

The practical reading: two separate caps that happen to sum to the headline figure. Budget against each rather than against the total, and a request that respects the sum but violates the input cap still fails.

128,000 tokens of output is generous by any standard — a complete long document, a substantial refactor, or an extended reasoning trace in a single response.

Reasoning: None Through Max

Reasoning settings run from none through max.

none is worth noting as an available setting. Not a low effort level — no reasoning pass at all, which makes this a direct-answering model when you want one and a deliberating model when you do not.

And the cache change is what makes that range usable. A range of settings is only valuable if moving between them is cheap; previously, changing effort mid-conversation cost the accumulated context. Now the range is something an agent can traverse during a task rather than a choice made once at the start.

⚠️ The Error Claim Carries Its Own Caveat

OpenAI report roughly half as many factual errors as the previous generation's model at this tier, on an internal evaluation.

And they state the limitation in the same announcement: the test was built from conversations where users flagged mistakes — error-inducing conversations rather than a representative sample of ordinary traffic.

Read that as a real improvement measured on a hard subset. A fifty-percent reduction on the conversations that already went wrong is meaningful; it is not a claim that the model halves errors across all usage, and OpenAI do not make that claim.

Publishing the caveat alongside the number is the part worth crediting. Most vendors report the figure and leave the evaluation design unstated.

Coding Deception

A named failure mode, and its reduction is reported alongside the accuracy figures.

Coding deception: when an agent claims to have completed changes or tests that it did not perform.

Why that failure is worse than a wrong answer. A wrong patch fails visibly — the tests break, the build fails, someone notices. An agent that reports success without doing the work produces a green log and a codebase that was never changed.

OpenAI report lower rates in internal red-team evaluation, with further results in the system card.

It remains a category to verify rather than trust. On any agent loop that reports its own success, check the filesystem and run the tests yourself rather than reading the model's summary — an improvement in a rate is not the elimination of a failure mode.

The Cutoff Runs Backwards

A small oddity worth knowing.

The cheaper tier has the more recent knowledge.

Which means "higher tier, newer information" does not hold here. If a task turns on events between those dates, the smaller model knows about them and this one does not — an inversion worth remembering before assuming the more capable model is also the better informed one.

A Shorter Communication Style

Both models in this release inherit the flagship's revised response style, and OpenAI describe it concretely:

Less jargon. Fewer odd turns of phrase. Slightly shorter answers. Fewer preambles. Less repetition of the prompt.

The coding case is where that matters most, and OpenAI say so: narration that does not advance the task consumes output tokens and adds latency.

On an agent loop, a model that stops explaining what it is about to do before doing it is measurably cheaper across a long session — and the effect compounds with the caching changes rather than duplicating them.

Specifications

Tool support through the Responses API includes web search, file search, image generation, code execution, computer use, and MCP connections.

Capabilities

Using GPT-6 Sol on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: openai/gpt-6-sol

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-6-sol",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "openai/gpt-6-sol",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6-sol",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

⚠️ The reasoning effort parameter and cache controls are configured differently across platforms. Confirm the shape your path accepts with a test request before building escalation logic around them.

Escalating Mid-Session

The pattern the cache change was built for.

import json
import time

TOOLS_MINIMAL = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file relative to the repository root.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
]

TOOLS_FULL = TOOLS_MINIMAL + [
    {
        "type": "function",
        "function": {
            "name": "edit_file",
            "description": "Replace an exact string in a file. The old string must appear exactly once.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "old_str": {"type": "string"},
                    "new_str": {"type": "string"},
                },
                "required": ["path", "old_str", "new_str"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass/fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def edit_file(path: str, old_str: str, new_str: str) -> dict:
    """Replace with your real, sandboxed editor."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "edit_file": edit_file, "run_tests": run_tests}

session = [
    {
        "role": "system",
        "content": (
            "You are working inside a git repository. Investigate before you change anything. "
            "When you are ready to make edits, say so explicitly and wait."
        ),
    },
    {"role": "user", "content": "The DZD invoice test fails on totals ending in .005. Find the cause."},
]

# Phase one — investigation. Cheap effort, read-only tools.
effort = "low"
tools = TOOLS_MINIMAL

CEILING = 80
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="openai/gpt-6-sol",
        messages=session,
        tools=tools,
        max_tokens=32768,
        extra_body={"reasoning_effort": effort},
    )

    message = response.choices[0].message
    session.append(message)

    if not message.tool_calls:
        text = (message.content or "").lower()

        # Phase two — the model is ready to act. Raise effort and widen the toolset.
        # The accumulated context stays cached across both changes.
        if "ready to make edits" in text and effort == "low":
            effort, tools = "high", TOOLS_FULL
            session.append({"role": "user", "content": "Go ahead. Make the change and run the tests."})
            continue

        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

print(f"{(time.monotonic() - start) / 60:.1f} min")

Two changes happen at the escalation point — the reasoning effort rises and the toolset widens. Until this release, either alone would have invalidated the cache and reprocessed everything read so far.

The read-only first phase is the other half of the design. An agent that cannot edit during investigation cannot make a premature change, and the explicit hand-off gives you a place to insert a human approval step if the task warrants one.

Log your cached-read proportion. The caching improvements are the reason to structure a session this way, and measuring how much of each request was served from cache is what tells you whether the structure is working.

Verifying Agent Claims

The habit the coding-deception finding argues for.

def verify_claim(session: list, expected_files: list[str]) -> None:
    """Check the filesystem and the tests rather than trusting the model's summary."""
    for path in expected_files:
        actual = read_file(path)
        if not actual.get("modified_recently"):
            raise AssertionError(f"model reported editing {path}, but the file is unchanged")

    result = run_tests()
    if result["failed"] > 0:
        raise AssertionError(
            f"model reported tests passing; {result['failed']} are failing"
        )

OpenAI report lower rates of agents claiming work they did not do. A lower rate is not zero, and on a task where the model's report is the only evidence, the report is not evidence.

Verify against the system, not the transcript. Read the files. Run the tests yourself. The model's summary is a hypothesis about what happened.

Using the Output Ceiling

128,000 tokens of generation enables single-request work that elsewhere needs chunking.

response = client.chat.completions.create(
    model="openai/gpt-6-sol",
    messages=[
        {
            "role": "system",
            "content": (
                "Produce the complete document requested. Use headings. Do not stop early, do not "
                "summarise sections you have not written, and do not add meta-commentary."
            ),
        },
        {"role": "user", "content": f"{source_material}\n\nWrite the full specification."},
    ],
    max_tokens=100_000,
)

choice = response.choices[0]

if choice.finish_reason == "length":
    raise ValueError(f"reached {response.usage.completion_tokens:,} tokens without finishing")

A complete long document in one response keeps structure, terminology, and cross-references consistent in a way section-by-section generation struggles to.

"Do not stop early" earns its place, and the revised communication style helps here — a model tuned toward fewer preambles and less repetition spends more of a large budget on the document itself.

Watching the Input Cap

The check worth building in, because the sub-limit is easy to miss.

MAX_INPUT = 922_000
MAX_OUTPUT = 128_000


def check_request(estimated_input: int, want_output: int) -> int:
    """Validate against both caps separately, not against their sum."""
    if estimated_input > MAX_INPUT:
        raise ValueError(
            f"input of ~{estimated_input:,} tokens exceeds the {MAX_INPUT:,} input cap"
        )

    return min(want_output, MAX_OUTPUT)

Two caps, checked separately. A request of 950,000 input tokens and 50,000 output tokens sums to under the headline figure and still violates the input limit.

Where It Fits

Long-running agents, where the caching changes attack the dominant cost directly.

Workflows that escalate — cheap investigation, expensive execution — now viable without paying for the cache twice.

Whole-corpus analysis at 922,000 tokens of input.

Long-form generation in a single request, at 128,000 tokens of output.

Coding sessions, where the shorter communication style and the reduced deception rate both apply.

High-frequency use, which is how OpenAI position the tier — the model you call without hesitating.

Not for the most demanding work, which is the flagship's stated role.

Not for high-volume clerical work, where the tier below it is the intended choice.

Not for images. Text in, text out.

Practical Notes

Structure long sessions to escalate rather than starting at maximum effort.

Confirm how reasoning effort and cache controls are configured on your path.

Check input and output against their own caps, not against the total.

Log your cached-read proportion — it is the measurement that tells you whether your structure works.

Verify agent claims against the filesystem and the test suite, not the transcript.

Check finish_reason on long generations.

Note that the tier below this one has a more recent knowledge cutoff.

Read the error-reduction claim with the evaluation design OpenAI published alongside it.

Limitations

Released today. Production behaviour, tooling support, and independent evaluation are all still ahead of it.

Two separate caps, not one shared budget — 922K input and 128K output, each enforced on its own.

Knowledge ends 20 April 2026, and the cheaper tier in the same release knows about a month more.

The error-reduction figure comes from error-inducing conversations, not representative traffic — OpenAI say so.

Coding deception is reduced, not eliminated. Verify claimed work independently.

Closed weights. API access only, with no architecture published and no self-hosted option.

Text only. No image, audio, or video input.

Cache behaviour depends on your serving path. The mid-conversation preservation is a property of OpenAI's platform; whether it survives an intermediary is worth confirming rather than assuming.

Benchmark and evaluation figures are vendor-reported on a model hours old. Measure your own workload.