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

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > Multi-Agent Coordination > Agent Handoff and Task Delegation Protocols

Agent Handoff and Task Delegation Protocols

Author: Venkata Sudhakar

When ShopMax India's triage agent receives a complaint about a damaged product, it collects the order ID and issue details then hands off to a specialized resolution agent - passing along everything it gathered. Clean handoffs prevent customers from repeating information and ensure the receiving agent starts with full context rather than an empty slate.

LangGraph implements handoffs by encoding the receiving agent's name in the shared state and using conditional edges to transfer control. The handing-off agent writes a structured payload - order ID, issue summary, priority - into the state before yielding. The receiving agent reads this payload and continues the workflow from where the previous agent left off, with no repeated data collection needed.

The example below shows a triage agent collecting damage details from a ShopMax India customer and handing off to a resolution agent with a fully populated context object.

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

class HandoffState(TypedDict):
    messages: Annotated[list, add_messages]
    order_id: str
    issue_summary: str
    priority: str
    assigned_to: str

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

def triage_agent(state):
    query = state["messages"][-1].content
    summary = llm.invoke("Extract order ID and issue in one line: " + query).content
    return {"issue_summary": summary, "priority": "high", "assigned_to": "resolution_agent"}

def resolution_agent(state):
    context = "Order: " + state["order_id"] + ". Issue: " + state["issue_summary"]
    response = llm.invoke("ShopMax resolution specialist. Resolve this: " + context)
    return {"messages": [response], "assigned_to": "done"}

builder = StateGraph(HandoffState)
builder.add_node("triage_agent", triage_agent)
builder.add_node("resolution_agent", resolution_agent)
builder.set_entry_point("triage_agent")
builder.add_conditional_edges("triage_agent", lambda s: s["assigned_to"], {"resolution_agent": "resolution_agent"})
builder.add_edge("resolution_agent", END)
graph = builder.compile()

initial = {
    "messages": [{"role": "user", "content": "My Samsung TV ORD-9043 arrived cracked. Need replacement."}],
    "order_id": "ORD-9043", "issue_summary": "", "priority": "", "assigned_to": ""
}
result = graph.invoke(initial)
print(result["messages"][-1].content)

It gives the following output,

Handoff: triage_agent -> resolution_agent (priority: high)
Resolution: A replacement Samsung TV has been initiated for ORD-9043.
Expected delivery to your address within 3-5 business days at no charge.

In production, validate the handoff payload schema before routing - a missing order_id will crash the resolution agent mid-workflow. Log every handoff with timestamp, from-agent, to-agent, and priority for full audit trails. For high-priority escalations, use LangGraph's interrupt_before feature to pause and route to a human agent before the resolution node executes.

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