Designing Multi-Agent Workflows, Systems, Handoffs, and Graphs with LangGraph and CrewAI

Introduction

Single-agent LLM systems are limited by perspective, task scope, and memory. Real world problems require role-based multi-agent collaboration.

In this article, you will learn how to:

• Orchestrate multi-agent systems using LangGraph
• Delegate tasks across CrewAI agents
• Pass memory, output, and control between agents
• Design workflows that are fault-tolerant and observable

---

Why Multi-Agent Design Matters

No single agent can:

• Research, decide, write, validate, and deploy
• Maintain context across roles
• Route decisions or escalate failures

Multi-agent systems solve this by using separation of concern and role-specific expertise. Architecturally, this is similar to service-oriented design.

---

LangGraph as the Execution Backbone

LangGraph provides deterministic, memory-aware graphs that connect agents into stateful workflows. Each agent is modeled as a node, and state is passed through edges.

Minimum Required Version

Use LangGraph v0.0.20 or newer to ensure full support for memory propagation and multi-agent graphs.

Reference: LangGraph Concepts

---

Agent Roles in a Coordinated System

Let us define three distinct agents:

1. Planner Agent — receives the task and breaks it into steps
2. Researcher Agent — runs tools like web search and document summarizers
3. Writer Agent — composes summaries or reports using LLMs

Each will live in a CrewAI definition but execute within a LangGraph context.

---

Role-Based Multi-Agent Workflow

All agents share a memory backend and communicate via LangGraph edges.

---

Example: LangGraph Multi-Agent Orchestration

from langgraph.graph import StateGraph
from agents import planner, researcher, writer

graph = StateGraph()
graph.add_node("plan", planner)
graph.add_node("research", researcher)
graph.add_node("write", writer)

graph.add_edge("plan", "research")
graph.add_edge("research", "write")

compiled = graph.compile()
compiled.invoke({"task": "Write a technical report on LLM security."})

---

CrewAI for Agent Role Management

CrewAI structures agents into collaborative crews with:

• Role definitions
• Shared goals
• Sequential or conditional task flow
• Integrated memory tools (LangMem compatible)

CrewAI Quick Example

from crewai import Crew, Agent, Task

planner = Agent(name="Planner", role="Decompose tasks")
researcher = Agent(name="Researcher", role="Find source material")
writer = Agent(name="Writer", role="Draft final content")

task1 = Task(agent=planner, description="Break down the user's request")
task2 = Task(agent=researcher, description="Research key topics", depends_on=[task1])
task3 = Task(agent=writer, description="Write final content", depends_on=[task2])

crew = Crew(agents=[planner, researcher, writer], tasks=[task1, task2, task3])
crew.kickoff()

Documentation: https://docs.crewai.com

---

Comparison Table: LangGraph vs CrewAI

Feature	LangGraph	CrewAI
Execution model	State graph with explicit edges	Task and role-based flows
Tool integration	Manual; pluggable nodes	Built-in via tool registry
Role specialization	Requires manual node configuration	Declarative agent definition
Memory sharing	Full support via graph state	Supported via agent memory layers
Ideal for	Complex orchestrations	Structured team workflows

---

Handoff Design Patterns

Multi-agent systems need reliable handoff mechanisms. LangGraph supports:

• Edge-based handoffs
• Memory context carry-over
• Result chaining between node outputs

CrewAI supports:

• Task dependency graphs
• Inter-agent variable passing
• Memory recall between agent runs

Example: Controlled Handoff in LangGraph

def planner(state):
    return {"step": "Research LLM attacks"}

def researcher(state):
    return {"findings": "Prompt injection, data poisoning, jailbreaking"}

def writer(state):
    return f"Security risks identified: {state['findings']}"

---

Engineering Considerations

Before deploying multi-agent systems, evaluate:

• How will you monitor each agent’s performance?
• Will agents operate sequentially or in parallel?
• Are your memory systems tenant-aware?
• What happens when one agent fails or produces invalid output?
• How do you log, audit, and replay agent decisions?

---

External References

• LangGraph Multi-Agent Guide: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
• CrewAI Quickstart: https://docs.crewai.com/quickstart
• LangMem Tools for Shared Memory: https://github.com/langchain-ai/langmem
• LangChain Memory Architecture: https://python.langchain.com/docs/modules/memory/

---

Conclusion

LangGraph and CrewAI allow engineers to move from tool-calling agents to collaborative, memory-aware teams. When you model agents as planners, researchers, validators, or writers, you can orchestrate pipelines that scale.

In the next article, we will cover infrastructure hardening, including:

• Retry logic
• Human-in-the-loop checkpoints
• Role-based access control
• Cost management
• Observability strategies