What are handoffs in langgraph

In multi-agent architectures, agents can be represented as graph nodes. Each agent node executes its step(s) and decides whether to finish execution or route to another agent, including potentially routing to itself (e.g., running in a loop). A common pattern in multi-agent interactions is handoffs, where one agent hands off control to another. Handoffs allow you to specify:

destination: target agent to navigate to (e.g., name of the node to go to)

payload: information to pass to that agent (e.g., state update)

To implement handoffs in LangGraph, agent nodes can return Command object that allows you to combine both control flow and state updates:

def agent(state) -> Command[Literal["agent", "another_agent"]]:

    # the condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.

    goto = get_next_agent(...)  # 'agent' / 'another_agent'

    return Command(

        # Specify which agent to call next

        goto=goto,

        # Update the graph state

        update={"my_state_key": "my_state_value"}

    )

In a more complex scenario where each agent node is itself a graph (i.e., a subgraph), a node in one of the agent subgraphs might want to navigate to a different agent. For example, if you have two agents, alice and bob (subgraph nodes in a parent graph), and alice needs to navigate to bob, you can set graph=Command.PARENT in the Command object:

def some_node_inside_alice(state):

    return Command(

        goto="bob",

        update={"my_state_key": "my_state_value"},

        # specify which graph to navigate to (defaults to the current graph)

        graph=Command.PARENT,

    )

Handoffs as tools

One of the most common agent types is a ReAct-style tool-calling agents. For those types of agents, a common pattern is wrapping a handoff in a tool call, e.g.:

def transfer_to_bob(state):

    """Transfer to bob."""

    return Command(

        goto="bob",

        update={"my_state_key": "my_state_value"},

        graph=Command.PARENT,

    )

This is a special case of updating the graph state from tools where, in addition to the state update, the control flow is included as well.

!!! important

If you want to use tools that return `Command`, you can either use prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:

```python

def call_tools(state):

    ...

    commands = [tools_by_name[tool_call["name"]].invoke(tool_call) for tool_call in tool_calls]

    return commands

```

references:

https://github.com/langchain-ai/langgraph/blob/main/docs/docs/concepts/multi_agent.md