GPT-5.5 Review After Seven Weeks: Where It Beats Claude and Where It Doesn't

TL;DR

GPT-5.5 is OpenAI’s best coding model and the first one that genuinely works as an autonomous agent. It leads Terminal-Bench 2.0 at 82.7%, uses 72% fewer tokens than Claude Opus on identical tasks, and its 1M-token context window is usable for retrieval. But it loses SWE-Bench Pro to Opus 4.7 (58.6% vs 64.3%), struggles with multi-file refactors that need sustained context, and the $30 per million output tokens adds up fast once you run it in agentic loops. After seven weeks of daily use, I reach for GPT-5.5 when I need a terminal agent that chains tool calls across hundreds of steps — and I reach for Claude when the task requires reading a real codebase and making careful changes.

I Switched My Agent Pipeline to GPT-5.5 for Seven Weeks

When OpenAI shipped GPT-5.5 on April 23, I moved my agentic coding pipeline from Claude Opus 4.7 to the new model. I wanted to test the claim OpenAI made during the launch demo: that GPT-5.5 could run over a thousand tool calls in a single session without human intervention. My setup was a Python monorepo with about 140K lines across 300 files, a Go microservice layer, and a CI pipeline that runs ~900 tests. I used GPT-5.5 through the API in a custom harness and through Codex CLI for interactive terminal work.

Seven weeks later, I have a clear picture. GPT-5.5 is a different animal from GPT-5.4. It’s a terminal agent that happens to understand code, and the entire model design follows from that.

What GPT-5.5 Actually Is

OpenAI’s framing in the launch post was unusually direct: GPT-5.5 is an agentic model first, a chat model second. The design decisions follow from that:

• 1M-token context window (922K input, 128K output), the largest OpenAI has shipped
• Native multi-step tool use with self-checking before submission
• Two variants: standard GPT-5.5 (with reasoning effort levels from low to xhigh) and GPT-5.5 Pro for harder long-horizon tasks
• Long-context reasoning jumped from 36.6% on GPT-5.4 to 74.0%, a 2x improvement
• Hallucination rate reportedly dropped 60% compared to GPT-5.4 (OpenAI’s system card shows a more modest 23% factual accuracy improvement)

The model rolled out to ChatGPT Plus, Pro, Business, and Enterprise on the same day, with API access the next morning. AWS Bedrock integration followed within the month, alongside MCP support in Codex CLI.

Worth noting: the widely reported “60% hallucination drop” compared to GPT-5.4 doesn’t appear in OpenAI’s system card. OpenAI’s published metrics say 23% more likely to be factually correct and 3% fewer factual errors per response, which is solid but more modest than the 60% figure circulating in coverage.

Benchmarks: What the Numbers Say and What They Hide

The headline numbers are strong. But after running GPT-5.5 daily for seven weeks, I’ve learned that benchmark scores tell you the ceiling, not the floor.

The SWE-Bench split tells the real story. On SWE-Bench Verified (single-shot bug fixes) GPT-5.5 edges out at 88.7% vs 87.6%. On SWE-Bench Pro, the harder multi-step issues that need planning across files, Opus 4.7 pulls ahead at 64.3% vs 58.6%. The same pattern showed up in my own work: GPT-5.5 fixed isolated bugs faster, but Claude produced cleaner diffs when a fix required touching five files with interconnected changes.

A caveat about these numbers. Three different scores all claim to be “the best SWE-Bench Pro result”: 80.3% (Claude Fable 5 on Anthropic’s scaffold), 59.1% (GPT-5.4 xHigh on Scale’s standardized SEAL leaderboard), and 47.1% (Opus 4.6 on Scale’s private commercial set). The spread comes from scaffolding and data splits. I’m comparing numbers from the same evaluation setup where possible.

Where GPT-5.5 Wins: Terminal-Native Agent Work

GPT-5.5 was built for one thing and it does it well: long-running tool-use chains in a terminal. Codex CLI is the natural home for it. In my workflow, I’d point it at a directory, describe a task, and let it work through shell commands, file edits, and test runs on its own.

A real example from week three: I asked it to add OpenTelemetry tracing to a Go HTTP server with 14 endpoints. It read the existing handler files, added span creation and attribute logging to each endpoint, updated the go.mod to pull in go.opentelemetry.io/otel, wrote a tracing.go init function, and ran the test suite. All in one uninterrupted session of 47 tool calls. It caught a missing context propagation in a middleware and fixed it before I noticed.

In Codex CLI, the workflow looks like this:

codex --model gpt-5.5 --approval auto-edit

Then you describe the task in natural language. The agent reads files, runs commands, edits code, and executes tests, asking for approval only on destructive operations by default. MCP support means it can talk to external databases, internal APIs, and vector stores through the same protocol Claude Code uses.

The token efficiency was the biggest surprise. On the same coding tasks (identical prompts, same goals) GPT-5.5 produced about 72% fewer output tokens than Claude Opus 4.7. It skips the narrative commentary between steps. Where Claude writes “I’ll now update the configuration file to include the new middleware…” before editing, GPT-5.5 just edits. Over a 200-step agentic session, that difference saves $15-20 in output tokens.

Where GPT-5.5 Falls Short

Multi-File Architecture Work

Hand GPT-5.5 a task that requires reading four files to understand a data flow, then modifying three of them coherently, and it’ll often produce changes that work in isolation but break at the seams. I hit this repeatedly when refactoring our authentication middleware. Claude would read all the files, build a mental model of the call chain, and produce a diff that held together. GPT-5.5 would fix each file correctly in isolation, then miss that the type signature changed upstream.

Instruction Following Under Load

Several users, myself included, have noticed GPT-5.5 going off-script during long sessions. Around the 80-100 tool call mark, the model sometimes ignores the original plan and follows its own interpretation of what should happen next. I had a session where it started re-implementing a feature I’d explicitly told it to leave alone. Interrupting mid-stream doesn’t always help. The model can be sticky about its current direction.

Silent Model Swaps

The most frustrating issue: OpenAI sometimes serves a lighter variant (GPT-5.5 Instant or a mini model) while the UI still says “GPT-5.5 Extended Thinking.” Multiple users on Reddit and the OpenAI developer forum have documented this behavior. It’s not consistent enough to reproduce on demand, but when it happens, the quality drop is obvious. OpenAI hasn’t acknowledged it publicly.

Novel Reasoning

GPT-5.5 handles familiar patterns well. A standard CRUD endpoint, a known algorithm implementation, a common refactoring pattern: it’ll produce clean code fast. But give it a genuinely unusual problem (a custom distributed lock mechanism, an optimization for a niche data structure) and it falls back to templated approaches that miss the specific constraint. Frontier models in general still struggle here, but GPT-5.5’s weakness is more noticeable because OpenAI’s marketing leans so heavily on reasoning.

Pricing: What a Real Month Costs

The headline rate is $5 per 1M input tokens, $30 per 1M output tokens. But the real cost depends on how you use it.

For comparison: Claude Opus 4.7 runs $5 per 1M input and $25 per 1M output, $5 cheaper on output tokens. At first glance the gap looks small. In practice, it compounds.

I tracked my spending across three weeks of mixed use (daily agentic sessions of 30-120 minutes plus ad hoc queries). API cost: roughly $340/month on GPT-5.5 for tasks that cost me about $280/month on Opus 4.7. The 72% token efficiency partially offsets the higher output price, but “partially” is the key word: shorter outputs at $30/M still cost more than longer outputs at $25/M in many real sessions.

GPT-5.5 Pro at $30/$180 is a different calculation. I used it for a handful of hard debugging sessions where the standard model was going in circles. It solved two problems the standard model couldn’t. But at 6x the cost, it’s a precision tool. Don’t leave it running in an agentic loop.

If you’re using ChatGPT Plus ($20/month) or Pro ($200/month), GPT-5.5 is included. The rate limits on Plus are tight for serious agentic work, though. Pro subscribers get enough headroom for most workflows.

The 1M Context Window: Useful, With Limits

GPT-5.5 is the first OpenAI model where the 1M-token context window is genuinely usable. I loaded our entire Python monorepo (~140K lines, roughly 500K tokens) and asked it questions about cross-module dependencies. It found a circular import that our existing tooling had missed, buried in an indirect chain spanning four packages.

For retrieval (“find me every place this function is called” or “which modules depend on this config key”) the full context window works well up to about 700K tokens. Past that, I noticed occasional misses where it would report “no other callers” when grep showed two more.

For complex reasoning over the full window (“refactor this data flow across these six modules”) quality degrades noticeably past 200K tokens. The model still produces code, but the coherence across distant parts of the context drops. This matches what I’ve seen with other 1M-context models including Claude and Gemini. The context window is there, but the attention budget spreads thin at the edges.

The long-context pricing premium ($10/$45 past 272K input) also shapes how I use it. For most sessions, I load the relevant files (typically 30-80K tokens) rather than the whole repo. The full context load is worth it for exploratory questions about unfamiliar codebases, but not for routine work where you already know which files to touch.

GPT-5.5 vs Claude Opus: The Honest Split

After seven weeks switching between both models, the split is clear:

GPT-5.5 when:

• The task is a terminal workflow: run commands, check output, iterate. GPT-5.5’s tool-use fluency and token efficiency make it the better agent here.
• I need to process a massive context for retrieval. Dump 500K tokens and ask pointed questions.
• Speed over care. Quick bug fixes, boilerplate generation, test scaffolding.
• The Codex CLI or Codex web IDE is the right tool for the job.

Claude Opus when:

• The task requires sustained coherence across multiple files. Code review, architectural refactors, anything where the diff needs to be internally consistent.
• Instruction following is non-negotiable. Claude sticks to the plan more reliably over long sessions.
• I’m writing or reviewing technical documentation alongside code.
• The task is genuinely novel: custom algorithms, unusual constraints, problems without obvious templates.

GPT-5.5 leads on agentic tool use and long-context retrieval; Claude leads on careful multi-file edits and instruction fidelity. The benchmark split (GPT-5.5 wins Terminal-Bench, Opus wins SWE-Bench Pro) maps directly to this real-world split.

For teams choosing between them: if your workflow is primarily Codex CLI / terminal-driven agentic tasks, GPT-5.5 is the better default. If your workflow involves code review, refactoring, and PR-quality diffs, Claude is still ahead. For the budget tier of this comparison, see Gemini Flash vs Claude Haiku vs MAI-Code-1-Flash.

Codex CLI Integration

The best way to use GPT-5.5 for coding is through Codex CLI. If you’re comparing it against Claude Code, I covered that matchup in Claude Code vs Codex CLI. The integration has matured since launch:

codex --model gpt-5.5 \
  --approval auto-edit \
  --mcp-server ./mcp-config.json

Key features that make the agentic workflow practical:

• Three approval modes: suggest (read-only), auto-edit (edits without asking, asks before commands), and full-auto (runs everything, use with caution)
• MCP support: same protocol as Claude Code, so existing MCP servers work
• Installable skills modules that extend Codex without custom tooling
• Piping support: echo "add retry logic to the HTTP client" | codex for scripted workflows

The MCP integration deserves a specific mention. If you’ve built MCP servers for Claude Code, they work in Codex CLI without changes. I pointed Codex at my existing PostgreSQL MCP server and it queried the database to verify schema changes it was making in migration files, with zero changes on the MCP side.

FAQ

Is GPT-5.5 good for coding?

Yes, with caveats. It’s the best model available for terminal-driven agentic coding — scripts, CLI automation, test runs, and long tool-use chains. For careful multi-file refactors and code review, Claude Opus 4.7 still produces cleaner diffs. Pick based on what kind of coding you’re doing.

How does GPT-5.5 compare to Claude Opus 4.7?

On 10 shared benchmarks, Opus leads on 6 (reasoning-heavy tasks) and GPT-5.5 leads on 4 (tool-use and terminal tasks). GPT-5.5 uses 72% fewer tokens for the same work. Opus costs $5 less per million output tokens. In practice, GPT-5.5 wins on speed and efficiency, Claude wins on coherence and instruction following.

What is GPT-5.5 pricing?

$5 per 1M input tokens, $30 per 1M output tokens for the standard model. GPT-5.5 Pro runs $30/$180 for harder tasks. Cached input drops to $0.50/M. Long-context use above 272K input tokens bumps to $10/$45 per 1M. ChatGPT Plus ($20/month) and Pro ($200/month) include GPT-5.5 with rate limits.

What changed from GPT-5.4 to GPT-5.5?

Long-context reasoning doubled (36.6% → 74.0%), Terminal-Bench score jumped from ~70% to 82.7%, and the model shifted from a general-purpose chat model to an agentic-first design. The 1M context window existed in GPT-5.4 technically, but GPT-5.5 is the first model where long-context reasoning actually works well enough to use it.

Is GPT-5.5 worth it for agentic workflows?

If you’re running multi-step terminal agents — yes, it’s the current best option. The token efficiency alone saves $15-20 per long session compared to Opus. But watch the output pricing at scale: $30/M adds up in loops that generate thousands of steps. For teams running heavy agentic workloads, the GPT-5.5 Pro tier ($180/M output) should only be used for the hardest problems.

Sources

• GPT-5.5 launch announcement — official GPT-5.5 release details from OpenAI
• OpenAI API pricing — current pricing tiers for GPT-5.5, GPT-5.5 Pro, and long-context
• GPT-5.5 benchmarks — BenchLM — standardized benchmark scores across SWE-Bench, Terminal-Bench, MMLU, GPQA
• SWE-Bench Pro leaderboard — Scale — independent benchmark from Scale AI with standardized scaffolding
• GPT-5.5 real-world coding comparison — MindStudio — independent testing of GPT-5.5 vs Opus 4.7 on coding tasks
• User reports of model degradation — coverage of silent GPT-5.5 downgrade reports

Bottom Line

GPT-5.5 is the model OpenAI should have shipped instead of GPT-5.4. The agentic-first design works. Terminal-Bench 2.0 at 82.7% reflects real improvements in tool use and multi-step execution. The token efficiency — 72% fewer output tokens than Opus on the same work — makes it the cheapest frontier model to run in agent loops, despite the higher per-token price.

But it’s not the universal best coding model. SWE-Bench Pro, multi-file coherence, and instruction fidelity over long sessions all still go to Claude Opus 4.7. And the silent model-swap reports are a trust problem that OpenAI needs to address.

My recommendation: use GPT-5.5 as your terminal agent and Claude as your code reviewer. In practice, they complement each other better than they compete.