Gen AI

Supervisor Pattern

Instead of letting agents talk to whoever they want, you create a rigid hierarchy. A 'Manager' agent receives the task, delegates sub-tasks to 'Worker' agents, reviews their work, and compiles the final answer.

Why Does This Exist?

When building Multi-Agent Systems, the default approach is often a "Group Chat." You put the User, the Coder Agent, and the Reviewer Agent in a virtual room and tell them to figure it out.

Group Chats are highly creative, but highly unreliable. The Coder might ignore the Reviewer. The agents might get stuck in an infinite argument. They might hallucinate that the task is finished before it actually is. In production applications (like banking or healthcare), you cannot afford this chaos.

The Supervisor Pattern enforces strict control flow. You structure your AI exactly like a corporate hierarchy. Worker agents do not talk to each other; they only talk to their Manager (the Supervisor).

Think of It Like This

Building a House

Group Chat Pattern: You put a plumber, an electrician, and a carpenter in an empty lot. You yell "Build a house!" and walk away. They will likely argue over who goes first, step on each other's toes, and build a mess.

Supervisor Pattern: You hire a General Contractor (Supervisor). The Contractor tells the carpenter to build the frame. The carpenter finishes and reports to the Contractor. The Contractor then tells the electrician to wire the frame. The workers never talk to each other directly; the Contractor orchestrates the entire project plan.

How It Actually Works

The Supervisor is usually a fast, highly capable LLM (like GPT-4o). It has no tools of its own (it cannot search the web or write code). Its only job is to Route, Delegate, and Evaluate.

The Execution Loop

The Request: The user asks: "Research Apple's Q3 earnings and write a python script to graph them."
The Plan: The Supervisor reads the request and breaks it into steps.
Delegation 1: The Supervisor creates a Sub-Agent Handoff to the Researcher Agent: "Find Apple's Q3 earnings."
Execution 1: The Researcher Agent uses its web tools, finds the data, and reports back to the Supervisor.
Delegation 2: The Supervisor routes to the Coder Agent: "Here is the data: [Data]. Write a graphing script."
Execution 2: The Coder Agent writes the script and reports back.
Finalization: The Supervisor compiles the final response and returns it to the user.

Show Me the Code

Frameworks like LangGraph excel at the Supervisor Pattern because they allow you to define the communication pathways as a rigid state graph.

1# Conceptual LangGraph Supervisor Implementation2from langgraph.graph import StateGraph, END3import openai4
5def supervisor_node(state):6    """The Supervisor decides who should act next."""7    messages = state["messages"]8    9    prompt = f"""10    You are a Supervisor managing a Researcher and a Coder.11    Review the conversation so far.12    If the task is entirely complete, output "FINISH".13    If we need data, output "RESEARCHER".14    If we need code, output "CODER".15    """16    17    # ... call LLM ...18    decision = llm_output.strip()19    return {"next": decision}20
21def researcher_node(state):22    """Worker 1: Uses web tools"""23    print("-> Researcher is working...")24    # ... call LLM with search tools ...25    return {"messages": ["Researcher found the Q3 data: $100M"]}26
27def coder_node(state):28    """Worker 2: Uses code tools"""29    print("-> Coder is working...")30    # ... call LLM with python tools ...31    return {"messages": ["Coder wrote the script."]}32
33# --- Build the Graph ---34workflow = StateGraph(AgentState)35
36# Add the nodes (The Agents)37workflow.add_node("Supervisor", supervisor_node)38workflow.add_node("Researcher", researcher_node)39workflow.add_node("Coder", coder_node)40
41# Define the rigid hierarchy (Edges)42# Workers ALWAYS report back to the Supervisor. They never talk to each other.43workflow.add_edge("Researcher", "Supervisor") 44workflow.add_edge("Coder", "Supervisor")45
46# The Supervisor routes dynamically based on its decision47workflow.add_conditional_edges("Supervisor", lambda x: x["next"], {48    "RESEARCHER": "Researcher",49    "CODER": "Coder",50    "FINISH": END51})52
53# Set entry point54workflow.set_entry_point("Supervisor")55app = workflow.compile()

Watch Out For

Supervisor Bottleneck

Because every single message must pass through the Supervisor, you will be calling the Supervisor LLM very frequently. If you use an expensive, slow model (like GPT-4) for the Supervisor, your system will be slow and costly. Conversely, if you use a model that is too cheap (like GPT-4o-mini), it might lack the reasoning capabilities to accurately evaluate the workers' output, leading to terrible routing decisions. You must carefully balance the intelligence and cost of your Supervisor node.

The Quick Version

Peer-to-peer agent networks (Group Chats) are creative but chaotic and unreliable for production systems.
The Supervisor Pattern imposes a strict hierarchy.
A central Manager agent plans the workflow and routes tasks to specialized Worker agents.
Worker agents never communicate with each other; they only report their results back to the Manager.
This pattern is highly deterministic and prevents infinite looping and off-topic hallucinations.