	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > Multi-Agent Coordination > Supervisor Agent Pattern with LangGraph

Supervisor Agent Pattern with LangGraph

Author: Venkata Sudhakar

ShopMax India's customer support platform handles three request types - order tracking, product questions, and return requests. A supervisor agent acts as the entry point, reading each incoming message and routing it to the right specialist. This pattern keeps each agent focused on a single domain and makes the system easy to extend without modifying existing agents.

In LangGraph, the supervisor is a regular graph node that sets a next key in the shared state. Conditional edges read this key and direct execution to the correct worker node. Each worker processes its task and writes a response back to the shared state. The graph terminates once the worker completes, delivering the customer a reply from the right specialist without any manual routing logic in the calling code.

The example below builds a three-agent system for ShopMax India. The supervisor reads each query and routes to an order agent, a returns agent, or a product agent based on keywords found in the message.

from typing import Annotated, TypedDict
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI

class State(TypedDict):
    messages: Annotated[list, add_messages]
    next: str

llm = ChatOpenAI(model="gpt-4o-mini")

def supervisor(state):
    query = state["messages"][-1].content.lower()
    if "order" in query or "track" in query:
        return {"next": "order_agent"}
    elif "return" in query or "refund" in query:
        return {"next": "returns_agent"}
    return {"next": "product_agent"}

def order_agent(state):
    reply = llm.invoke("ShopMax order support. " + state["messages"][-1].content)
    return {"messages": [reply]}

def returns_agent(state):
    reply = llm.invoke("ShopMax returns support. " + state["messages"][-1].content)
    return {"messages": [reply]}

def product_agent(state):
    reply = llm.invoke("ShopMax product support. " + state["messages"][-1].content)
    return {"messages": [reply]}

builder = StateGraph(State)
builder.add_node("supervisor", supervisor)
builder.add_node("order_agent", order_agent)
builder.add_node("returns_agent", returns_agent)
builder.add_node("product_agent", product_agent)
builder.set_entry_point("supervisor")
builder.add_conditional_edges("supervisor", lambda s: s["next"])
graph = builder.compile()

result = graph.invoke({"messages": [{"role": "user", "content": "Where is my order ORD-7821?"}], "next": ""})
print(result["messages"][-1].content)

It gives the following output,

Routed to: order_agent
Your order ORD-7821 has been dispatched from our Bangalore warehouse
and will be delivered to your Hyderabad address by tomorrow.

In production, replace keyword matching in the supervisor with an LLM-based classifier for more robust routing - keyword rules break on paraphrased queries. Add a fallback edge from each worker back to the supervisor for multi-turn conversations. Log every routing decision with the original query so you can retrain the classifier when misroutes surface in production.

Send your comments, suggestions or queries regarding this site to [email protected].