1 What are LLM Agents and Multi-Agent Systems?

Large language models are excellent at expressing intent, but they cannot act without scaffolding. This chapter introduces LLM agents—systems that turn an LLM’s text-planned intentions into real actions by calling external tools—and shows how multiple agents can be combined into multi-agent systems for tougher problems. It surveys prominent applications such as report generation, web and deep research, retrieval-augmented generation, coding with sandboxed interpreters, and full computer-use automation. Standards like the Model Context Protocol expand an agent’s toolset, while Agent2Agent enables collaboration across heterogeneous agent frameworks. The overarching goal is to build a deep, working understanding by constructing agents and multi-agent systems from scratch.

At their core, LLM agents pair a backbone LLM with tools and rely on two prerequisite capabilities: planning and tool-calling. Tasks run inside a processing loop where the agent formulates or adapts a plan, invokes tools via structured requests, synthesizes results, and iterates until completion; the resulting “trajectory” is invaluable for inspection and debugging. The chapter details enhancements that improve reliability and efficiency: memory modules to save and reload past steps and tool outputs, and human-in-the-loop checkpoints to prevent cascading errors (with a latency trade-off). It also clarifies related ideas—reasoning-oriented prompting, specialized Large Action Models for narrow action domains, and how LLM agents differ from reinforcement learning agents trained to optimize explicit reward signals.

Multi-agent systems shine when complex tasks can be decomposed into focused subtasks handled by specialized agents whose results are combined, often outperforming a single generalist. Protocols anchor this ecosystem: MCP standardizes access to third-party tools and resources, and A2A provides agent-to-agent communication so agents across frameworks can collaborate. The chapter closes with a hands-on roadmap for building a custom framework in four stages: implement base Tool and LLM interfaces and an agent processing loop; add MCP compatibility (including building a server); incorporate memory and human-in-the-loop controls; and finally integrate A2A and coordination logic to construct full multi-agent solutions for real applications like deep research and automated report generation.

The applications for LLM agents are many, including agentic RAG, report generation, deep search and computer use, all of which can benefit from MAS.

An LLM agent is comprised of a backbone LLM and its equipped tools.

LLM agents utilize the planning capability of backbone LLMs to formulate initial plans for tasks, as well as to adapt current plans based on the results of past steps or actions taken towards task completion.

An illustration of the tool-equipping process, where a textual description of the tool that contains the tool’s name, description and its parameters is provided to the LLM agent.

The tool-calling process, where any equipped tool can be used.

A mental model of an LLM agent performing a task through its processing loop, where tool calling and planning are used repeatedly. The task is executed through a series of sub-steps, a typical approach for performing tasks.

An LLM agent that has access to memory modules where it can store key information of task executions and load this back into its context for future tasks.

A mental model of the LLM agent processing loop that has memory modules for saving and loading important information obtained during task execution.

An LLM agent processing loop with access to human operators. The processing loop is effectively paused each time a human operator is required to provide input.

Multiple LLM agents collaborating to complete an overarching task. The outcomes of each LLM agent’s processing loop are combined to form the overall task result.

A first look at the llm-agents-from-scratch framework that we’ll build together.

A simple UML class diagram that shows two classes from the llm-agents-from-scratch framework. The BaseTool class lives in the base module, while the ToolCallResult lives in the data_structures module. The attributes and methods of both classes are indicated in their respective class diagrams and the relation between them is also described.

A UML sequence diagram that illustrates how the flow of a tool call. First, an LLM agent prepares a ToolCall object and invokes the BaseTool, which initiates the processing of the tool call. Once completed, the BaseTool class constructs a ToolCallResult which then gets sent back to the LLM agent.

The build plan for our llm-agents-from-scratch framework. We will build this framework in four stages. In the first stage, we’ll implement the interfaces for tools and LLMs, as well as our LLM agent class. In the second stage, we’ll make our LLM agent MCP compatible so that MCP tools can be equipped to the backbone LLM. In stage three, we will implement the human-in-the-loop pattern and add memory modules to our LLM agent. And, in the fourth and final stage, we’ll incorporate A2A and other multi-agent coordination logic into our framework to enable building MAS.

• LLMs have become very powerful text generators that have been applied successfully to tasks like text summarization, question-answering, and text classification, but they have a critical limitation in that they cannot act; they can only express an intent to act (such as making a tool call) through text. That’s where LLM agents come in to bring in the ability to carry out the intended actions.
• Applications for LLM agents are many, such as report generation, deep research, computer use and coding.
• With MAS, individual LLM agents collaborate to collectively perform tasks.
• Many applications for LLM agents can further benefit from MAS. In principle, MAS excel when complex tasks can be decomposed into smaller subtasks, where specialized LLM agents outperform general-purpose LLM agents.
• LLM agents are systems comprised of an LLM and tools that can act autonomously to perform tasks.
• LLM agents use a processing loop to execute tasks. Tool calling and planning capabilities are key components of that processing loop.
• Protocols like MCP and A2A have helped to create a vibrant LLM agent ecosystem that is powering the growth of LLM agents and their applications. MCP is a protocol developed by Anthropic that has paved the way for LLM agents to use third-party provided tools.
• A2A is a protocol developed by Google to standardize how agent-to-agent interactions are conducted in MAS.
• Building an LLM agent requires infrastructure elements like interfaces for LLMs, tools, and tasks.
• We’ll build LLM agents, MAS, and all the required infrastructure from scratch into a Python framework called llm-agents-from-scratch.

FAQ