OpenAI's GPT-5.5 Hits 82.7% on Terminal-Bench and Rewires Its Agent Platform
OpenAI shipped 30+ API updates in six months: new GPT-5.x models, a production-ready Agents SDK with sandboxing, and OpenAI models on Amazon Bedrock
- New model tier: GPT-5.5 ($5/$30 per 1M tokens) leads a full family including GPT-5.4 mini ($0.75/$4.50) and GPT-5.4 nano ($0.20/$1.25) for cost-sensitive workloads.
- Agents SDK upgraded: Native sandbox execution and a model-native harness now ship out of the box, with support for E2B, Modal, Vercel, and 4 other providers.
- Three agentic primitives: Skills (modular SKILL.md instructions), Hosted Shell (Debian 12 container), and Server-side Compaction (auto-summarizes context) now live in the Responses API.
- OpenAI on AWS: GPT-5.5 and GPT-5.4 land on Amazon Bedrock at OpenAI-matching prices, with IAM, VPC, and AWS commitment spend support.
- New voice models: GPT-Realtime-2 (speech-to-speech with reasoning), GPT-Realtime-Translate, and GPT-Realtime-Whisper replace the deprecated Realtime Beta.
- Assistants API sunset: Hard shutdown date is August 26, 2026; migrate to the Responses API and Conversations API now.
OpenAI just dropped a recap of everything it shipped to the API over the past six months, and the list is longer than most companies' annual roadmaps. Thirty-plus models, features, and tools landed quietly in the changelog while the headlines were elsewhere. Here's what actually matters for anyone building on the platform.
A model family for every budget
The flagship addition is GPT-5.5, OpenAI's most capable model to date. It excels at writing and debugging code, researching online, analyzing data, creating documents and spreadsheets, operating software, and moving across tools until a task is finished. Crucially, GPT-5.5 delivers this step up in intelligence without compromising on speed: larger, more capable models are often slower to serve, but GPT-5.5 matches GPT-5.4 per-token latency in real-world serving.
On benchmarks, the numbers are strong. On Terminal-Bench 2.0, which tests complex command-line workflows requiring planning, iteration, and tool coordination, it achieves a state-of-the-art accuracy of 82.7%. On SWE-Bench Pro, which evaluates real-world GitHub issue resolution, it reaches 58.6%, solving more tasks end-to-end in a single pass than previous models.
Below GPT-5.5, two new smaller models round out the lineup. GPT-5.4 mini and GPT-5.4 nano are now available in the Chat Completions and Responses API. GPT-5.4 mini brings GPT-5.4-class capabilities to a faster, more efficient model for high-volume workloads, while GPT-5.4 nano is optimized for simple high-volume tasks where speed and cost matter most. Feature support differs: GPT-5.4 mini supports tool search, built-in computer use, and compaction, while GPT-5.4 nano supports compaction but does not support tool search or computer use.
| Model | Input (per 1M tokens) | Output (per 1M tokens) | Best for |
|---|---|---|---|
| GPT-5.5 | $5.00 | $30.00 | Complex reasoning, coding, agentic work |
| GPT-5.4 mini | $0.75 | $4.50 | High-volume production apps |
| GPT-5.4 nano | $0.20 | $1.25 | Classification, extraction, routing |
Cached inputs drop 90% on GPT-5.5 and GPT-5.4, which matters a lot for repeated system prompts and long-context agents. GPT-5.5 supports a 1,050,000-token context window with 128K max output, though prompts with more than 272K input tokens are priced at 2x input and 1.5x output for the full session.
Voice gets a serious upgrade
The realtime audio stack was completely rebuilt. GPT-Realtime-2 is a new realtime voice model with configurable reasoning for speech-to-speech agents, along with GPT-Realtime-Translate for streaming speech translation and GPT-Realtime-Whisper for streaming speech-to-text. GPT-Realtime-2 is the most capable realtime voice model, supporting speech-to-speech interactions with configurable reasoning effort, stronger instruction following, and more reliable tool use for complex voice-agent workflows. The old Realtime API Beta was removed, so if you're still on it, migration is not optional.
The Agents SDK grew up
This is the most significant infrastructure shift in the batch. The updated Agents SDK adds two things developers have been cobbling together themselves: native sandbox execution and a model-native harness.
The harness is the runtime layer that sits between your code and the model. In agent development, the "harness" refers to everything around the model itself: the instructions, tools, approvals, tracing, handoffs, and state management that make an agent functional in a real environment. Before this update, you had to build all of that yourself. With this release, the Agents SDK harness becomes more capable for agents that work with documents, files, and systems. It now has configurable memory, sandbox-aware orchestration, Codex-like filesystem tools, and standardized integrations with primitives that are becoming common in frontier agent systems.
The sandbox side is equally important. The updated Agents SDK supports sandbox execution natively, so agents can run in controlled computer environments with the files, tools, and dependencies they need for a task. Many useful agents need a workspace where they can read and write files, install dependencies, run code, and use tools safely. Native sandbox support gives developers that execution layer out of the box, instead of forcing them to piece it together themselves.
You can bring your own sandbox or use one of the built-in integrations. Supported providers include Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop, and Vercel. The harness and sandbox are deliberately kept separate for security: agent systems should be designed assuming prompt-injection and exfiltration attempts, and separating harness and compute helps keep credentials out of environments where model-generated code executes.
Durability is also built in. When the agent's state is externalized, losing a sandbox container does not mean losing the run. With built-in snapshotting and rehydration, the Agents SDK can restore the agent's state in a fresh container and continue from the last checkpoint if the original environment fails or expires.
Three primitives that make long-running agents actually work
Alongside the SDK update, OpenAI shipped three agentic primitives into the Responses API that address the most common failure modes for agents doing sustained work:
- Skills: Compressed prompt modules loaded on demand. Instead of injecting 40KB of context into every call, the SDK loads only an index, and the model requests relevant skills via a tool call. Skills are defined using the open
SKILL.mdstandard, which is also supported by Anthropic, making them portable across providers. Enterprise AI search startup Glean reported a jump in tool accuracy from 73% to 85% by using OpenAI's Skills framework. - Hosted Shell: Developers can opt for
container_auto, which provisions an OpenAI-hosted Debian 12 environment. This isn't just a code interpreter: it gives each agent its own full terminal environment pre-loaded with Python 3.11, Node.js 22, Java 17, Go 1.23, and Ruby 3.1. Container sessions are now billed per minute with a 5-minute minimum, which lowers effective cost for shorter sessions. - Server-side Compaction: Server-side compaction keeps long runs moving by managing the context window and compressing conversation history automatically. The results are striking. Early data from e-commerce platform Triple Whale shows their agent Moby successfully navigated a session involving 5 million tokens and 150 tool calls without a drop in accuracy. Compaction is trained behavior, not a hack: OpenAI's latest models are trained to analyze prior conversation state and produce a compaction item that preserves key prior state in an encrypted, token-efficient representation.
These three primitives are designed to work as a system. Skills define what the agent should do, the shell gives it a place to do it, and compaction ensures the agent can keep doing it for as long as necessary.
OpenAI lands on Amazon Bedrock
Perhaps the biggest strategic move in the batch: for many companies, using AI at scale requires bringing the best models to the systems their teams already use. That's why OpenAI launched its models, including GPT-5.5, on Amazon Bedrock. Customers can now build with OpenAI models in AWS, alongside the services, security controls, identity systems, and procurement processes they already rely on.
Both GPT-5.5 and GPT-5.4 run on Bedrock's next-generation inference engine, built for high performance, reliability, and security, and are available through the Responses API with pricing that matches OpenAI rates and no additional fees. For enterprises, the compliance story is clean: OpenAI models on Bedrock inherit the full set of enterprise controls customers already depend on, including IAM-based access management, AWS PrivateLink connectivity, guardrails, and encryption. Customers can apply OpenAI model usage toward their existing AWS cloud commitments.
The integration is a drop-in. You swap the client class and point at a Bedrock endpoint, and the rest of your code stays the same:
from openai import BedrockOpenAI
client = BedrockOpenAI(aws_region="us-east-2")
response = client.responses.create(
model="openai.gpt-5.5",
input="Summarize this contract.",
)
print(response.output_text)One caveat: hosted tools run through OpenAI-operated service infrastructure and are unavailable in the initial Amazon Bedrock offering. GPT-5.4 and GPT-5.5 also have a 272,000-token context window on Amazon Bedrock, compared to the 1M+ available directly through OpenAI.
What this means in practice
The through-line across all of these updates is that OpenAI is moving from selling model inference to selling a complete agent execution platform. These three features turn the Responses API from a model endpoint into a full agent platform, complete with compute, memory, and reusable capabilities. The Assistants API, which many teams still rely on, is being sunset: the shutdown date is August 26, 2026, with the Responses API and Conversations API as the official replacement. If you're still on Assistants, the clock is ticking.
For teams building agents today, the practical checklist looks like this:
- Migrate off the Assistants API before August 26, 2026
- Use
GPT-5.5for complex agentic or coding tasks;GPT-5.4 minifor high-volume production;GPT-5.4 nanofor classification and routing - Add
context_managementwithcompact_thresholdto any long-running Responses API loop - Replace ad-hoc system prompt blobs with versioned
SKILL.mdfiles - If you're on AWS, request Bedrock preview access to consolidate billing and compliance
Six months of quiet shipping just redrew the map for anyone building production AI systems on OpenAI's platform. The model quality improvements are real, but the infrastructure story is what will actually change how teams build.