Agent skill
langgraph-workflows
Expert guidance for designing LangGraph state machines and multi-agent workflows. Use when building workflows, connecting agents, or implementing complex control flow in LangConfig.
Install this agent skill to your Project
npx add-skill https://github.com/LangConfig/langconfig/tree/main/backend/skills/builtin/langgraph-workflows
SKILL.md
Instructions
You are an expert LangGraph architect helping users design and build workflows in LangConfig. LangGraph enables stateful, cyclic, multi-agent workflows with automatic state management.
LangGraph Core Concepts
Based on official LangGraph documentation:
StateGraph
A specialized graph that maintains and updates shared state throughout execution:
- Each node receives current state and returns updated state
- State is automatically passed between nodes
- Enables context-aware decision-making and persistent memory
Nodes
Represent processing steps in the workflow:
# Each node is a function that takes state and returns updates
def research_node(state: WorkflowState) -> dict:
# Process state
result = do_research(state["query"])
# Return state updates
return {"research_results": result}
Edges
Define transitions between nodes:
- Static edges: Fixed transitions (A → B)
- Conditional edges: Dynamic routing based on state
LangConfig Node Types
AGENT_NODE
Standard LLM agent that processes input and can use tools:
{
"id": "researcher",
"type": "AGENT_NODE",
"data": {
"agentType": "AGENT_NODE",
"name": "Research Agent",
"model": "claude-sonnet-4-5-20250929",
"system_prompt": "Research the given topic thoroughly.",
"native_tools": ["web_search", "web_fetch"],
"temperature": 0.5
}
}
CONDITIONAL_NODE
Routes workflow based on evaluated conditions:
{
"id": "router",
"type": "CONDITIONAL_NODE",
"data": {
"agentType": "CONDITIONAL_NODE",
"condition": "'error' in messages[-1].content.lower()",
"true_route": "error_handler",
"false_route": "continue_processing"
}
}
LOOP_NODE
Implements iteration with exit conditions:
{
"id": "refinement_loop",
"type": "LOOP_NODE",
"data": {
"agentType": "LOOP_NODE",
"max_iterations": 5,
"exit_condition": "'APPROVED' in messages[-1].content"
}
}
OUTPUT_NODE
Terminates workflow and formats final output:
{
"id": "output",
"type": "OUTPUT_NODE",
"data": {
"agentType": "OUTPUT_NODE",
"output_format": "markdown"
}
}
CHECKPOINT_NODE
Saves workflow state for resumption:
{
"id": "checkpoint",
"type": "CHECKPOINT_NODE",
"data": {
"agentType": "CHECKPOINT_NODE",
"checkpoint_name": "after_research"
}
}
APPROVAL_NODE
Human-in-the-loop checkpoint:
{
"id": "human_review",
"type": "APPROVAL_NODE",
"data": {
"agentType": "APPROVAL_NODE",
"approval_prompt": "Please review the generated content."
}
}
Workflow Patterns
1. Sequential Pipeline
Simple linear flow of agents:
START → Agent A → Agent B → Agent C → END
Use case: Content generation pipeline
- Research → Outline → Write → Edit
2. Conditional Branching
Route based on output:
START → Classifier → [Condition]
├── Route A → Handler A → END
└── Route B → Handler B → END
Use case: Intent classification
- Classify query → Route to appropriate specialist
3. Reflection/Critique Loop
Self-improvement cycle:
START → Generator → Critic → [Condition]
├── PASS → END
└── REVISE → Generator (loop)
Use case: Code review, content quality
- Generate → Critique → Revise until approved
4. Supervisor Pattern
Central coordinator managing specialists:
START → Supervisor → [Delegate]
├── Specialist A → Supervisor
├── Specialist B → Supervisor
└── Complete → END
Use case: Complex research tasks
- Supervisor assigns subtasks to specialists
5. Map-Reduce
Parallel processing with aggregation:
START → Splitter → [Parallel]
├── Worker A ─┐
├── Worker B ─┼→ Aggregator → END
└── Worker C ─┘
Use case: Document analysis
- Split document → Analyze sections → Combine insights
State Management
Workflow State Schema
class WorkflowState(TypedDict):
# Core identifiers
workflow_id: int
task_id: Optional[int]
# Message history (accumulates via reducer)
messages: Annotated[List[BaseMessage], operator.add]
# User input
query: str
# RAG context
context_documents: Optional[List[int]]
# Execution tracking
current_node: Optional[str]
step_history: Annotated[List[Dict], operator.add]
# Control flow
conditional_route: Optional[str]
loop_iterations: Optional[Dict[str, int]]
# Results
result: Optional[Dict[str, Any]]
error_message: Optional[str]
State Reducers
Automatically combine state updates:
# Messages accumulate (don't overwrite)
messages: Annotated[List[BaseMessage], operator.add]
# Step history accumulates
step_history: Annotated[List[Dict], operator.add]
Edge Configuration
Static Edge
Always routes to specified node:
{
"source": "researcher",
"target": "writer",
"type": "default"
}
Conditional Edge
Routes based on state:
{
"source": "classifier",
"target": "router",
"type": "conditional",
"data": {
"condition": "state['intent']",
"routes": {
"question": "qa_agent",
"task": "task_agent",
"default": "general_agent"
}
}
}
Best Practices
1. Keep Nodes Focused
Each node should do ONE thing well:
- ❌ "Research and write and edit"
- ✅ "Research" → "Write" → "Edit"
2. Use Checkpoints Strategically
Save state at expensive operations:
- After long LLM calls
- Before human approval
- At natural breakpoints
3. Handle Errors Gracefully
Add error handling paths:
Agent → [Error?]
├── No → Continue
└── Yes → Error Handler → Retry/Exit
4. Limit Loop Iterations
Always set max_iterations to prevent infinite loops:
{
"max_iterations": 5,
"exit_condition": "'DONE' in result"
}
5. Design for Observability
Include meaningful names and step history:
- Name nodes descriptively
- Log state transitions
- Track timing metrics
Debugging Workflows
Common Issues
-
Workflow hangs
- Check for missing edges
- Verify conditional logic
- Look for infinite loops
-
Wrong routing
- Debug condition expressions
- Check state values
- Verify edge labels match
-
State not updating
- Ensure nodes return dict updates
- Check reducer configuration
- Verify key names match
-
Memory issues
- Limit message history
- Checkpoint and clear old state
- Use streaming for large outputs
Examples
User asks: "Build a workflow for writing blog posts"
Response approach:
- Design pipeline: Research → Outline → Write → Edit → Review
- Add CONDITIONAL_NODE after Review (PASS/REVISE)
- Create loop back to Write if revision needed
- Set max_iterations to prevent infinite loops
- Add OUTPUT_NODE to format final post
- Configure each agent with appropriate tools
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
LangConfig/langconfig
python-testing
Expert guidance for writing Python tests with pytest and unittest. Use when writing tests, debugging test failures, or improving test coverage for Python projects.
LangConfig/langconfig
debugging
Expert guidance for debugging code, analyzing errors, and systematic problem-solving. Use when troubleshooting bugs, understanding error messages, or investigating unexpected behavior.
LangConfig/langconfig
mcp-builder
Comprehensive guide for creating Model Context Protocol (MCP) servers. Use when building MCP servers, integrating external APIs, or creating tool interfaces for LLMs.
LangConfig/langconfig
langconfig-builder
Complete guide for building agents and workflows in LangConfig. Use when users need help configuring nodes, connecting agents, setting up tools, or designing multi-agent systems within the LangConfig platform.
LangConfig/langconfig
code-review
Systematic code review guidance covering best practices, security, performance, and maintainability. Use when reviewing code, checking PRs, or analyzing code quality.
LangConfig/langconfig
langchain-agents
Expert guidance for building LangChain agents with proper tool binding, memory, and configuration. Use when creating agents, configuring models, or setting up tool integrations in LangConfig.
Didn't find tool you were looking for?