GPT-5.5 is here: smarter and cheaper

OpenAI released GPT-5.5 today, internally codenamed “Spud.” Only a week after Anthropic dropped its latest model—this pace is classic OpenAI: you make a move, I follow up, but with a higher bid.

Co-founder Greg Brockman gave it a rather high-profile description: “A whole new kind of intelligence.” We’ve heard similar statements in past releases, but this time, judging from benchmark scores and real-world feedback, it really seems different.

Core change: not better at chatting—better at doing work

Let’s start with the most important point—GPT-5.5 doesn’t focus on improving conversational quality, but on its Agent capabilities.

What does that mean? Previously, when you used GPT for work, you were basically acting as a project manager: breaking tasks down, writing clear prompts, and feeding them step by step. GPT-5.5 aims to change that interaction model. You can now throw at it a fuzzy, unstructured, multi-step requirement, and the model will plan and execute on its own—calling tools, checking intermediate results, and progressing to a usable outcome.

In Brockman’s words: “Less guidance, more output.”

And this isn’t just hype. Early tester feedback shows visible improvements from GPT-5.5 in several areas:

• Significantly improved understanding of system architecture; no need to manually feed in the full codebase context
• Higher accuracy in fault localization, with proactive correlation across up- and downstream dependencies
• In code review scenarios, it can anticipate potential reviewer comments

One developer shared a vivid impression: “5.4 is more like a perfectionist logic master, while 5.5 feels like a pragmatist—do first, then test.” That’s an apt comparison. GPT-5.5 tends toward a “produce-first, iterate-later” style—writing more test cases, reading context more aggressively, and reducing those “sounds professional but says nothing” outputs.

Benchmark scores: competitive where it counts

In numbers, GPT-5.5’s report card looks solid:

• Terminal-Bench 2.0: 82.7% accuracy
• SWE-Bench Pro (real GitHub issue-solving): 58.6%
• Expert-SWE and other long-horizon tasks: surpasses GPT-5.4 across the board
• Artificial Analysis Coding Index: reaches SOTA performance at half the competitor cost
• GeneBench (genomics) and BixBench (bioinformatics): both lead benchmarks

That 58.6% on SWE-Bench Pro deserves emphasis. This benchmark tests how models resolve actual GitHub issues—not carefully crafted exam questions, but real-world bugs with fuzzy descriptions and complex contexts. Scoring close to 60% suggests GPT-5.5’s code understanding and fixing abilities have hit a practical threshold.

There’s also a noteworthy breakthrough in scientific research. OpenAI says GPT-5.5 assisted in discovering a new proof related to Ramsey numbers. If that rings a bell—it’s the same line of work where GPT-5.2 Pro solved an Erdős conjecture last year, which Terence Tao himself acknowledged. GPT-5.5 has now pushed that line further.

The real killer feature: cost

It’s not news that newer models are stronger—that happens every generation. What makes this release truly interesting is the shift in cost structure.

GPT-5.5’s API input pricing is $5 per million tokens—about the same as Google Gemini 2.5’s base subscription. But the crucial part comes from NVIDIA: with its new chips, running models like GPT-5.5 now costs 1/35 of what it used to per token.

That’s one thirty-fifth, not one third.

What does that drop mean? Example: suppose an Agent workflow with GPT-5.4 for a complex code review consumed 100k tokens (~$1 cost). Running the same task on GPT-5.5 uses fewer tokens (OpenAI specified “fewer tokens to complete the same task”) and benefits from cheaper infrastructure—total cost could fall to mere cents.

For individual developers, that’s savings; for enterprises, it’s a strategic shift. Many companies held back from large-model adoption because token costs scaled exponentially with usage—IT budgets just couldn’t handle it. Now that economic model has been rewritten.

NVIDIA VP of Enterprise Computing Justin Boitano put it plainly: GPT-5.5 can serve as a “chief of staff” for enterprise AI agents already in production. NVIDIA and OpenAI even co-developed a deployment blueprint to speed up integration.

Speed: not slower

This deserves separate mention, because the usual rule was “stronger = slower.” GPT-5.5 breaks that pattern—despite being larger and more powerful, its per-token latency matches GPT-5.4’s.

How? OpenAI hasn’t disclosed details, but based on the System Card and discussions, GPT-5.5 likely underwent full pretraining rather than incremental fine-tuning over 5.4 (the consensus in the community is yes). That implies architectural adjustments, not just data or training tweaks.

For developers, “not slower” may matter more than “stronger,” since latency directly impacts user experience and system throughput. A model that’s both powerful and fast is the one that actually scales to production.

Real-world use: OpenAI eats its own dog food

OpenAI shared internal stats: over 85% of employees use Codex (based on GPT-5.5) weekly, and its finance team audited more than 70,000 pages of tax documents using it.

Seventy thousand pages of tax files—that’s not a demo or benchmark; that’s true production use. Financial audits demand near-zero error tolerance. The fact that OpenAI trusts its own tax files to the model sends a strong signal.

External partners echo this. NVIDIA said GPT-5.5 reduced debugging time “from days to hours.” With 30,000 engineers, NVIDIA has already run multi-week tests and plans a company-wide rollout. When a world-class engineering firm deploys it fully, it’s clearly more than marketing.

Early-access users also shared specific scenarios:

• Verifying emotionally nuanced creative work (e.g., marketing copy tone)
• Reviewing thousands of additional documents in bulk
• Saving up to 10 hours of work time per week

A notable usage tip

Developers noticed something interesting: when you want GPT-5.5 to write documentation or do deep analysis, include “think deeply about this problem” in your prompt. Otherwise—even at max reasoning level (xhigh)—the model often prioritizes speed over depth.

That reflects GPT-5.5’s design philosophy: default to efficient execution, not deep reasoning. For most Agent workflows, that’s correct—you don’t want every step to take ages. But if your use case requires deep reasoning, you must explicitly ask for it.

Remember this trick—it may save you hours of debugging.

Rollout pace and API access

Starting today, GPT-5.5 is available for Plus and Pro users in ChatGPT and Codex. The API version is “coming soon,” pending additional network security measures.

API pricing:

| Type | Price (per million tokens) | |------|-----------------------------| | Input | $5 | | Output | TBA (likely around GPT-5’s $10) |

For developers already using the OpenAI API, integrating GPT-5.5 is mostly a matter of changing the model parameter. If you call via aggregation platforms like OpenAI Hub, switching will be even easier—typically ready right after launch, just a key away.

Example: calling GPT-5.5 through an OpenAI-compatible API:

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.openai-hub.com/v1"  # OpenAI Hub aggregation endpoint, direct in China
)

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "system",
            "content": "You are a senior software engineer skilled in code review and architecture analysis. Think deeply about this problem."
        },
        {
            "role": "user",
            "content": "Analyze this Python project’s dependencies, identify potential circular references, and give refactoring advice."
        }
    ],
    temperature=0.3,
    max_tokens=4096
)

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

Note the “think deeply about this problem” in the system prompt—that community insight also applies to API usage.

For running Agent workflows, you can leverage GPT-5.5’s tool-calling capability:

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": "Check GitHub issues from the past 3 days, classify which are bugs and which are feature requests, prioritize them, and generate a weekly report."
        }
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "search_github_issues",
                "description": "Search GitHub repository issues",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "repo": {"type": "string", "description": "Repository name"},
                        "since": {"type": "string", "description": "Start date, ISO format"},
                        "state": {"type": "string", "enum": ["open", "closed", "all"]}
                    },
                    "required": ["repo"]
                }
            }
        }
    ],
    tool_choice="auto"
)

This ability—to throw a vague task and have the model autonomously break it down and execute—is the core of GPT-5.5’s Agent capabilities.

Competitive landscape: the price war begins

Placed in an industry context, GPT-5.5 sends several signals.

First, the timing: only a week after Anthropic’s release. Internally, OpenAI has described Anthropic’s rapid ascent as a “red alert” or “wake-up call,” so this fast follow-up seems deliberate.

Second, pricing: $5 per million input tokens directly matches Gemini 2.5 instead of following the premium-pricing approach. Combined with NVIDIA’s 35× cost compression, OpenAI is clearly signaling: the large-model price war is officially on.

Third, enterprise orientation: Brockman introduced the concept of a “compute-driven economy,” but stripped of rhetoric, OpenAI’s strategic focus is shifting from consumer (C-side) to enterprise (B-side). GPT-5.5’s Agent capabilities, its NVIDIA deployment blueprint, and its “chief of staff” positioning all point in one direction—AI as infrastructure, not as entertainment.

For developers, that means demand for model-based Agents and workflow integration is about to explode. The capability is here, cost is down, enterprises are ready to pay—the only bottleneck is who can productize it effectively.

A few sober notes

Of course, not everything is perfect.

First, the API isn’t live yet. OpenAI said security measures are being finalized but gave no timeline. “Coming soon” might mean days—or weeks—for those waiting to integrate.

Second, some in the community noted GPT-5.5 still struggles with certain logic problems. One developer used a combinatorics question (drawing candies from a bag) and found large fluctuations in reasoning quality. So its progress in pure mathematical reasoning may not match its advancements in code or Agent tasks.

Lastly, the “default run-fast” design cuts both ways. In deep-analysis scenarios, if you don’t explicitly enable a deep-thinking mode, you might get a polished but shallow answer. This trade-off in interaction design is something OpenAI ought to refine further.

Final thoughts

GPT-5.5 isn’t a “better conversationalist”—it’s a “better worker.” That shift in positioning may matter more than any benchmark number.

When a model evolves from “a chat tool” to “an execution engine,” when token costs drop to enterprise-operable levels, and when NVIDIA and OpenAI jointly publish a deployment blueprint—we’re witnessing not just another model iteration, but the tipping point where AI transitions from usable, to useful, to indispensable.

For developers, now’s the time to seriously study Agent workflows. Model power is no longer the bottleneck, nor is cost. The bottleneck is whether you can identify which parts of your workflow are ready for “a pragmatic AI coworker.”

---

References:

• ITHome: OpenAI’s Smartest Model GPT-5.5 Launches — detailed specs, benchmarks, and pricing
• Linux.do: GPT-5.5 Release Recap — discussions on codename Spud and pretraining
• Linux.do: Personal Testing Notes on GPT-5.5 — developer feedback and usage tips