How to design agentic tasks with OpenAI tools

TL;DR

Agentic tool calling combines reasoning with the ability to call tools to achieve goals and perform long horizon tasks. The session includes a live demo of building a task system, handling a backlog of tickets, and guidance on delegation for evaluation. It also highlights 2025 updates such as the Responses API, Agents SDK, Hosted Tools, and Codex and explains how to use them to scale applications.

Transcript

Hey everyone, welcome back for another build hour. This is actually our first one of 2025 and we're really excited to be with you here today. My name is Sarah Urbonus and I lead startup marketing here at OpenAI and I am joined by Alain. Yeah, I'm Elan. I'm on the developer experience team. So, we always like to start Build Hour with kind of the goa... Read More

Key Insights

• Agentic tool calling is the process of combining model reasoning with the ability to call external tools to achieve a user defined end state.
• Long horizon tasks require planning for multiple steps, tool invocations, and state management to sustain progress over time.
• Reasoning in agentic systems is trained on results rather than explicit step by step instructions, enabling the model to determine its own action sequences.
• Tools can be accessed via APIs and SDKs to query files, run code, or call external services during task execution.
• Delegation in agentic systems allows tasks to be split and assigned to multiple agents or processes, improving scalability and fault tolerance.
• Infra and runtime environments are important for parallel execution, state synchronization, and handling failures during long tasks.
• Codex, 03 codeex, and other agents are cited as examples of how to implement and experiment with agentic workflows.
• The build hour emphasizes hands on coding, a live backlog processing demo, and guidance for eval to help teams ship practical AI powered features.
• More videos from this channel:
  • What is ChatGPT Atlas and how does it work?
  • How to connect internal data to ChatGPT for business
  • How to balance accuracy latency and cost at scale
• More from this channel: OpenAI

Questions & Answers

Q: A real search query question about the video (e.g. 'How to...', 'What is...', 'Why does...', 'When should...'). Question 1

What is agentic tool calling and why does it matter for building AI powered workflows? Agentic tool calling is the practice of letting a model reason about goals and also giving it access to tools or APIs so it can perform actions to reach those goals. This combination enables long horizon tasks where the model can plan, execute, and adjust its approach based on tool responses. It matters because it shifts AI from passively suggesting steps to actively completing tasks in a robust, end to end manner.

Q: Question 2

How do long horizon tasks differ from short, one off tasks in AI systems? Long horizon tasks require maintaining state, coordinating multiple tool calls, and potentially parallel work across subsystems. They need a task system interface for tracking progress, handling retries, and delegating sub tasks. Short tasks are typically single, atomic actions with immediate feedback and do not require extensive orchestration.

Q: Question 3

What role do updates like the Responses API and Agents SDK play in agentic task design? Updates like the Responses API and Agents SDK provide the building blocks to structure reasoning, tool calls, and event flows. They enable hosted tools, code exex, and long lived agent interactions, making it easier to implement, test, and scale agent based workflows across teams and product lines.

Q: Question 4

How can teams begin building a task system interface based on the session guidance? Teams should start by defining the end state of a task, the tools available, and how success is evaluated. Then they can implement an interface that captures task goals, sequences tool calls, and records progress and outcomes, followed by iterative testing with real world conditions and edge cases.

Q: Question 5

What is the importance of delegation in evaluating AI agents? Delegation helps distribute workload across multiple agents or processes, enabling asynchronous progress and parallel work. It supports scalability, reduces bottlenecks, and provides a mechanism for directional guidance during evals, allowing teams to observe how agents handle complex scenarios and recover from failures.

Q: Question 6

How does a live backlog processing demo help illustrate agentic capabilities? A backlog processing demo demonstrates an end to end flow where an agent system prioritizes, assigns, and executes tasks on a queue. It shows how planning, tool calls, and evaluation integrate into a cohesive process, highlighting robustness, fault tolerance, and the ability to adapt as new information comes in.

Q: Question 7

What are practical steps to start experimenting with codec and codeex for agentic tasks? Practical steps include selecting a task with a clear end state, enabling the relevant tools and environment, and writing a core loop that lets the agent reason, call tools, and update task state. Iteratively test with different scenarios, monitor outcomes, and refine prompts and tool interfaces for better reliability.

Q: Question 8

Why is it valuable to have a centralized hub for Build Hours and a community around agentic development? A centralized hub consolidates upcoming topics, sessions, and resources, helping teams plan learning journeys and coordinate experiments. A community around agentic development accelerates knowledge sharing, provides feedback loops, and supports faster adoption of new APIs, SDKs, and practical patterns for building AI powered products.

Summary & Key Takeaways

• A comprehensive walkthrough of agentic task design, combining reasoning and tool use to execute long horizon goals, with a hands on demo building a task system interface and backend.

• An overview of key 2025 OpenAI offerings and how they enable agents to reason, call tools, and delegate tasks across systems and evaluations.

• A practical playbook for integrating tools, managing state, and evaluating agent performance in real world workflows.