Ask one model to research a topic, write the Python to analyse it, run that code, and then grade its own output, and you get something mediocre. Ask four models with separate jobs and a shared conversation, and quality jumps, mostly because the critic can see the analyst’s mistakes written down. That gap is the whole premise behind AutoGen.
Microsoft Research released it in 2023 and it has since become one of the most-starred multi-agent frameworks on GitHub. Version 0.4, shipped in January 2025, rebuilt the core around an event-driven actor model and split the project into three layers: Core, AgentChat, and Extensions. If you’re sizing up AutoGen AI agents for real work, understanding those layers matters more than the launch blog posts did.
What AutoGen actually gives you
AutoGen is a framework, not a product. It’s a set of Python classes for defining agents that exchange messages until some condition tells them to stop. You set up the participants, give each one a system prompt and a list of permitted tools, then hand the group a task.
A research setup that works well looks roughly like this:
- An AssistantAgent on GPT-4o or Claude that plans and drafts.
- A second assistant with a narrower, more sceptical prompt that reviews the plan and names weak reasoning.
- A UserProxyAgent standing in for you, approving steps and passing messages along.
- A code executor, either Docker or a local subprocess, where generated Python actually runs.
None of that is magic. The framework’s real contribution is plumbing: message routing, turn-taking, termination conditions, and a clean handoff to tools. The “auto” in the name refers to automating conversation between agents, not to automating your judgement.
How AutoGen AI agents hand work to each other
Almost everything in AutoGen comes down to which agent speaks next. There are three patterns worth knowing before you write a line of code.
Two agents, back and forth
The simplest arrangement is a pair: a writer and a reviewer, or an assistant and a proxy that runs its code. Each replies to the last message. This is where most people should start, because you can read the entire transcript in under a minute and see exactly where things went sideways.
Group chats and speaker selection
GroupChat puts three or more agents in one conversation and picks who talks next. You can force round-robin order, let a model choose the speaker based on the conversation so far, or supply your own selector function that reads a shared state flag. The auto selector is clever and unpredictable in equal measure; on long tasks it tends to let the loudest agent dominate. Round-robin with a fixed cap on turns is duller and far easier to debug.
Sequential and nested chats
Bigger systems nest one conversation inside another. A manager agent runs a high-level dialogue and delegates chunks of work to sub-teams, each with its own tiny chat and its own termination rule. This is how you keep a 40-step task from turning into one enormous context window where nobody remembers the original brief.
If you want to see the pieces assembled rather than described, this AutoGen step-by-step build of a multi-agent research assistant walks through it from an empty file to a working team.
Code execution is the headline act, and the biggest risk
The feature people get excited about is that AutoGen agents can write code and immediately run it. The gap between “the model wrote Python” and “the Python ran and returned a number” is where most agent demos quietly collapse, and AutoGen closes it properly with DockerCommandLineCodeExecutor and its siblings.
Treat that capability with respect. You are handing a language model a shell in a container. Good practice is unglamorous: no network access inside the executor, a fresh container per session, pinned base images, read-only mounts for anything you can’t afford to lose, and a human approval step before any command that touches the outside world. A cheaper model with loose file permissions can delete a working directory in about four seconds.
The cost and debugging reality that demos skip
Four agents having eight turns each is 32 model calls for a task you might have solved with three. That multiplier is the price of the quality gain, and it shows up on your invoice. A group chat running GPT-4o across a hundred documents will comfortably cost more than a single well-prompted call doing the same job badly. Sometimes the trade is worth it. Often it isn’t.
Two habits keep the bill and the frustration in check:
- Always set an explicit termination condition. MaxMessageTermination and TextMentionTermination combined will stop a loop where two agents politely thank each other forever.
- Log every message with the sender, token count, and timestamp. When a run produces nonsense, the transcript tells you whether the planner failed or the critic approved something it shouldn’t have.
Self-hosting helps on cost but shifts the burden elsewhere. The trade-offs between managed and local models are covered well in this look at open source AI agents, what they cost, and where they break, and the failure modes are similar.
Where AutoGen sits next to LangGraph and CrewAI
AutoGen optimises for conversation. LangGraph optimises for explicit state machines, where each node and edge is something you defined, which makes production auditing considerably easier. CrewAI leans on role-play and gets a working prototype fast, with less granular control over who speaks when.
The choice usually comes down to how much determinism your problem tolerates. Research summaries, report drafting, and exploratory data analysis all suit AutoGen’s looser conversational style. Anything touching money or customer records probably wants the graph. A broader look at how these frameworks differ is worth reading in this AI agent platform comparison, especially the parts about observability and failure recovery, which is also the thread running through this piece on why the best AI agent platforms are the ones that survive your actual systems.
Wiring in real tools without maintaining sixty integrations
AutoGen makes it easy to register a Python function as a tool. It does not make it easy to handle OAuth flows, token refresh, pagination, and rate limits for every service your agents need to touch. That maintenance load quietly becomes the project.
One practical route is an integration layer that handles auth and normalises API responses so your agents just call a named action. Composio is one option for giving AI agents real tools without the integration headache, and the pattern applies whichever framework you pick. The point is to keep credentials and retry logic out of your agent prompts.
A first project that won’t burn two weeks
Pick something with a measurable output, not “build me a general assistant”. A weekly competitor digest, a script that reconciles two CSVs and flags mismatches, or a review of pull request diffs against a style guide all work because you can tell instantly whether the result is right.
Start with two agents and a hard turn limit of six. Run it on ten real inputs and read every transcript. You will usually find that the assistant is fine and the critic is the weak link, approving sloppy work because its prompt is too vague. Fix the critic before adding a third agent. Add a planner only once the two-agent version produces output you’d actually send to a colleague.
Keep the code executor isolated from day one, set a monthly spend cap on your API key, and resist the temptation to expand the team until the small version earns it. AutoGen rewards that kind of patience. It punishes anyone who builds a five-agent orchestra on day one and then tries to work out which violin is out of tune.