OpenAI dropped GPT-5.5, codenamed "Spud," on April 23, 2026, and it's the first fully retrained base model we've seen since GPT-4.5. This isn't just another incremental update. The company built this model from the ground up with a specific mission: handling complex, multi-step tasks that require using tools and thinking through workflows like a human would. If you've been following the evolution of large language models, you know that each generation brings something new to the table. GPT-5.5 focuses less on being a better chatbot and more on being a reliable agent that can actually get work done. The benchmark numbers tell part of the story - an 82.7% score on Terminal-Bench 2.0 - but what really matters is what changed under the hood to make that happen.
Built for Agentic Tasks, Not Just Chat
OpenAI made a deliberate choice with GPT-5.5. Instead of chasing higher scores on traditional language benchmarks or trying to sound more human in casual conversation, they optimized for what they call "agentic tasks." That means multi-step workflows where the model needs to use external tools, maintain context across several operations, and make decisions about what to do next without constant hand-holding.
Think about the difference between asking a model to write an email versus asking it to research a topic across multiple sources, synthesize the findings, draft a report, and then format it for presentation. The second task requires planning, tool use, and the ability to course-correct when something doesn't work. That's what GPT-5.5 was designed to handle. The Terminal-Bench 2.0 score of 82.7% reflects performance on exactly these kinds of complex, real-world scenarios that earlier models struggled with.
This focus on agency shows up in how the model handles errors and uncertainty. Rather than confidently hallucinating when it hits a knowledge gap, GPT-5.5 is more likely to acknowledge what it doesn't know and suggest next steps. It's less impressive in a demo when the model admits limitations, but it's far more useful when you're depending on it to complete actual work. The training process involved exposing the model to thousands of multi-step tasks that required using APIs, databases, and other tools - essentially teaching it to think like a software agent rather than just a text generator.
API Access Delayed for Safety Reasons
Here's something unusual: OpenAI released GPT-5.5 to ChatGPT users on April 23, 2026, but held back API access until the following day. The one-day delay might not sound significant, but it signals something important about how this model differs from its predecessors. According to OpenAI, the delay was necessary to implement different safeguards tailored to GPT-5.5's capabilities.
When a model can autonomously execute multi-step workflows and use tools, the safety considerations change. A chatbot that writes text poses one set of risks. An agent that can browse the web, run code, access databases, and chain together operations poses another entirely. The safeguards needed for GPT-5.5 go beyond content filtering and bias mitigation. They have to account for what happens when the model makes decisions about which tools to use, how to interpret their results, and what actions to take based on that interpretation.
The delay also suggests OpenAI learned from previous launches. Rolling out API access to thousands of developers simultaneously means unpredictable usage patterns and edge cases that testing can't always catch. Starting with the controlled environment of ChatGPT, where OpenAI can monitor behavior and implement quick fixes, makes sense when you're deploying a model with genuine agentic capabilities. Developers got access on April 24, 2026, but that extra day gave OpenAI breathing room to ensure the safety measures were working as intended in production.
What "Fully Retrained" Actually Means
OpenAI emphasized that GPT-5.5 is the first fully retrained base model since GPT-4.5. That distinction matters more than it might seem. Many model updates involve fine-tuning, instruction following improvements, or adding capabilities on top of an existing base. A full retraining means going back to square one with the foundational model architecture and training process.
Retraining from scratch is expensive and time-consuming. It requires massive computational resources and months of work. OpenAI wouldn't do it unless they believed the incremental approach had hit diminishing returns for their goals. By starting fresh, they could optimize the entire training process for agentic behavior rather than trying to bolt it onto a model originally designed for different purposes.
The base model determines everything else. It's the foundation that all subsequent fine-tuning and specialization builds on. Think of it like the difference between renovating a house and building one from the ground up. Sometimes renovation works fine. But if you want fundamentally different structural characteristics, you need to start with a new foundation. GPT-5.5's focus on tool use, multi-step reasoning, and workflow execution apparently required those fundamental structural changes that only a full retraining could provide.
This also explains why we're seeing GPT-5.5 instead of GPT-5.0. The numbering suggests this isn't just the next generation in the main line - it's a specialized branch optimized for specific use cases. The .5 increment indicates it's building on GPT-5 architecture but trained with different priorities and objectives. That training process involved new datasets, different optimization targets, and evaluation metrics focused on real-world task completion rather than just natural language processing benchmarks.
Terminal-Bench 2.0 and What It Measures
GPT-5.5 scored 82.7% on Terminal-Bench 2.0, but what does that benchmark actually test? Unlike traditional language model evaluations that focus on question answering or text generation quality, Terminal-Bench 2.0 measures performance on tasks that involve command-line operations, API calls, file manipulation, and multi-step problem solving in a simulated terminal environment.
The benchmark presents scenarios where the model needs to diagnose problems, plan solutions, execute commands, interpret results, and adapt based on what happens. It's designed to mirror real developer workflows and system administration tasks. An 82.7% score means the model successfully completed about four out of every five complex terminal-based tasks without human intervention.
Context matters here. Earlier models might score well on coding benchmarks by generating syntactically correct code, but struggle when that code needs to be executed, debugged, and integrated into a larger workflow. Terminal-Bench 2.0 tests the whole cycle. The model doesn't just write a script - it has to run it, interpret error messages, fix problems, verify the output, and confirm the task is complete. That's a much harder bar to clear, which makes the 82.7% score more impressive than the number alone suggests.
Conclusion
GPT-5.5 represents a shift in how OpenAI thinks about model capabilities. Rather than pursuing general-purpose language understanding across all domains, they built a model specifically for complex, tool-using workflows. The full retraining from the base level up, the one-day API delay for additional safeguards, and the strong Terminal-Bench 2.0 performance all point to the same conclusion: this model was designed to be an agent, not just a conversationalist.
We're still early in understanding what that means in practice. The benchmark scores and technical details tell us about capability, but the real test comes from how developers and users deploy GPT-5.5 in production environments. Can it reliably handle the multi-step workflows it was trained for? Do the safety measures prevent misuse without creating too much friction? Those questions will take time to answer fully. What's clear is that OpenAI made specific architectural and training choices to prioritize agentic behavior, and they were willing to invest in a complete retraining to make it happen. Whether that bet pays off depends on how well the model performs when faced with real work rather than benchmarks.
FAQs
Why did OpenAI choose the codename "Spud" for GPT-5.5?
OpenAI hasn't publicly explained the reasoning behind the "Spud" codename. Internal codenames at tech companies often follow themes or inside references that aren't necessarily meaningful externally. Previous OpenAI models have had various internal names that didn't make it into public marketing, so "Spud" might simply be part of an internal naming convention rather than a reference to specific capabilities or characteristics of the model.
Can GPT-5.5 access the internet and run code independently?
The model was trained for tool-using workflows, which means it can work with APIs, execute commands, and interact with external systems when given appropriate access. However, OpenAI controls what tools are actually available in any given deployment. In ChatGPT, the model has access to browsing and code execution within sandboxed environments. API users can configure which tools their implementation of GPT-5.5 can access, with appropriate authentication and permission structures determining what's actually possible in production.
Is GPT-5.5 available for free ChatGPT users?
OpenAI typically reserves its most capable models for paid tiers. While the company hasn't specified every access detail publicly, GPT-5.5 likely follows the pattern of previous flagship models by being available primarily to ChatGPT Plus, Team, and Enterprise subscribers. Free tier users generally get access to older model versions with usage limits, though specific availability can change over time based on OpenAI's deployment strategy.
How does the safety approach differ from GPT-4.5?
The one-day API delay specifically cited the need for different safeguards, suggesting GPT-5.5's agentic capabilities required additional protective measures beyond content filtering. These likely include guardrails around tool use, limits on what operations the model can chain together autonomously, and monitoring systems for detecting potentially harmful multi-step workflows. The safety layer needs to catch not just problematic outputs but problematic sequences of actions across multiple tools.
What happens if GPT-5.5 fails partway through a multi-step task?
The model was trained to handle errors and course-correct, which is part of what Terminal-Bench 2.0 tests. When a command fails or produces unexpected results, GPT-5.5 is designed to interpret error messages, adjust its approach, and try alternative solutions rather than simply stopping. That error recovery capability distinguishes it from earlier models that might generate a complete plan upfront but struggle when execution doesn't go as expected. The 82.7% benchmark score includes these recovery scenarios, not just perfect-path completions.
