OpenAI Launches Agents SDK and Responses API: A New Era of AI Agent Development
Discover OpenAI’s latest innovations with the launch of the Agents SDK and Responses API. Learn how these powerful tools simplify the development of intelligent agents and enhance automation
OpenAI has just dropped a game-changing update for developers looking to build sophisticated AI agents. Their new Agents SDK and Responses API represent a significant leap forward in how we can create and deploy AI systems that interact with the world. Let's dive into what makes these tools so revolutionary and how they're reshaping the AI development landscape.
No Time to Read? Here's the Scoop
OpenAI has released a new Agents SDK and Responses API for building sophisticated AI agents
The Responses API merges Chat Completions API ease with Assistants API tool functionality. If using their chat completions API, then plan to migrate to the new one.
Built-in tools include web search, file search, and computer use capabilities, but it’s not free, separate pricing for each. Read the blog for more info.
The Agents SDK is open source and facilitates both single-agent and multi-agent workflows, but it’s difficult to use it for other models.
Integrated observability tools help developers trace and debug agent operations. It’s quite helpful.
Building Blocks for AI Agents
The core philosophy behind the Agents SDK is to create systems that can operate independently, handling complex workflows with minimal human oversight.
OpenAI has spent the past year refining its models with advanced reasoning, multimodal interactions, and enhanced safety techniques, laying the groundwork for these capabilities to be transformed into production-ready agents.
OpenAI has introduced a suite of APIs and tools aimed specifically at streamlining the development of agentic applications. These include:
Responses API: A new API merging the ease of the Chat Completions API with the tool-use features of the Assistants API, ideal for building agents that go beyond basic interactions.
Built-in Tools: Web search, file search, and computer use, that allow agents to gather and utilize external information effectively.
Agents SDK: A framework facilitating the orchestration of both single-agent and multi-agent workflows, streamlining the creation and management of complex AI systems. It’s open source
Integrated Observability Tools: Features for tracing and inspecting agent workflow executions provide developers with visibility into agent operations for better debugging and optimization.
The Responses API: A Gateway to Agentic Applications
The Responses API provides developers with a unified way to leverage OpenAI’s built-in functionalities. This API significantly reduces the complexity of marrying OpenAI’s models and built-in tools, making agent development more accessible.
Read the previous blogs here:
Advanced Built-in Tools Enhance Functionality
OpenAI’s new built-in tools in the Responses API are designed to enhance agents’ operational capabilities:
Web Search: This tool enables agents to access real-time information from the web, providing relevant citations that enhance the value of user interactions. Early testing has validated its effectiveness, as seen in applications across shopping, research, and travel.
const response = await openai.responses.create({ model: "gpt-4o", tools: [{ type: "web_search_preview" }], input: "What was a positive news story that happened today?", }); console.log(response.output_text);File Search: This feature allows agents to efficiently retrieve information from large datasets by supporting multiple file types and incorporating advanced query optimization techniques, making it especially beneficial for customer support applications.
const productDocs = await openai.vectorStores.create({ name: "Product Documentation", file_ids: [file1.id, file2.id, file3.id], }); const response = await openai.responses.create({ model: "gpt-4o-mini", tools: [{ type: "file_search", vector_store_ids: [productDocs.id], }], input: "What is deep research by OpenAI?", }); console.log(response.output_text);Computer Use: Leveraging the Computer-Using Agent (CUA) model, this tool allows agents to perform tasks directly on users’ computers. While it holds the potential to revolutionize workflows—particularly in legacy systems—its performance requires careful monitoring due to current success rates on benchmark tasks.
const response = await openai.responses.create({ model: "computer-use-preview", tools: [{ type: "computer_use_preview", display_width: 1024, display_height: 768, environment: "browser", }], input: "I'm looking for a new camera. Help me find the best one.", }); console.log(response.output);
By the way all this comes at a price, check it out here:
Agents SDK: Orchestrating Intelligent Workflows
To complement the Responses API, the Agents SDK provides a framework for orchestrating multi-agent workflows efficiently. Key features include:
Configurable LLMs: Developers can create agents with customized instructions and built-in tools aligned with specific tasks.
Handoffs: The ability for agents to intelligently transfer control between one another enhances collaborative functionality.
Guardrails: The inclusion of configurable safety checks ensures that agents validate inputs and outputs, maintaining reliability.
Tracing & Observability: This feature visualizes agent execution, enabling developers to debug and optimize agent performance effectively.
Example:
from agents import Agent, Runner, WebSearchTool, function_tool
@function_tool
def submit_refund_request(item_id: str, reason: str):
# Your refund logic goes here
return "success"
support_agent = Agent(
name="Support & Returns",
instructions="You are a support agent who can submit refunds [...].",
tools=[submit_refund_request],
)
shopping_agent = Agent(
name="Shopping Assistant",
instructions="You are a shopping assistant who can search the web [...].",
tools=[WebSearchTool()],
)
triage_agent = Agent(
name="Triage Agent",
instructions="Route the user to the correct agent.",
handoffs=[shopping_agent, support_agent],
)
output = Runner.run_sync(
starting_agent=triage_agent,
input="What shoes might work best with my outfit so far?",
)
Real-World Applications Taking Shape
What excites me most about these tools is seeing the innovative applications developers are already building:
Autonomous research assistants that can gather information, synthesize findings, and generate reports with minimal supervision
Personal productivity agents that integrate with calendars, email, and task management systems
Customer service systems that can handle complex troubleshooting flows while maintaining context
Looking Ahead: What This Means for the Future
The Agents SDK and Responses API represent just the beginning of what promises to be a transformative period in AI development. As these tools mature and the community builds upon them, we can expect to see increasingly sophisticated AI agents becoming integrated into our daily digital experiences.
The launch of the Agents SDK and Responses API positions OpenAI at the forefront of AI agent development. By providing robust tools to build, deploy, and optimize intelligent agents, OpenAI facilitates a future where AI systems integrate seamlessly into the workforce, enhancing productivity and transforming how organizations operate.
Check out their video:
Read their blog here - https://openai.com/index/new-tools-for-building-agents/