Skip to content
BSWEN
Blog

How Fast Can I Build a Multi-Agent System with crewAI?

Cowrie
Cowrie
Dev @ Bswen

I needed to build a multi-agent system for a client project, and I had exactly one afternoon to deliver a working prototype. I’d heard about crewAI being fast to set up, but “under an hour” sounded like marketing hype. So I timed myself.

Verdict: It’s true. 47 minutes from zero to working multi-agent system.

The Problem That Started This

My client needed an automated research workflow:

  1. Take a topic as input
  2. Have one agent research the topic
  3. Have another agent write a summary
  4. Have a third agent review and refine

I could have built this with LangGraph, but the state management and graph definition felt overkill for a simple linear workflow. I just needed agents that talk to each other in sequence.

My First Attempt (The Wrong Way)

I started by reading the docs. Bad move—I got lost in the details of tools, memory, and knowledge systems before I even had a basic agent running.

After 20 minutes of reading, I had zero code written.

Then I found the scaffolding command.

The Right Way: One Command to Start

Terminal window
crewai create crew research_crew

This gave me a complete project structure:

research_crew/
├── src/
│   └── research_crew/
│       ├── config/
│       │   ├── agents.yaml
│       │   └── tasks.yaml
│       ├── crew.py
│       └── main.py
├── pyproject.toml
└── .env

The agents.yaml file had pre-defined placeholders. I just needed to fill in the blanks.

Defining Agents (5 Minutes)

The decorator-driven API is where crewAI shines. I opened agents.yaml:

researcher:
  role: >
    Senior Research Analyst
  goal: >
    Uncover cutting-edge developments in AI and data science
  backstory: >
    You're a seasoned researcher with a knack for uncovering the latest
    developments in AI and data science. Known for your ability to find the most relevant
    information and present it in a clear and concise manner.


writer:
  role: >
    Tech Content Strategist
  goal: >
    Craft compelling content on tech advancements
  backstory: >
    You are a renowned Content Strategist, known for your insightful and engaging articles.
    You transform complex concepts into compelling narratives.

That’s it. No complex class hierarchies, no state machine definitions. Just roles and goals.

Defining Tasks (5 Minutes)

The tasks.yaml file defines what agents actually do:

research_task:
  description: >
    Conduct a comprehensive analysis of the latest advancements in {topic}.
    Identify key trends and breakthrough technologies.
  expected_output: >
    A detailed report on the latest advancements in {topic}.
  agent: researcher


writing_task:
  description: >
    Using the insights provided, develop an engaging blog post
    that highlights the most significant advancements in {topic}.
  expected_output: >
    A compelling blog post formatted as markdown.
  agent: writer

The {topic} placeholder means I can pass different topics at runtime.

Running the Crew (2 Minutes)

In main.py, I just needed to kick off the crew:

from research_crew.crew import ResearchCrew


def run():
    inputs = {
        'topic': 'AI Agent Frameworks'
    }
    ResearchCrew().crew().kickoff(inputs=inputs)
Terminal window
python src/research_crew/main.py

And boom—two agents working together, researching and writing.

What Actually Happened (The Trial-and-Error Part)

The first run failed with:

Error: API key not found

I forgot to set OPENAI_API_KEY in .env. Fixed that.

Second run worked, but the output was too verbose. I adjusted the expected_output to be more specific: “A 500-word blog post formatted as markdown.”

Third run: perfect.

Why crewAI is Fast

┌─────────────────────────────────────────────────────────┐
│                  crewAI Setup Flow                       │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   crewai create crew ──► agents.yaml ──► tasks.yaml    │
│        (30 sec)            (5 min)         (5 min)     │
│                                                         │
│              │                                          │
│              ▼                                          │
│                                                         │
│        crew.kickoff() ──► Working Multi-Agent System   │
│           (2 min)              (47 min total)          │
│                                                         │
└─────────────────────────────────────────────────────────┘

Speed factors I observed:

  1. Scaffolding: One command generates the entire project structure
  2. YAML-based config: No code for defining agents and tasks
  3. Decorator-driven API: The Python code is minimal
  4. Readable docs: I could find what I needed without endless scrolling
  5. Discord community: My question about custom tools was answered in 8 minutes

When crewAI is the Right Choice

Use CasecrewAI?Better Alternative
Quick prototypingYes-
Learning multi-agent fundamentalsYes-
Simple linear workflowsYes-
Complex RAG with conditional routingNoLangGraph
Durable execution with state persistenceNoLangGraph
Autonomous code execution with self-debuggingNoAutoGen

When crewAI Falls Short

After my 47-minute success, I got ambitious. I tried to build a more complex system with:

  • Conditional agent routing (if research fails, try a different agent)
  • Persistent state across runs
  • Self-correcting code execution

That’s when crewAI’s simplicity became a limitation.

For conditional routing, I had to write custom Python logic that felt like fighting the framework. For state persistence, there was no built-in solution. For self-correcting code execution, I hit a wall.

Complexity Level
    │
    │         ┌─────────────────┐
    │         │  AutoGen/LangGraph │  ← Complex systems
    │         └─────────────────┘
    │
    │    ┌──────────────┐
    │    │   crewAI     │  ← Sweet spot
    │    └──────────────┘
    │
    │ ┌─────────┐
    │ │ Single  │  ← Just use ChatGPT
    │ │ Agent   │
    │ └─────────┘
    └────────────────────────────►

The Real-World Takeaway

crewAI’s claim of “under an hour” is real. But it comes with caveats:

  1. Fast setup = opinionated design: If your use case fits crewAI’s mental model, it’s incredibly fast. If not, you’ll fight the framework.

  2. Community speed matters: The Discord community responded in minutes, not days. That’s crucial when you’re learning a new framework.

  3. Documentation is actually readable: This shouldn’t be notable, but in AI tooling, it is. The docs are structured, have examples, and work.

  4. Know when to switch: For simple multi-agent workflows, crewAI is excellent. For complex state machines with conditional logic, use LangGraph.

If you’re choosing between frameworks, consider:

  • LangGraph: Best for complex workflows with cycles, state persistence, and conditional routing. Steeper learning curve but more power.
  • AutoGen: Best for autonomous code execution and self-debugging systems. Built by Microsoft for research use cases.
  • crewAI: Best for straightforward multi-agent coordination with fast setup. Great for prototyping and learning.

Summary

47 minutes. That’s how long it took me to go from “I need a multi-agent system” to “I have a working multi-agent system.”

The key was not overthinking it:

  1. crewai create crew <name> (don’t read docs first)
  2. Edit agents.yaml and tasks.yaml (no complex Python)
  3. Run crew.kickoff() (that’s it)

If your use case fits crewAI’s linear workflow model, it’s the fastest way to get multi-agent systems running. If you need more complexity, you’ll know within the first hour.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: