OpenAI's Agents SDK Gets Native Sandbox Execution!

Hey everyone, it's Shii-chan! Today's news is exciting for anyone building AI agents: OpenAI just gave the Agents SDK a big evolution. Let's dig in!

OpenAI News openai.com

What was announced?

From OpenAI's News, there's an update to the Agents SDK that adds two big things. First, a model-native harness that lets agents work across files and tools on a computer. Second, native sandbox execution so that work can run safely.

In short, you now get standardized agent infrastructure that's built correctly for OpenAI models, without having to piece it together yourself.

The story so far

To build a useful agent, great models alone aren't enough. You need systems that support how agents inspect files, run commands, write code, and keep working across many steps.

Until now, the options each came with tradeoffs:

• Model-agnostic frameworks are flexible but don't fully utilize frontier model capabilities.
• Model-provider SDKs can be closer to the model but often lack visibility into the harness.
• Managed agent APIs simplify deployment but constrain where agents run and how they access sensitive data.

These tradeoffs bite harder as teams move from prototype to production.

What changes

With this release, the Agents SDK harness gets much 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 harness also aligns execution with the way models perform best, so you get better reliability and performance on complex tasks—especially long-running work spread across many tools.

An engineer at Oscar Health who tested it said it made a clinical records workflow production-viable when previous approaches couldn't handle it reliably enough:

"The updated Agents SDK made it production-viable for us to automate a critical clinical records workflow that previous approaches couldn't handle reliably enough."

Dive Deep

The biggest piece is native sandbox execution. Agents can now run in controlled computer environments with the files, tools, and dependencies they need. You get an execution layer for reading and writing files, installing dependencies, running code, and using tools safely—out of the box, instead of building it yourself.

You can bring your own sandbox or use built-in support for Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop, and Vercel.

To keep environments portable across providers, the SDK adds a Manifest abstraction for describing the workspace. You can mount local files, define output directories, and bring in data from storage providers including AWS S3, Google Cloud Storage, Azure Blob Storage, and Cloudflare R2. That gives the model a predictable workspace: where to find inputs, where to write outputs, and how to stay organized across a long task.

The other key idea is separating the harness from compute. Agent systems should be designed assuming prompt-injection and exfiltration attempts, and separating the two keeps credentials out of the environment where model-generated code runs.

That separation also enables durable execution. With state externalized, losing a sandbox container doesn't mean losing the run. Built-in snapshotting and rehydration let the SDK restore the agent's state in a fresh container and continue from the last checkpoint if the original environment fails or expires. It also scales: use one sandbox or many, invoke sandboxes only when needed, route subagents to isolated environments, and parallelize work across containers.

On pricing, these capabilities are generally available to all customers via the API and use standard API pricing based on tokens and tool use—no special add-on cost.

One note: the new harness and sandbox features launch first in Python, with TypeScript support planned for later. Code mode and subagents are also on the way for both Python and TypeScript.

Wrap-up

• OpenAI added a model-native harness and native sandbox execution to the Agents SDK.
• The harness gains configurable memory, sandbox-aware orchestration, and Codex-like filesystem tools, making it stronger on complex, long-running tasks.
• Sandboxes support Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop, and Vercel, and the Manifest keeps workspaces portable.
• Separating harness from compute brings security, durability, and scale, including restoring state from snapshots.
• It's available now at standard API pricing, but Python first—TypeScript is coming.

This one's for developers tired of hand-building agent runtimes, especially anyone shipping long-running, multi-tool agents to production!