One Agent vs Many Agents

In the early stages of development, we tend to build a "monolithic" agent—one giant LLM prompt with 50 tools. This is the "MacGyver" approach. While satisfying for simple tasks, it fails at scale due to context pollution and instructions-overload.

The "Industrial" approach is the Multi-Agent System (MAS). In this lesson, we will explore why and when to split your monolithic agent into a system of specialized workers.

---

1. The Monolithic Agent (Solo)

A single agent handling everything (Retrieval, Logic, Execution, Formatting).

Pros

• Simplicity: One graph, one thread, one prompt.
• Speed: No "inter-agent" communication overhead.

Cons (The "Instruction Ceiling")

• Token Waste: You pay to send all 50 tool descriptions in every turn, even if the user just said "Hello."
• Reasoning Drift: If an agent has too many responsibilities, it starts making "Creative" mistakes (using the wrong tool).

---

2. The Multi-Agent System (Swarm)

A group of specialized agents, each with a narrow focus and a custom set of tools.

Why Multi-Agent?

1. Separation of Concerns: One agent is a "Python Coder." Another is a "Senior Reviewer." They hold each other accountable.
2. Context Efficiency: Each agent only gets the context it needs to do its job.
3. Task Parallelization: Agent A can search Google while Agent B analyzes a local PDF.

---

3. Core Multi-Agent Patterns

A. The "Manager-Worker" Pattern (Hierarchy)

A central "Supervisor" agent receives the task, creates a plan, and delegates sub-tasks to worker agents.

graph TD
    User --> Supervisor[Supervisor Agent]
    Supervisor --> Researcher[Search Agent]
    Supervisor --> Writer[Drafting Agent]
    Researcher --> Supervisor
    Writer --> Supervisor
    Supervisor --> User

B. The "Chain-of-Command" (Sequential)

Agent 1 finishes its work and passes the torch to Agent 2.

• Example: Creative Director -> Graphic Artist -> QC Auditor.

C. The "Round Robin" (Collaborative)

Agents talk in a shared channel until they collectively agree on a solution.

---

4. The Technical Cost of Agency

Every time you add an agent, you introduce Communication Latency.

• Agent A sends a message.
• You must wrap it in a HumanMessage or FunctionMessage for Agent B.
• Agent B must "Read" and "Acknowledge" it.
• Result: A task that takes a human 1 minute might take 3 agents 30 seconds of "thinking" and another 30 seconds of "passing notes."

---

5. When to Split Your Agent: The "Rule of Three"

Don't over-engineer. Stay monolithic until:

1. You have more than 10 tools.
2. Your system prompt is longer than 2,000 words.
3. Your agent is consistently choosing the wrong tool for a specific task.

---

6. Implementation Strategy in LangGraph

In LangGraph, you don't actually need "separate" model objects. You just need different Nodes with different System Prompts.

# Node A: The Researcher
def researcher_node(state):
    # Specialized prompt for search
    return {"results": search_llm.invoke(state)}

# Node B: The Writer
def writer_node(state):
    # Specialized prompt for prose
    return {"final_draft": writer_llm.invoke(state)}

---

Summary and Mental Model

Think of a Monolithic Agent like a Solo Founder. They do the sales, the coding, and the coffee runs. It's fast, but they eventually burn out (Instruction Overload).

Think of a Multi-Agent System like a Scaling Series A Startup.

• You hire a specialized CTO (The Coding Agent).
• You hire a specialized Sales Lead (The Routing Agent).
• They talk in Slack (The Shared State) to get things done.

Scaling is the art of delegation.

---

Exercise: Agent Decomposition

1. Splitting Logic: You have an agent that "Creates a travel itinerary, books the flights, and sends an email to the user."
   • Break this into 3 specialized agents.
   • Give each agent a unique Mission Statement (Lesson 4.1).
2. Trade-off: If you split one agent into three, does your Total Cost go up or down?
   • (Hint: Think about "Input Tokens" per call).
3. Collaboration: How do you prevent two agents from trying to "Edit the same paragraph" at the same time? Ready to isolate these agents at the process level? Let's move to Process Isolation.