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

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > LangGraph > LangGraph Multi-Agent Handoff

LangGraph Multi-Agent Handoff

Author: Venkata Sudhakar

Not every business task is best handled by a single AI agent. A customer complaint about a damaged product has three distinct phases: classify the complaint and gather key details (triage agent), apply the relevant policy and determine the remedy (specialist agent), then draft the customer response (resolution agent). Each agent is focused and expert in its phase. The handoff pattern means the output of each agent flows into the input of the next, with accumulated context growing at every step - each agent builds on what the previous one found.

In LangGraph, multi-agent handoff is just a graph where each node is a focused LLM call and the shared state carries the accumulated work forward. The triage agent adds complaint type and severity, the specialist adds the policy decision and remedy, and the resolution agent adds the final response draft. The state grows richer at each step without overwriting earlier work. This makes the pipeline transparent - you can inspect the state after each agent to understand exactly what happened and why.

The below example builds a three-agent complaint handling pipeline for an electronics retailer, turning a raw customer message into a polished, policy-compliant response draft in one automated run.

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

llm = ChatOpenAI(model="gpt-4o-mini", api_key="your-api-key", temperature=0.2)

class ComplaintState(TypedDict):
    customer_name:   str
    raw_complaint:   str
    complaint_type:  str   # DAMAGED_PRODUCT, WRONG_ITEM, etc.
    severity:        str   # LOW, MEDIUM, HIGH
    remedy:          str   # replacement, refund, voucher
    policy_decision: str
    response_draft:  str
    needs_human:     bool

# Agent 1: Triage - classify the complaint
def triage_agent(state: ComplaintState) -> dict:
    result = llm.invoke(
        "Classify this customer complaint. Use this exact format:\n"
        "TYPE: [DAMAGED_PRODUCT|WRONG_ITEM|LATE_DELIVERY|QUALITY_ISSUE|OTHER]\n"
        "SEVERITY: [LOW|MEDIUM|HIGH]\n\n"
        "Customer: " + state["customer_name"] + "\n"
        "Complaint: " + state["raw_complaint"]
    ).content
    lines = {l.split(":")[0].strip(): ":".join(l.split(":")[1:]).strip()
             for l in result.strip().split("\n") if ":" in l}
    print("Triage ->", lines.get("TYPE"), "|", lines.get("SEVERITY"))
    return {"complaint_type": lines.get("TYPE","OTHER"),
            "severity":       lines.get("SEVERITY","MEDIUM")}

# Agent 2: Specialist - apply policy and decide remedy
def specialist_agent(state: ComplaintState) -> dict:
    result = llm.invoke(
        "Apply this customer service policy and decide the remedy.\n"
        "POLICY:\n"
        "- DAMAGED_PRODUCT: full replacement, no questions within 30 days\n"
        "- WRONG_ITEM: replacement + Rs 200 goodwill voucher\n"
        "- LATE_DELIVERY: Rs 100 voucher if delay over 5 days\n"
        "- QUALITY_ISSUE: repair first, replace if repair fails\n"
        "- Severity HIGH: flag for human supervisor review\n\n"
        "Complaint type: " + state["complaint_type"] + "\n"
        "Severity: " + state["severity"] + "\n\n"
        "Reply format:\n"
        "REMEDY: <what to offer>\n"
        "REASON: <one sentence>\n"
        "ESCALATE: YES or NO"
    ).content
    lines = {l.split(":")[0].strip(): ":".join(l.split(":")[1:]).strip()
             for l in result.strip().split("\n") if ":" in l}
    escalate = lines.get("ESCALATE","NO").upper().startswith("YES")
    print("Specialist -> remedy:", lines.get("REMEDY"), "| escalate:", escalate)
    return {"remedy":          lines.get("REMEDY","goodwill gesture"),
            "policy_decision": lines.get("REASON",""),
            "needs_human":     escalate}

# Agent 3: Resolution - draft the customer reply
def resolution_agent(state: ComplaintState) -> dict:
    draft = llm.invoke(
        "Write a warm professional email reply to this customer complaint.\n"
        "Customer: " + state["customer_name"] + "\n"
        "Complaint: " + state["raw_complaint"] + "\n"
        "Remedy to offer: " + state["remedy"] + "\n"
        "Keep it under 100 words. Apologise sincerely, state the remedy clearly, "
        "end with clear next steps."
    ).content
    print("Resolution -> draft ready")
    return {"response_draft": draft}

Building the graph and running a real complaint through the pipeline,

graph = StateGraph(ComplaintState)
graph.add_node("triage",     triage_agent)
graph.add_node("specialist", specialist_agent)
graph.add_node("resolution", resolution_agent)
graph.set_entry_point("triage")
graph.add_edge("triage",     "specialist")
graph.add_edge("specialist", "resolution")
graph.add_edge("resolution", END)
app = graph.compile()

complaint = {
    "customer_name":   "Priya Sharma",
    "raw_complaint":   ("I ordered a Samsung TV (Order #88421) which arrived yesterday "
                        "with a cracked screen. The packaging looked fine from outside "
                        "so the damage must have happened during manufacturing or "
                        "shipping. This is completely unacceptable for a Rs 45,000 "
                        "purchase. I want this resolved immediately."),
    "complaint_type":  "", "severity": "", "remedy": "",
    "policy_decision": "", "response_draft": "", "needs_human": False
}

result = app.invoke(complaint)

print("\n=== PIPELINE RESULT ===")
print("Complaint type: ", result["complaint_type"])
print("Severity:       ", result["severity"])
print("Remedy:         ", result["remedy"])
print("Human review:   ", result["needs_human"])
print("\n=== RESPONSE DRAFT ===")
print(result["response_draft"])

It gives the following output,

Triage -> DAMAGED_PRODUCT | HIGH
Specialist -> remedy: Full replacement unit to be dispatched immediately | escalate: True
Resolution -> draft ready

=== PIPELINE RESULT ===
Complaint type:  DAMAGED_PRODUCT
Severity:        HIGH
Remedy:          Full replacement unit to be dispatched immediately
Human review:    True

=== RESPONSE DRAFT ===
Dear Priya,

We are sincerely sorry about the damaged Samsung TV you received - this is
not the experience we want for any customer, especially on a purchase of
this value. We are arranging an immediate full replacement unit for you.

A courier will contact you within 24 hours to collect the damaged TV and
deliver your replacement. Your case has also been flagged for senior review
to ensure this is handled with priority.

Thank you for your patience.
Warm regards, QuickElectronics Customer Care

# Three agents, each doing one focused job
# Full audit trail in state: type, severity, remedy, policy reason, draft
# needs_human=True triggers a supervisor notification in production

The multi-agent handoff pattern shines when a workflow has genuinely distinct expertise requirements at each step. Keep agents narrowly focused - a triage agent that also tries to write the response will be mediocre at both. Each agent should receive only the state fields it needs. In production, add a conditional edge after the specialist: if needs_human is True, route to a human review queue node instead of the resolution agent - the human writes the reply and the AI provides all the context. This gives you AI speed for routine cases and human judgment exactly where the complaint is serious enough to need it.

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