OpenAI Agents API Adds Computer Use, Tool Search, Context Compaction

OpenAI pushed its agent infrastructure forward at DevDay 2026: computer use is now available in the Agents API, letting developer-built agents operate software autonomously — a capability previously confined to Codex and to ChatGPT on macOS since April and Windows 11 since May. The API simultaneously gained multi-agent capabilities, Tool Search, and Context Compaction, which automatically condenses long contexts. Behind the features sits a research statistic OpenAI shared the same day: zero-intervention success on 8-to-16-hour tasks rose from 10 percent in January 2026 to 35 percent by July.

This piece covers what each addition does, why the four together describe a specific architecture OpenAI is standardizing, and what builders should verify before moving agent workloads onto the new primitives. It is written for engineers building autonomous systems on the OpenAI platform.

Computer use: what changed in the API

Until now, an agent that needed to click, type, and navigate applications had to live inside OpenAI's own products — Codex, or ChatGPT's desktop integrations on macOS and Windows 11. Moving computer use into the Agents API hands that capability to arbitrary developer applications: an agent can now complete tasks by operating software directly, not just by calling structured APIs.

OpenAI paired the launch with harness improvements: internal optimization of the computer-use harness — work the company says its own AI models contributed to — delivered a 2x latency win, and current models show fewer desktop and browser navigation errors. Latency and misclick rates are precisely the two factors that decide whether GUI-driving agents are viable, since every wrong click compounds across a long workflow.

Tool Search and Context Compaction: scaling the loop

Tool Search addresses an emerging scale problem: agents connected to large tool catalogs cannot carry every tool definition in context on every call. Letting the agent search for relevant tools instead of enumerating them keeps prompt size flat as the catalog grows — the difference between an agent with ten tools and an agent with a thousand.

Context Compaction attacks the other axis: duration. Long-running tasks accumulate history until they overflow the context window, and manual summarization strategies are one of the most reinvented pieces of agent plumbing. Making compaction automatic at the API level removes that burden — and given OpenAI's 8-to-16-hour task framing, it is clearly built for agents whose transcripts far exceed any context window.

The 10-to-35-percent number, read carefully

The most consequential disclosure was the research trajectory: tasks of 8 to 16 hours completed with zero human interventions moved from a 10 percent success rate in January to 35 percent in July. That is a 3.5x improvement in six months on exactly the metric that always-on agents — like the dots OpenAI launched the same day — depend on. It is also still a 65 percent failure rate, which explains why every agent product OpenAI shipped this week emphasizes approval gates, activity views, and monitoring.

For builders, the number is a calibration tool: design for graceful interruption and human checkpoints, because even the frontier lab's own systems fail most long tasks without intervention. The improvements — compaction, fewer navigation errors, faster harnesses — are the mechanisms behind the curve, and the curve's slope matters more than its current value.

Multi-agent and the AWS option

The multi-agent capabilities land alongside a deployment expansion: Bedrock Managed Agents — the limited preview OpenAI launched in April — now integrates core Agents API features with AWS customization and direct resource connectivity, letting OpenAI agents run entirely within AWS infrastructure. For enterprises whose data governance stops at the VPC boundary, that answers the deployment question that kept agent pilots from production.

Together the pieces describe one architecture: multiple agents, discovering tools on demand, compacting their own memory, operating computers directly, deployable inside customer infrastructure. That is the platform OpenAI's own dots are built on, now exposed layer by layer to developers.

What to verify before building on it

Computer use in an API context raises the questions OpenAI answered for its own products but developers must answer for theirs: sandboxing, credential handling, and what the agent is permitted to click in production. The dots launch showed OpenAI's own answers — separate cloud computers, read-only background modes, action review — and building equivalents is now the developer's job, not an optional extra.

Benchmark the claims against your workloads: measure the harness latency improvement on your actual GUI flows, test Context Compaction against tasks where specific early details must survive hours of history, and validate Tool Search recall on your real catalog — a missed tool is a silent capability loss. Watch for pricing details on computer-use sessions and how the multi-agent primitives compose with the Decisions API's fast classification, announced the same day.