Orchestration Frameworks LangChain LangGraph and CrewAI

We already know the agent loop: the model receives context, decides whether to call a tool, the application runs that tool, the agent receives the result, and the loop repeats until the agent can answer. In this article we step one level outside that loop to examine the orchestration layer — the application code that keeps the loop running reliably. A framework packages common orchestration responsibilities so you don’t implement every piece from scratch. Your application still defines the workflow: which models and tools are available, the rules that control the steps, and how the application connects to other services. The framework handles the repeated work: state management, retries, pauses for human approval, logging, and recovery.

A dark-themed presentation slide titled "What runs the agent loop?" comparing two boxes: "What your app does" and "What a framework adds," connected by a large red arrow. The left box lists app duties like preparing inputs, running tool calls, keeping data, and handling errors; the right box describes orchestration and common loop/state code.

What orchestration covers

Preparing the next model input and running tool calls.
Carrying state forward between steps and persisting it for resumability.
Handling transient failures, retry logic, and human approvals.
Recording audit logs, execution traces, and results for observability and debugging.

Frameworks vary by how much control they take over the workflow. Below are three common design points you’ll encounter: LangChain, LangGraph, and CrewAI. These are representative examples — choose the one that best fits your workflow requirements. LangChain: pre-built agents and a common interface

Purpose: Fast path to a working agent; provides pre-built agent implementations and standardizes the model/tool interface.
When to use: You want minimal boilerplate and just need the built-in loop behavior.
What you supply: model selection, tools, and instructions; the agent manages the interaction and tool invocation.

Example (illustrative):

# install the library (example)
pip install -U langchain

# Example usage (illustrative)
from langchain import Agent, Tool, OpenAIModel

model = OpenAIModel(name="gpt-4o")
tools = [
    Tool(name="search", func=search_kb),
    Tool(name="run_api", func=call_service)
]

agent = Agent(model=model, tools=tools, instructions="You are a helpful assistant.")
result = agent.run("Find latest policy on X and summarize for me.")
print(result)

LangChain is a good fit when a single agent + a few tools solve the problem and you want to iterate quickly. If you need explicit branching, persistent checkpoints, or more deterministic control, consider a graph-based framework. LangGraph: explicit nodes, edges, and saved state

Purpose: Make workflow steps explicit by modeling each step as a node in a state graph.
When to use: Workflows require branching, recoverability, human pauses, or long-running stateful processes.
What you supply: explicit node functions, routing logic, and state model; the framework provides persistence and resumability.

Example (illustrative):

# install the library (example)
pip install -U langgraph

# Illustrative graph definition
from langgraph import StateGraph, InMemorySaver, START, END

g = StateGraph(TicketState)

g.add_node("triage", triage)
g.add_node("lookup", search_kb)
g.add_node("respond", draft_reply)

g.add_edge(START, "triage")
g.add_conditional_edges("triage", route)  # route decides next step(s)
g.add_edge("lookup", "respond")
g.add_edge("respond", END)

app = g.compile(checkpointer=InMemorySaver())

Each node is a discrete step (triage, lookup, respond). Edges represent transitions; conditional edges enable branching. Because state is persisted, runs can resume after failures and pause for approvals, making LangGraph suitable for workflows requiring visibility and recoverability. CrewAI: role-based agents and sequential processes

Purpose: Organize work around roles; group agents into crews and assign role-specific tasks with clear handoffs.
When to use: You have distinct agents that should act independently with explicit role responsibilities and backstories.
What you supply: agent roles, goals, backstories, and task definitions; the framework coordinates handoffs and task execution.

Example (illustrative):

# install the library (example)
pip install crewai

# Illustrative CrewAI usage
from crewai import Agent, Task, Crew, Process

triager = Agent(
    role="Ticket Triage Specialist",
    goal="Classify and route tickets",
    backstory="Veteran support lead who works with users"
)

engineer = Agent(
    role="Issue Resolver",
    goal="Investigate and resolve technical tickets",
    backstory="Experienced engineer who debugs system issues"
)

classify = Task(
    description="Triage ticket {id}",
    expected_output="Routed ticket",
    agent=triager
)

resolve = Task(
    description="Resolve ticket {id}",
    expected_output="Resolution summary",
    agent=engineer
)

crew = Crew(agents=[triager, engineer],
            tasks=[classify, resolve],
            process=Process.sequential)
crew.kickoff()

CrewAI is hierarchical by design: a coordinator assigns tasks and passes results among agents. It’s ideal when you want readable, role-based workflows and explicit handoffs, at the cost of more prompts and model calls.

A dark-themed slide titled "Three Frameworks, Different Levels of Control" that compares three tools — LangChain, LangGraph, and CrewAI — with bullet points about each model, what you write, strengths, and cautions. It’s a visual guide for choosing a framework based on how much control your workflow needs.

Quick comparison table

Framework	Control model	Best for	Install example
LangChain	High-level agent interface; framework owns loop	Quick iterations, simple tool sets, rapid prototyping	`pip install -U langchain`
LangGraph	Graph of nodes/edges with persisted state	Branching workflows, approvals, resumability	`pip install -U langgraph`
CrewAI	Role-based agents and sequential processes	Role handoffs, readable processes, multi-agent coordination	`pip install crewai`

How to choose

Start with the simplest solution that satisfies your workflow constraints.
If one model and a few tools are sufficient, keep orchestration in application code without a framework.
Choose LangChain-style frameworks for a fast, pre-built agent and fewer infrastructure concerns.
Pick a graph-based framework like LangGraph for explicit branching, saved progress, or multi-step approvals.
Use a role-based approach (CrewAI) when work should be divided among specialized agents with clear role handoffs.

A dark-themed slide titled "Choose the Simplest Option that Fits" that lists four workflow options (one model and a few tools; a prebuilt agent; branches/approvals; tasks divided among agents) with suggested frameworks like LangChain, LangGraph, and CrewAI. It also shows an "Also available" row with other tools such as n8n and Microsoft Agent Framework.

Practical rule of thumb

Only add a framework when it saves you work you would otherwise implement and maintain (persistence, retries, auditability, pauses).
Prefer frameworks that match your required guarantees: persistence, approval gates, observability, and operational simplicity.
Evolve from simple to structured: start small and adopt more structured orchestration as complexity grows.

Choose the simplest framework that provides the control and guarantees (e.g., persistence, approvals, auditability) your workflow requires. Start small and evolve to a more structured orchestration framework only when the benefits outweigh the additional coordination overhead.

Summary

Orchestration is the application layer that keeps the agent loop running reliably (model/tool calls, state, retries, approvals, logging).
LangChain, LangGraph, and CrewAI represent three orchestration design points: pre-built agent interface, graph/stateful workflows, and role-based multi-agent coordination.
Match the framework to your workflow’s branching, persistence, and role-hand-off needs to minimize complexity while maximizing reliability.

Links and references

LangChain course
LangGraph course
CrewAI course
For more on orchestration best practices, look for resources on state management, long-running workflows, and auditability in agent-based systems.

The Modern AI Stack: Introduction

Inside the Model

Choosing and Running Models

Prompts, Context, and RAG

AI Agents and Agentic AI

The Ecosystem: MCP, Frameworks, and Automation

AI Security Essentials

Putting It All Together

Orchestration Frameworks LangChain LangGraph and CrewAI

Watch Video