Build Hour: Agentic Tool Calling

Agentic tool calling is being positioned as the bridge between “reasoning” and “doing,” enabling goal-driven models that can plan across long horizons, call tools repeatedly, recover from failures, and stay consistent through tens or hundreds of function calls. The practical payoff is a shift from chat-only interactions toward long-horizon “tasks” that have an end state, run with supporting infrastructure, and can be evaluated by outcomes rather than turn-by-turn correctness.

The session ties that concept to a broader 2025 push toward agents, highlighting new capabilities such as deep research 03 and Codex, plus the responses API’s growing ecosystem. A key thread is how reasoning training and tool execution combine: models are trained to optimize for correct results (not step-by-step scripts), then tool calling supplies the means to fetch information and take actions. When those two pieces work together, the system becomes “resourceful” and “robust to recovery,” with the ability to course-correct after tool failures and continue toward the goal across long sequences.

From there, the talk reframes “tasks” as a new abstraction layer above chat. A task isn’t just a prompt; it’s an agent definition (what it should do), infrastructure (how it runs, manages state, retries, and parallelism), a product layer (how users interact, how progress is surfaced, and what context is provided), and evaluation (how success is graded). Goal specification is emphasized as different from step-by-step prompting: instead of dictating the path, the system is given the desired end state, along with the tools needed to reach it.

A hands-on coding segment demonstrates an agentic task system for a customer-service backlog. The implementation starts with the agents SDK to wrap the tool-calling loop, then defines mock functions such as retrieving user data, fetching order details, and initiating refunds. The agent is instructed to “get all the context you need up front” and then complete without further back-and-forth, illustrating how end-state instructions can reduce unnecessary interaction.

The product/infrastructure integration is where the architecture becomes concrete. A simple “foreground” approach streams events over an SSE connection while the client stays connected. For real-world long-running work, the session then builds a background-task pattern: a backend task endpoint creates a task and returns a task ID, while a separate SSE events endpoint streams task updates to the frontend. An async worker runs the agent with streaming, publishes response events to the event queue, and updates task status until completion.

To make progress visible without exposing raw internal tool calls, the demo adds a to-do mechanism. The model receives functions that can update a task’s to-dos; the frontend renders those to-dos as progress indicators, while the underlying function-call details are filtered out. This creates a user experience that feels transparent and “magical” without building a separate monitoring UI.

The Q&A extends the theme with practical guidance: use Python for strict sequential/conditional tool chains when needed; manage memory via the model’s context plus external stores like vector search; keep tool counts to a reasonable range (roughly under 20) and use handoffs when tool sets grow; combine hosted tools (including MCP) with custom functions; and note that the responses API supports MCP, enabling long background runs when everything can be handled remotely. The session closes by pointing to shared repos, a practical guide for building agents, and an upcoming build hour focused on image gen.