Building an application that calls a large model is not hard. But once the model starts choosing tools on its own, deciding the next step from the execution result, and even handing a task over to another Agent, the execution logic of the program changes: what runs next is no longer written into the code by the developer in advance.
So how does an AI Agent actually run? How does the model know which tools are available, and how does it decide when to call which one? How does a tool's result re-enter the context and shape the next round of decisions? And when a single Agent cannot finish a complex task, how should capabilities be split apart and composed into several Agents working together?
Using the open source Strands Agents SDK as a practical framework, this talk uses Python code and live demos to take apart the core mechanics of an AI Agent, starting from how it executes:
Agent Loop: who decides the next step? Starting from a single model call, we unpack the dynamic execution loop formed by reasoning, action, observation and the next round of decision-making, and see how an Agent differs from an application with a traditional fixed control flow.
Tool Calling: from function calls to autonomous tool selection. We look at how an ordinary function becomes a Tool the Agent can understand and call, and how the tool schema, the context and the execution result together influence the model's next action.
From local Tools to MCP. We show how MCP extends an Agent's capabilities from local functions to external tools and services, and where MCP sits within the Agent execution loop.
From Tool to Agent: composition and multi-Agent collaboration. We explore patterns such as Agent-as-Tool, and how Agents in different roles use delegation and collaboration to complete tasks a single Agent would struggle with.
Seeing the Agent execute. With hooks, tracing and observability we observe what decisions the model made, which tools it called, and how a task flows between Agents and Tools.
This is not a feature tour of an Agent framework API. The aim is to open the "black box" of the Agent with real code, and to understand how the model, the code, the tools and other Agents jointly decide the system's next action.
The audience will come away with a clear mental model of how Agent execution works, and with the knowledge to use Python to compose functions, external tools and multiple Agents into agentic applications that complete tasks on their own.