跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
设计与 UI

langgraph-agent-patterns

Implement multi-agent coordination patterns (supervisor-subagent, router, orchestrator-worker, handoffs) for LangGraph applications. Use when users want to (1) implement multi-agent systems, (2) coordinate multiple specialized agents, (3) choose between coordination patterns, (4) set up supervisor-subagent workflows, (5) implement router-based agent selection, (6) create parallel orchestrator-worker patterns, (7) implement agent handoffs, (8) design state schemas for multi-agent systems, or (9) debug multi-agent coordination issues.

soba-labs · 已有 AI 审核记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add soba-labs/langchain-agent-skills --skill langgraph-agent-patterns

技能说明


name: langgraph-agent-patterns description: Implement multi-agent coordination patterns (supervisor-subagent, router, orchestrator-worker, handoffs) for LangGraph applications. Use when users want to (1) implement multi-agent systems, (2) coordinate multiple specialized agents, (3) choose between coordination patterns, (4) set up supervisor-subagent workflows, (5) implement router-based agent selection, (6) create parallel orchestrator-worker patterns, (7) implement agent handoffs, (8) design state schemas for multi-agent systems, or (9) debug multi-agent coordination issues.

LangGraph Agent Patterns

Implement and configure multi-agent coordination patterns for LangGraph applications.

Pattern Selection

Choose the right pattern based on your coordination needs:

PatternBest ForWhen to Use
SupervisorComplex workflows, dynamic routingAgents need to collaborate, routing is context-dependent
RouterSimple categorization, independent tasksOne-time routing, deterministic decisions
Orchestrator-WorkerParallel execution, high throughputIndependent subtasks, results need aggregation
HandoffsSequential workflows, context preservationClear sequence, each agent builds on previous

Quick Decision:

  • Dynamic routing needed? → Supervisor
  • Tasks can run in parallel? → Orchestrator-Worker
  • Simple categorization? → Router
  • Linear sequence? → Handoffs

For detailed comparison: See references/pattern-comparison.md

Pattern Implementation Guides

Supervisor-Subagent Pattern

Overview: Central coordinator delegates to specialized subagents based on context.

Quick Start:

# Generate supervisor graph boilerplate
uv run scripts/generate_supervisor_graph.py my-team \
  --subagents "researcher,writer,reviewer"

# TypeScript
uv run scripts/generate_supervisor_graph.py my-team \
  --subagents "researcher,writer,reviewer" \
  --typescript

Key Components:

  1. State with routing: next field for routing decisions
  2. Supervisor node: Makes routing decisions based on context
  3. Subagent nodes: Specialized agents with distinct capabilities
  4. Conditional edges: Route from supervisor to subagents

Example Flow:

User Request → Supervisor → Researcher → Supervisor → Writer → Supervisor → FINISH

For complete implementation: See references/supervisor-subagent.md

Router Pattern

Overview: One-time routing to specialized agents based on initial request.

Key Components:

  1. State with route: Single routing decision field
  2. Router node: Categorizes request (keyword, LLM, or semantic)
  3. Specialized agents: Independent agents for each category
  4. Conditional routing: Route to agent, then END

Example Flow:

User Request → Router → Sales Agent → END
                   ├→ Support Agent → END
                   └→ Billing Agent → END

Routing Strategies:

  • Keyword-based: Fast, simple string matching
  • LLM-based: Semantic understanding, flexible
  • Embedding-based: Similarity matching
  • Model-based: Fine-tuned classifier

For complete implementation: See references/router-pattern.md

Orchestrator-Worker Pattern

Overview: Decompose task into parallel subtasks, aggregate results.

Key Components:

  1. State with subtasks: Task decomposition and results accumulation
  2. Orchestrator node: Splits task into independent subtasks
  3. Worker nodes: Process subtasks in parallel
  4. Aggregator node: Synthesizes results
  5. Send fan-out: Return Send(...) objects from conditional edges and use a list reducer (for example Annotated[list[dict], operator.add]) so worker outputs accumulate

Example Flow:

Task → Orchestrator → Worker 1 ┐
                  → Worker 2  ├→ Aggregator → Result
                  → Worker 3 ┘

Best Practices:

  • Ensure subtasks are independent
  • Handle worker failures gracefully
  • Limit concurrent workers for resource management
  • Use LLM for result synthesis

For complete implementation: See references/orchestrator-worker.md

Handoffs Pattern

Overview: Sequential agent handoffs with context preservation.

Key Components:

  1. State with context: Shared context across handoffs
  2. Agent nodes: Each agent hands off to next
  3. Handoff logic: Explicit or conditional handoffs
  4. Context management: Preserve and pass information

Example Flow:

Request → Researcher → Writer → Editor → FINISH
         (with context preservation)

Handoff Strategies:

  • Explicit: Agent declares next agent
  • Conditional: Based on completion criteria
  • Circular: Agents can hand back for revisions

For complete implementation: See references/handoffs.md

Examples

Runnable mini-projects (Python + JavaScript):

  • assets/examples/supervisor-example/
  • assets/examples/router-example/
  • assets/examples/orchestrator-example/
  • assets/examples/handoff-example/

State Design for Multi-Agent Patterns

Each pattern requires specific state schema design:

Supervisor Pattern:

class SupervisorState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]
    next: Literal["agent1", "agent2", "FINISH"]
    current_agent: str

Router Pattern:

class RouterState(TypedDict):
    messages: list[BaseMessage]
    route: Literal["category1", "category2"]

Orchestrator-Worker:

import operator
class OrchestratorState(TypedDict):
    task: str
    subtasks: list[dict]
    results: Annotated[list[dict], operator.add]

Handoffs:

class HandoffState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]
    next_agent: str
    context: dict

For detailed state patterns: See references/state-management-patterns.md

Validation and Visualization

Validate Graph Structure

# Validate 
阅读完整来源 ↗