Contrast CrewAI's sequential process with its hierarchical process

Flashcard·Easy·4.0 · 0·~30s·Asked atCoreweave Glean Hcl

Attempt it

Sequential runs the tasks in the order you list them, hands each task to its designated agent, and threads the output of task N into the context of task N+1. No routing decisions, no LLM as router cost. Right pick when the workflow is a known pipeline: research, then outline, then draft, then edit.

Hierarchical introduces a manager agent (configured via manager_llm) that reads each task plus the current crew state and decides which agent should handle it. Right pick when task assignment is genuinely content-dependent or when tasks can be re-ordered. Hierarchical pays one manager LLM call per task assignment, which is fine for short crews and expensive for long ones. The CrewAI default for tutorials is sequential; teams move to hierarchical when sequential's fixed order stops fitting the work.

Your answer

CrewAI ships two **process modes** that decide who picks the next task for a crew of agents. **Sequential** runs tasks in the order you list them. Task 1 goes to agent A; the output threads into task 2 which goes to agent B; and so on. There is no router and no LLM picking what runs next. The benefit is simplicity, low cost, and a predictable trace. The trade-off is that the order is fixed; if task 3 should run before task 2 in some cases, sequential cannot handle it. **Hierarchical** introduces a **manager agent** (configured via the `manager_llm` parameter). The manager reads each task plus the current crew state and picks which agent should handle it. Tasks can be reassigned, re-ordered, or skipped based on what the manager decides. The cost is one extra LLM call per task assignment, which adds latency and tokens. The CrewAI tutorial default is sequential because most tutorial workflows are pipelines (research, then outline, then draft, then edit). Teams move to hierarchical when sequential's fixed order stops fitting the work, usually when task assignment is genuinely content-dependent.

**Sequential** and **hierarchical** are CrewAI's two process modes; they differ in who decides which task runs next. In **sequential**, you list tasks in order, each task is bound to a specific agent at definition time, and the runtime threads the output of task N into the context of task N+1. No routing, no LLM as router cost. Right pick when the workflow is a known pipeline: research, then outline, then draft, then edit. Cost is just the sum of worker LLM calls; trace is linear and easy to debug. In **hierarchical**, you supply a `manager_llm` parameter and CrewAI spins up a manager agent that reads each task plus the current crew state and decides which agent should handle it. Tasks can be reassigned dynamically. Right pick when task assignment is genuinely content-dependent (a triage flow where the first agent's output determines the next agent) or when tasks can re-order based on results. **The cost difference matters**. Hierarchical pays one manager LLM call per task assignment plus the worker call. For a 3-task crew that is 6 calls instead of 3. For a 10-task crew, 20 instead of 10. At scale and with a flagship manager model, that is real money. The CrewAI default for tutorials is sequential. Teams typically start sequential and move to hierarchical only when the fixed-order limitation hurts evals. The reverse migration (hierarchical to sequential after realising the manager is not earning its keep) is also common.

TL;DR

Sequential runs tasks in a fixed order with no router; hierarchical uses a manager LLM to pick the next agent per task at the cost of one extra call per assignment.

Memory aid

Easy to grasp

Imagine a kitchen with two ways to run a dinner service. In the first way, you write the menu order on a board: starter, main, dessert. Each cook picks up their dish when its turn comes. No supervisor, no decisions. In the second way, you hire a head chef who reads each order, looks at what each cook is doing, and tells them what to make next. The head chef is smart and flexible, but you pay their salary on every dish. The first way is sequential. The second way is hierarchical. Pick the head chef only when the order genuinely needs deciding, not when the menu is the same every night.

Key concepts

Multi-Agent Systems

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

CrewAI exposes two top-level process modes that govern how a crew runs through its task list: Process.sequential and Process.hierarchical. These are not minor configuration switches; they pick the entire coordination model of the crew. Sequential is a static execution order with no router. Hierarchical introduces a manager agent that LLM-routes every task assignment. The cost and latency profiles are materially different.

This walkthrough covers what each mode actually does on a CrewAI run, how the cost and latency math works out, when each is the right pick, and the production patterns that teams adopt once they have flown both modes in production.

Mental model: sequential is a pipeline. Hierarchical is a supervisor topology with the manager paid in LLM calls. The choice is mostly about whether the routing decision is real or imagined.

What sequential actually does on a run

Definition-time binding

In sequential mode, you define tasks in a list and each task is bound to a specific agent at definition time:

python

research_task = Task(description='Research X', agent=researcher)
write_task = Task(description='Write up findings', agent=writer)
crew = Crew(tasks=[research_task, write_task], process=Process.sequential)

Runtime execution

The runtime walks the task list in order. For task N:

Builds the prompt by combining the task description, agent context, and the output of task N-1 (threaded forward).
Calls the bound agent's LLM.
Stores the output as context for task N+1.

No router. No assignment decision. No manager.

Cost and latency

Cost: sum of worker LLM tokens. Nothing else.
Latency: sum of worker call latencies, since tasks run serially.
Trace: linear, one span per task. Easy to read and debug.

What sequential cannot do

The task order is fixed at definition time. If task 3 should depend on task 2's output in a content-dependent way (different agent depending on what task 2 returned), sequential cannot express it. You bail out to plain Python (write a function that picks the next task and calls the crew with a different list) or you switch to hierarchical.

When sequential is the right pick

Workflow is a known pipeline (research, outline, draft, edit).
Task order is fixed and content-independent.
Cost or latency budget is tight.
You want maximum debuggability.

What hierarchical adds and what it costs

The choice in practice

Reverse migration and broader landscape

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

CrewAI's official tutorials (research crew, content crew) use sequential by default; hierarchical appears only in the advanced docs.
Customer-support triage crews use hierarchical because the next agent depends on whether the issue is billing, technical, or escalation.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you decide whether a hierarchical crew's manager is earning its cost?

Compute manager-token share of total tokens per task. If over 50%, the router is dominating. Also count manager iterations per task; over 3-4 means the router is thrashing. Compare end to end success rate to a sequential baseline on the same tasks.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Defaulting to hierarchical because it sounds more sophisticated. Sequential is faster, cheaper, and easier to debug whenever the workflow is a known pipeline.

60 second bullets to scan on the way to the call.

Who decides task assignment in sequential versus hierarchical
The role of the manager_llm parameter

Primary sources. Browse if you want the original framing.