Build Hour: Agents SDK

Key Concepts

• Agents SDK: An open-source, model-agnostic framework for building production-grade AI agents.
• Sandbox: An isolated environment (Docker, Modal, Cloudflare, etc.) where agents execute code and manipulate files.
• Codex-style Harness: A design pattern that enables agents to perform long-horizon tasks using async shell interaction, file manipulation, and context compaction.
• Manifest: A configuration object defining the initial file system state and external data mounts for an agent.
• Skills API: A centralized repository for bundling instructions, scripts, and resources for specific agent tasks.
• Snapshotting/Rehydration: The process of saving the state of a sandbox (file system and conversation history) to allow an agent to resume work seamlessly after a container stops.
• Capability: A modular object that bundles tools, instructions, and environment configurations.

---

1. Main Topics and Updates

The session focused on evolving the Agents SDK to handle long-running, production-grade tasks. Key updates include:

• Decoupling Harness from Compute: By separating the agent's orchestration logic (harness) from the execution environment (sandbox), developers can treat sandboxes as ephemeral, stateless resources.
• TypeScript Support: Following the Python release, the SDK now fully supports TypeScript.
• Hosted Shell Tool: A lightweight API feature that spins up ephemeral containers to execute code and process files without requiring a full SDK implementation.
• Skills API: Allows developers to version and manage "skill bundles" (instructions + scripts) centrally, rather than relying on local files or external repositories.

2. Step-by-Step Framework: Building an Agentic Task Tracker

Steve demonstrated a workflow for automating conference planning:

1. Agent Definition: Subclassing the SandboxAgent and defining instructions.
2. Sandbox Configuration: Selecting a backend (e.g., Docker for local, Modal for cloud) and defining the environment image (e.g., Python 3.12).
3. Capability Integration: Adding the Skills capability to pull specific logic from a GitHub repository.
4. Tool Implementation: Using the @function_tool decorator to expose custom Python/TypeScript functions (e.g., update_task_status) to the model.
5. Human-in-the-loop: Implementing approval logic for sensitive actions (e.g., marking a task as "Done" requires explicit human confirmation).
6. Persistence: Using the SDK’s snapshotting mechanism to save the file system to an external store (e.g., R2/S3) for seamless rehydration.

3. Key Arguments and Perspectives

• Orchestration vs. Product: Steve argued that developers should spend less time building custom orchestration loops (the "agent loop") and more time building product-specific features. The SDK handles the loop, tool routing, and context management automatically.
• Security: By splitting the harness from the sandbox, developers can avoid storing secrets on the sandbox itself, mitigating risks from prompt injection or data exfiltration.
• Freshness vs. Latency: Nish (Product Manager) noted a trade-off in file management: copying files into a sandbox at startup increases latency but improves runtime performance, whereas mounting external volumes (R2/S3) provides faster startup but introduces network latency during file operations.

4. Notable Quotes

• "The agents SDK is designed to help you do all that stuff [orchestration] and not really think about the orchestration." — Steve
• "The model is actually unaware of the fact that it's running on a new container; it's totally oblivious to that." — Steve (on rehydration)

5. Technical Details & Data

• Context Compaction: The SDK includes automatic context compaction, allowing models to work for extended periods (hours to weeks) without exceeding the context window.
• Multi-tenancy: The SDK is designed to be multi-tenant, allowing systems to process many user requests simultaneously.
• Compatibility: The SDK supports R2 and S3 buckets via a unified API, allowing for large-scale data processing without local storage limitations.

6. Synthesis and Conclusion

The OpenAI Agents SDK has matured into a robust framework that abstracts the complexities of long-running agentic workflows. By providing first-class support for sandboxing, persistent state management (via snapshots), and modular capabilities (skills and tools), it enables developers to move from simple "one-shot" API calls to sophisticated, multi-agent systems. The shift toward cloud-native sandboxes (Modal, Cloudflare) and external data mounting (R2/S3) marks a significant step toward making AI agents reliable for production environments.