Comparisons / AutoGen vs CrewAI
AutoGen vs CrewAI: Which Agent Framework to Use?
AutoGen autogen by microsoft models agents as conversableagents that chat with each other. CrewAI crewai organizes work into agents, tasks, and crews. Here is how they compare — and what the same patterns look like in plain Python.
By the numbers
AutoGen
56.7k
8.5k
Python
CC-BY-4.0
2023-08-18
Microsoft Research
CrewAI
48.0k
6.5k
Python
MIT
2023-10-27
João Moura
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | AutoGen | CrewAI | Plain Python |
|---|---|---|---|
| Agent | ConversableAgent with system_message, llm_config | Agent(role, goal, backstory, tools, llm) | A function with a system prompt that POSTs to the LLM API |
| Tools | register_for_llm() and register_for_execution() | Tool registration with @tool decorator, custom Tool classes | A dict of callables + JSON schema descriptions |
| Conversation | Two-agent chat with initiate_chat(), message history | — | A messages array that grows with each turn |
| Multi-Agent | GroupChat with GroupChatManager, speaker selection | — | Multiple agent functions called in sequence on shared messages |
| Nested Chats | register_nested_chats() for sub-task handling | — | A task queue (BFS) — agent schedules follow-ups via a tool |
| Termination | is_termination_msg callback, max_consecutive_auto_reply | — | The while loop exits when no tool_calls or max_turns reached |
| Agent Loop | — | Internal to Agent execution, hidden from user | A while loop over messages with tool_calls check |
| Task Delegation | — | Crew(agents, tasks, process=sequential/hierarchical) | A task queue processed in a while loop with a budget cap |
| Memory | — | ShortTermMemory, LongTermMemory, EntityMemory | A dict injected into the system prompt |
| State | — | Task output passed between agents via Crew orchestration | A dict tracking tool calls and results |
What both do in plain Python
Every concept in the table above — agent, tools, loop, memory, state — maps to a handful of Python primitives: a function, a dict, a list, and a while loop. Both AutoGen and CrewAI wrap these primitives in their own class hierarchies and APIs. The underlying pattern is the same ~60 lines of code. The difference is how much ceremony each framework adds on top.
When to use AutoGen
AutoGen excels at complex multi-agent workflows where agents need to debate or collaborate. For single-agent use cases or simple tool-calling agents, the plain Python version is significantly simpler.
What AutoGen does
AutoGen's core abstraction is the ConversableAgent — an agent that can send and receive messages. Two agents chat by alternating turns on a shared message history. GroupChat extends this to N agents, with a GroupChatManager that selects the next speaker (round-robin, random, or LLM-based selection). Nested chats allow an agent to spin up a sub-conversation to handle a complex subtask before returning to the main thread. AutoGen also provides code execution sandboxes, letting agents write and run code as part of their conversation. The framework thinks in terms of conversations, not chains or graphs. This makes it natural for workflows where agents need to debate, critique, or iteratively refine outputs together.
The plain Python equivalent
A ConversableAgent is a function that takes a messages array, calls the LLM with a system prompt, and returns the assistant message. Two-agent chat is a while loop where you alternate between calling agent_a(messages) and agent_b(messages), appending each response. GroupChat is the same loop but with a speaker selection step — either rotate through a list or ask the LLM "who should speak next?" and call that agent function. Nested chats are a function call within the loop: pause the main conversation, run a sub-loop with different agents, and inject the result back. Tool registration is adding functions to a tools dict with their JSON schemas. The conversation-as-primitive model is just messages arrays passed between functions.
When to use CrewAI
CrewAI shines for multi-agent setups where you want named roles ("researcher", "writer"). But the core mechanics — tool dispatch, the agent loop, task scheduling — are the same patterns you can build in plain Python.
What CrewAI does
CrewAI models multi-agent systems as a crew of specialists. Each Agent has a role ("Senior Researcher"), a goal ("Find the best data sources"), a backstory that shapes its behavior, and a set of tools it can use. Tasks define discrete units of work with expected outputs. The Crew orchestrates execution — sequentially, hierarchically, or with a custom process. CrewAI also provides memory systems (short-term, long-term, entity) and delegation, where one agent can hand off subtasks to another. The mental model is a team of people collaborating on a project. For prototyping multi-agent workflows where you want to reason about roles and responsibilities, it provides a clean vocabulary.
The plain Python equivalent
An Agent in CrewAI is a function with a system prompt that includes the role, goal, and backstory. The tools dict maps names to callables. Task delegation is a list of tasks processed in order — each task calls the assigned agent function with the task description appended to the messages. Hierarchical execution is a manager agent that decides which sub-agent to call next (just another tool choice). Memory is a dict injected into the system prompt. The entire crew pattern — multiple agents, task queue, delegation — is a for-loop over tasks, where each iteration calls the right agent function. No Crew class, no process kwarg. Just functions calling functions with a shared state dict passed between them.
Or build your own in 60 lines
Both AutoGen and CrewAI implement the same 8 patterns. An agent is a function. Tools are a dict. The loop is a while loop. The whole thing composes in ~60 lines of Python.
No framework. No dependencies. No opinions. Just the code.
Build it from scratch →