CrewAI Patterns

Conceptual Explanation

CrewAI's model has four concepts:

Agent: An LLM-powered entity with a defined role, goal, and backstory. The role and goal form the agent's system prompt; the backstory provides context that shapes its reasoning style. Agents are assigned tools they can use.

Task: A unit of work with a description of what to do, the expected output format, and the agent responsible for it. Tasks are the nodes of the workflow.

Tool: A callable function exposed to agents. CrewAI tools follow the same design principles as tools in any agent system: descriptive names, clear schemas, idempotent write operations.

Crew: The composition of agents and tasks, plus a process type that determines how they execute.

Core Architecture

text
Crew
├── Process: Sequential | Hierarchical
├── Agents
│   ├── Agent(role, goal, backstory, tools, llm)
│   └── Agent(...)
└── Tasks
    ├── Task(description, expected_output, agent)
    └── Task(description, expected_output, agent, context=[prior_task])

Process Types

Sequential: Tasks execute in order, each task's output automatically available to subsequent tasks as context. Simple, predictable, and appropriate when tasks have linear dependencies.

Hierarchical: A manager agent (auto-created or specified) receives the overall goal, decomposes it into subtasks, delegates them to worker agents, and synthesizes results. More flexible; the manager can reassign tasks based on interim results.

Architecture Diagram

Common Mistakes

No expected<em>output specification. Without specifying the expected output format, agents produce inconsistent output structures that break downstream tasks. Always specify the exact format in expected</em>output.

allow_delegation=True without oversight. When agents can delegate, they can create recursive delegation chains that are hard to trace and control. Disable delegation for worker agents in sequential processes; use hierarchical process instead when delegation is needed.

Manager agent using same model as workers. In hierarchical mode, the manager performs complex planning and coordination — it benefits from a frontier model. Workers perform focused tasks — they can often use smaller models effectively.

No memory for multi-session workflows. A crew with no memory configuration starts fresh on every run. For patient-specific workflows that span multiple interactions, configure long-term memory to persist relevant context.

Best Practices

  • Use sequential process for linear task workflows with clear dependencies; use hierarchical for adaptive workflows
  • Assign frontier models to agents requiring complex reasoning; use smaller models for focused tasks
  • Specify expected_output in detail for every task, especially those producing machine-parseable data
  • Disable allow_delegation for worker agents in sequential crews; it adds unpredictability
  • Apply the principle of least privilege to agent tool lists — only tools needed for the role
  • Test agent output format consistency across multiple runs before deploying to production

Alternatives

Framework Best For When to Prefer LangGraph Instead
CrewAI (Sequential) Linear role-based workflows; team emulation When you need complex conditional routing
CrewAI (Hierarchical) Adaptive task delegation; unknown task structure When you need typed state and checkpointing
LangGraph Production workflows requiring persistence, HITL, typed state When role-based config is sufficient
Custom orchestrator Maximum control; unusual topology When you want to reduce dependencies
AutoGen Conversational multi-agent patterns When agents need to debate/negotiate

Trade-offs

Dimension CrewAI Advantage CrewAI Cost
Configuration speed Declarative; fast to set up Less control than LangGraph
Role clarity Role/goal/backstory maps to human teams State management is implicit
Checkpointing Memory options available Less mature than LangGraph checkpointing
Conditional routing Hierarchical process provides some flexibility Not as expressive as LangGraph graph edges
Output validation expected_output guides agents Does not enforce format — validation is manual

Interview Questions

Q1: When would you choose CrewAI over LangGraph for an enterprise agentic workflow?

Category: Architecture Difficulty: Senior Role: AI Architect

Answer Framework:

The choice comes down to what the workflow's primary complexity is: role/task decomposition or graph/state complexity.

Choose CrewAI when: the workflow maps naturally to a team of specialized humans (researcher, analyst, writer); the task sequence is either linear or can be delegated by a manager agent; you need a working prototype quickly and the operational requirements (checkpointing, typed state, complex HITL) are not yet defined.

Choose LangGraph when: the workflow requires typed, persistent state that is shared across multiple nodes; HITL is required at specific points and resumption must be reliable; the workflow has complex conditional routing (different paths based on data, not just sequential delegation); you need fault-tolerant, resumable workflows in production with a PostgreSQL-backed checkpointer.

In practice, many teams prototype with CrewAI and migrate to LangGraph when they hit the operational requirements wall. A hybrid is also possible: use LangGraph as the outer state machine with CrewAI crews as sub-workflows at specific nodes.

Key Takeaways

  • CrewAI models agents as roles (role, goal, backstory) and workflows as task sequences — appropriate for team-emulation patterns
  • Sequential process executes tasks in order with automatic context passing; hierarchical process uses a manager agent for dynamic delegation
  • Assign frontier models to planning/reasoning agents; use smaller models for focused task agents
  • Always specify expected_output in detail; validate output format in calling code
  • CrewAI is faster to configure than LangGraph; LangGraph provides more control for complex state, routing, and HITL requirements
  • Tool authorization principles apply identically in CrewAI: each agent gets only tools appropriate to its role