How do you design a multi-agent system where one agent's tool is actually another agent (agent-as-tool pattern)?

Question

Accepted Answer

LangGraph's Subagents pattern allows you to wrap a complete agent (with its own tools and logic) as a tool that the supervisor agent can invoke[citation:1][citation:7]. This enables hierarchical multi-agent systems where specialized sub-agents handle specific domains (e.g., stock agent, weather agent), and the main supervisor decides which sub-agent to invoke based on the user's request. Subagents can execute in parallel using `Send` for fan-out operations, and results are combined in the supervisor's state. ```python
from langgraph.graph import StateGraph, MessagesState, Send
from langgraph.prebuilt import ToolNode, create_react_agent
from langchain_core.tools import tool

# Step 1: Create specialized sub-agents
stock_tools = [get_stock_quote, get_stock_history]
stock_agent = create_react_agent(
    model="openai:gpt-4o-mini",
    tools=stock_tools,
    prompt="You answer stock market questions only.",
    name="stock_agent"
)

weather_agent = create_react_agent(
    model="openai:gpt-4o-mini",
    tools=[get_weather],
    prompt="You answer weather questions only.",
    name="weather_agent"
)

# Step 2: Create handoff tools for the supervisor
def make_handoff_tool(agent_name: str, agent_graph):
    @tool(name=f"transfer_to_{agent_name}", description=f"Send task to {agent_name}")
    def handoff(state: AppState, tool_call_id: str) -> Command:
        tool_msg = ToolMessage(
            content=f"Transferred to {agent_name}",
            tool_call_id=tool_call_id,
            name=f"transfer_to_{agent_name}"
        )
        return Command(
            goto=[Send(agent_name, {**state, "messages": state["messages"] + [tool_msg]})],
            graph=Command.PARENT
        )
    return handoff

# Step 3: Build supervisor with handoff tools
supervisor = create_react_agent(
    model="openai:gpt-4o-mini",
    tools=[make_handoff_tool("stock_agent", stock_agent),
           make_handoff_tool("weather_agent", weather_agent)],
    prompt="Route tasks to specialists. Use transfer_to_stock_agent for stocks."
)

# Step 4: Fan-out multiple sub-agents in parallel for complex queries
class AppState(MessagesState):
    results: dict
    targets: list

def plan_tasks(state: AppState):
    return {"targets": ["stock_agent", "weather_agent"]}

def fan_out(state: AppState):
    return [Send(target, state) for target in state["targets"]]

# Build graph with parallel execution
graph = StateGraph(AppState)
graph.add_node("plan", plan_tasks)
graph.add_node("fan_out", fan_out)
graph.add_node("stock_agent", stock_agent)
graph.add_node("weather_agent", weather_agent)
# Fan-out runs both sub-agents concurrently
```

How do you design a multi-agent system where one agent's tool is actually another agent (agent-as-tool pattern)?

Design an agent-as-tool system using LangGraph's Subagents pattern, where you wrap a child agent as a tool that the main agent can call, enabling hierarchical composition, parallel execution, and clear separation of responsibilities.

How do you design a multi-agent system where one agent's tool is actually another agent (agent-as-tool pattern)?

Design an agent-as-tool system using LangGraph's Subagents pattern, where you wrap a child agent as a tool that the main agent can call, enabling hierarchical composition, parallel execution, and clear separation of responsibilities.

Scenario Questions

Follow-up Questions