Last night, OpenAI released tools for building agents. The emergence of these tools may change the way developers build AI applications, making the development of agents simpler, more efficient, and more reliable.

Recently, the field of AI Agent has been very hot. From Devin and MGX in the field of AI programming to Manus, a general agent concept, many products have been launched one after another, and the speed of evolution and iteration is getting faster and faster. Open source general agents, such as OpenManus and OWL, have quickly become high-star ⭐️ hot products in the open source community.

Intelligent agents are systems that can independently complete user tasks. They can help us handle a variety of complex, multi-step tasks, greatly improving our work efficiency and quality of life. However, although the capabilities of AI models are constantly improving, it is not easy to transform these capabilities into production-level intelligent agents. It often requires a lot of prompt iterations and custom orchestration logic, and lacks sufficient visibility and built-in support. To address these challenges, OpenAI has released a series of new tools and APIs, hoping to simplify the development process of intelligent agents and enable developers to more easily build practical and reliable intelligent agents.

Responses API: A core tool to simplify agent development

Responses API is a new generation API launched by OpenAI, which combines the simplicity of Chat Completions API and the tool usage capabilities of Assistants API, providing a more flexible foundation for developers to build intelligent agents. With a simple Responses API call, developers can use a variety of tools and model rounds to solve increasingly complex tasks.

Benefits of the Responses API

The design concept of Responses API is to encapsulate complex functions in a concise interface, allowing developers to develop intelligent agents more efficiently. It has the following advantages:

• •  Unified design and polymorphism : Responses API adopts a unified project-based structure, which simplifies polymorphism processing and makes it easier for developers to handle different types of data and responses.
• •  Intuitive streaming events : Provides an intuitive streaming event processing mechanism, allowing developers to more easily process and respond to real-time output of the model.
• •  SDK auxiliary tools : introduced such as response.output_text SDK auxiliary tools such as , make it easy for developers to quickly obtain the text output of the model and improve development efficiency.

Application scenarios of Responses API

The Responses API has a wide range of applications, and any application that needs to combine OpenAI models and built-in tools can use it. For example, developers can use the Responses API to build shopping assistants, research agents, travel booking agents, etc. These applications all need to obtain information from the network in a timely manner to complete tasks.

Built-in tools for the Responses API

In order to enable intelligent agents to better interact with the real world, OpenAI introduced a variety of built-in tools in the Responses API, including web search, file search, and Computer Use. These tools are designed to enable intelligent agents to complete tasks more efficiently, and developers can integrate them with just a few lines of code.

Web Search

The web search tool allows developers to quickly obtain the latest information on the Internet and provide clear and relevant citations. In the Responses API, the web search tool uses GPT-4O and gpt-4o-mini , and can be combined with other tools or function calls. For example:

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 );

Hebbia uses web search tools to help asset managers, private equity and credit firms, and law firms, among others, quickly extract actionable insights from massive public and private data sets, providing richer, more specific market intelligence and improving the accuracy and relevance of analysis.

Web search in the API is powered by the same model as ChatGPT Search. On the SimpleQA benchmark, which evaluates the accuracy of LLMs in answering short, factual questions, GPT-4o Search Preview and GPT-4o mini  Search Preview scored 90% and 88%, respectively.

File Search Tool

The file search tool allows developers to easily retrieve relevant information from a large number of documents, supporting multiple file types, query optimization, metadata filtering, and custom re-ranking. For example:

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 );

Navan uses document search tools in its AI-driven travel agent to quickly provide users with precise answers from knowledge base articles, such as a company’s travel policies. With built-in query optimization and re-ranking capabilities, they were able to build a powerful Retrieval Augmentation Generation (RAG) pipeline without additional tuning or configuration.

Computer Use

The Computer Usage Tool enables developers to build agents that can complete tasks on computers and is based on the same Computer Usage Agent (CUA) model as Operator, which has achieved new state-of-the-art records on multiple benchmarks. For example:

const  response =  await  openai. responses . create ({
    model :  "computer-use-preview" ,
    tools : [{
        type :  "computer_use_preview" ,
        display_width :  1024 ,
        display_height :  768 ,
        environment :  "browser" ,
    }],
    truncation :  "auto" ,
    input :  "I'm looking for a new camera. Help me find the best one." ,
});

console . log (response . output );

Unify uses computer vision tools to give its agents access to information not available through APIs, such as verifying whether a business has expanded its real estate footprint through online maps, thereby triggering personalized outreach to help revenue growth teams engage with buyers with precision and scale.

In addition to building the core logic of the agents and giving them tools to make them useful, developers also need to orchestrate the workflow of the agents. OpenAI’s newly launched open source Agents SDK greatly simplifies the orchestration of multi-agent workflows and improves on this in many ways.

Features of Agents SDK

Agents SDK provides an efficient way to manage and coordinate collaboration among multiple agents. Its main features include:

• •  Easy-to-configure agents : Agents SDK provides easy-to-configure LLMs with clear instructions and built-in tools, allowing developers to quickly build agents based on different task requirements.
• •  Intelligent Handoffs : Ability to intelligently transfer control between different agents, allowing multiple agents to work together to complete complex tasks.
• •  Guardrails : Configurable security checks for input and output validation to ensure the security and reliability of the agent.
• •  Tracing & Observability : It can visualize the traces executed by the agent to help developers debug and optimize performance.

Agents SDK Application Scenarios

Agents SDK is suitable for a variety of practical application scenarios, including customer support automation, multi-step research, content generation, code review, and sales lead generation. For example, Coinbase used Agents SDK to quickly prototype and deploy AgentKit, enabling AI agents to interact seamlessly with crypto wallets and various on-chain activities. Box used Agents SDK and network search capabilities to quickly create agents that can search, query, and extract unstructured data within Box and from public Internet sources, providing enterprise customers with a secure and efficient way to access and analyze data.

The following is a simple example code using the Agents SDK:

from  agents  import  Agent, Runner, WebSearchTool, function_tool, guardrail

@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?" ,
)

Impact on existing APIs

Chat Completions API

Chat Completions remains OpenAI's most widely adopted API, and OpenAI will continue to support it and introduce new models and features. For developers who do not need built-in tools, you can continue to use Chat Completions with confidence. However, the Responses API is a superset of Chat Completions and has the same excellent performance, so for new integrations, OpenAI recommends starting with the Responses API.

Assistants API

Based on developer feedback on the Assistants API beta, OpenAI has incorporated key improvements into the Responses API to make it more flexible, faster, and easier to use. OpenAI is working to achieve full feature parity between the Assistants and Responses APIs, including support for Assistant- and Thread-like objects and a code interpreter tool. Once complete, OpenAI plans to formally announce the deprecation of the Assistants API, with a target sunset date of mid-2026. OpenAI will continue to release new models to the Assistants API until deprecation.