AutoGen: Microsoft's agent orchestration toolkit.

Briefing

Microsoft built one of the first serious answers to a question every team building with AI eventually hits: what happens when one chatbot isn't enough, and you need several of them working together?

That answer is AutoGen, an open-source framework out of Microsoft Research for building applications where multiple conversational agents talk to each other, hand off work, and pull a human in when the job calls for it (Microsoft Research). Picture a coder agent that writes a script and a reviewer agent that checks it, or a manager agent farming tasks out to a team of workers. AutoGen gives you the plumbing for that.

It landed early, and that matters. As one of the first multi-agent frameworks to come out of a major tech company, it reportedly helped set the terms for how a lot of people now think about agent orchestration. For an Australian business team weighing up whether to wire several AI agents together, it's worth understanding what AutoGen does well and where the ground has shifted under it.

One thing to know up front: as of 1 October 2025, Microsoft folded AutoGen and Semantic Kernel into a new Microsoft Agent Framework (public preview), which is now the recommended path for production work. The concepts below still hold, but if you're starting fresh today, check where Microsoft is pointing people before you commit.

Conversational Agents as Core Primitives

AutoGen's basic unit is the conversational agent. Each one can:

• Send and receive messages
• Generate responses using LLMs
• Execute code in sandboxed environments
• Call tools and APIs
• Request human input when needed

The interesting part is how the agents interact. A conversation can be:

• Two-agent: a simple back-and-forth, like coder and reviewer
• Group chat: several agents debating and building consensus
• Hierarchical: manager agents handing work down to worker agents
• Custom: any topology you can define with conversation patterns

Code Execution Built-In

AutoGen's standout feature is built-in code execution. The agents don't stop at writing code, they run it, read the output, and try again (AutoGen docs). This runs in Docker containers for isolation, though the exact execution backend and how dependencies get handled depends on your version and config.

from autogen import AssistantAgent, UserProxyAgent

assistant = AssistantAgent("coder", llm_config={"config_list": [...]})
user_proxy = UserProxyAgent("user", code_execution_config={"work_dir": "coding"})

user_proxy.initiate_chat(
    assistant,
    message="Write a Python script that plots the Fibonacci sequence"
)
# The assistant writes code, the proxy executes it, they iterate

That run-and-iterate loop is why AutoGen suits data analysis, scientific computing, and software work, where the actual deliverable is code.

Human-in-the-Loop

AutoGen keeps the human in the picture instead of designing them out. Agents can:

• Ask for clarification when the requirements are vague
• Request approval before running anything sensitive
• Present options when there's more than one sensible path
• Learn from feedback to do better next time

The thinking here is straightforward: fully autonomous agents aren't always what you want. Human judgement still earns its keep, especially when the stakes are high (AutoGen Human-in-the-Loop docs).

Advanced Patterns

Nested Chats: an agent can spin off a sub-conversation to crack a sub-problem, which lets you stack problem-solving into hierarchies.

State Machines: spell out explicit state transitions for workflows that need tight process control.

Custom Agents: build specialised agents by subclassing the base classes and overriding behaviour.

Group Chat Managers: run multi-agent discussions with speaker-selection strategies you configure.

The Microsoft Ecosystem

AutoGen rides on Microsoft's research budget and plugs into Azure:

• Azure OpenAI: LLM access with enterprise guarantees
• Azure Container Instances: scalable environments for code execution
• Azure Cognitive Services: vision, speech, and search
• Semantic Kernel: a bridge into Microsoft's wider AI framework

When to Choose AutoGen

AutoGen earns its place when:

• Code execution is a core requirement
• You want a human involved throughout
• You need complex conversation patterns
• Tying into the Microsoft ecosystem actually buys you something

The framework is mature, the docs are solid, and there's real research behind it. For enterprise teams building agentic apps, it offers a mix of capability and reliability that few alternatives match. Just keep one eye on the Microsoft Agent Framework, since that's where Microsoft is now steering production builds.