Briefing
Multi-agent systems have a reputation for being fiddly. CrewAI pushes back on that. It's an open-source Python framework where getting agents to work together comes down to describing who each agent is and what job it needs to do. The API stays readable, which is a big part of why it's caught on with teams dipping a toe into multi-agent work.
Here's the plain version of why anyone outside engineering should care. For years, getting software "agents" to coordinate meant wiring up brittle plumbing by hand. CrewAI flips the work into something closer to staffing a small team: you write down the role, the goal, and the task, and the framework handles the back-and-forth. A research agent gathers facts, hands them to a writing agent, which drafts the copy. No glue code holding it all together.
For an Australian business, that lowers the bar to trying this out. You don't need a dedicated AI team to stand up a working pipeline. A developer who understands the work can describe it in a handful of lines of Python and have agents passing tasks to each other the same afternoon. The framework runs on whatever model you already use, including local ones, so you're not locked into a single vendor or sending data offshore if you'd rather not.
The catch worth naming up front: easy to start is not the same as easy to get right. The mental model below is genuinely simple, but the quality of the output still rests on how well you define each role and task. CrewAI removes the plumbing, not the thinking.
Roles, Tasks, and Processes
CrewAI's mental model is straightforward.
Agents have a role, a goal, a backstory, and tools (CrewAI docs, Crews). The backstory isn't decorative. It shapes how the agent approaches problems. A "sceptical security researcher" agent reads code very differently than an "optimistic product developer."
Tasks have a description, expected output, and assigned agent. They can run in sequence, where each one depends on the last, or in parallel when they're independent.
Crews are collections of agents and tasks with a defined process. The process sets the execution order: sequential, hierarchical, or consensus-based.
from crewai import Agent, Task, Crew
researcher = Agent(
role='Research Analyst',
goal='Find comprehensive information',
backstory='Expert at web research and synthesis',
tools=[search_tool]
)
writer = Agent(
role='Content Writer',
goal='Create engaging articles',
backstory='Skilled at turning research into prose'
)
task1 = Task(description='Research AI trends', agent=researcher)
task2 = Task(description='Write article', agent=writer)
crew = Crew(agents=[researcher, writer], tasks=[task1, task2])
result = crew.kickoff()The crew starts running when you call crew.kickoff() (CrewAI docs, Crews).
Process Types
Sequential: Tasks run in order, and each task's output feeds the next one as context (CrewAI docs, Processes). Good fit for linear workflows.
Hierarchical: A manager agent coordinates the workers, handing out tasks and checking their output before things move on (CrewAI docs, Processes). Good fit for bigger projects that need oversight.
Consensus: Several agents work the same task and have to agree on the result. This is the newest of the three and less battle-tested than sequential and hierarchical work it was added through a pull request to the project rather than shipping as a founding feature so treat it as the experimental option rather than a like-for-like peer. Suited to high-stakes decisions where a second opinion matters.
Tool Integration
CrewAI agents can use any tool that exposes a function interface. The built-in integrations cover most of what teams reach for (CrewAI docs, Tools):
- Web search: Serper, Exa, Tavily, and custom search providers
- Code execution: sandboxed Python execution (CrewAI docs, Code Interpreter)
- File operations: read, write, and manipulate files
- API calls: a generic HTTP client for any REST or GraphQL API
- Database queries: SQL execution against connected databases
Defining your own tool is no harder than writing a function. Any Python function with a docstring can become a tool, and the docstring is what tells the agent what the tool does.
Memory and Context
CrewAI ships with a memory system so agents can share what they know across tasks (CrewAI docs, Memory). Short-term memory holds recent interactions. Long-term memory keeps important facts. Entity memory tracks the people, places, and concepts that come up across conversations.
Memory matters more in multi-agent work than people expect. Without shared context, agents work blind to each other, each one solving its slice in isolation. CrewAI's memory means what one agent figures out is available to the rest of the crew.
Ecosystem and Integrations
CrewAI plugs into the wider AI tooling around it:
- LangChain: use LangChain tools and chains inside CrewAI agents (crewAIInc/crewAI on GitHub)
- Mem0: persistent memory across crew sessions (Mem0 docs, CrewAI integration)
- OpenAI/Anthropic: works with any LLM provider
- Local models: full support for Ollama and LM Studio
Use Cases
Research Teams: multi-agent research with separate search, analysis, and writing agents.
Content Creation: end-to-end pipelines that take a topic from research through editing and formatting.
Code Review: agents with different specialities checking code for security, performance, and style.
Customer Support: tiered support with triage, troubleshooting, and escalation agents.
The honest summary: CrewAI is one of the more approachable ways into multi-agent systems, and its readable API is a real part of that. Whether it stays a leading option will depend on how the project and its community hold up over time, but for a team that wants to try agent collaboration without a heavy lift, it's a sensible place to start.