Comparisons / AutoGen vs Google ADK
AutoGen vs Google ADK: Which Agent Framework to Use?
AutoGen autogen by microsoft models agents as conversableagents that chat with each other. Google ADK google's agent development kit (adk) is an open-source framework for building multi-agent systems. 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
Google ADK
18.7k
3.2k
Python
Apache-2.0
2025-04-01
Google/Alphabet
Vertex AI
Yes
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | AutoGen | Google ADK | Plain Python |
|---|---|---|---|
| Agent | ConversableAgent with system_message, llm_config | LlmAgent class with model, instructions, and sub_agents list | A function with a system prompt that POSTs to the LLM API |
| Tools | register_for_llm() and register_for_execution() | FunctionTool, built-in tools (Search, Code Exec), third-party integrations | 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 | Hierarchical agent tree with root agent delegating to specialized sub-agents | 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 | — | Runner.run() with automatic tool dispatch and sub-agent delegation | A while loop: call LLM, check for tool_calls, execute, repeat |
| Workflows | — | SequentialAgent, ParallelAgent, LoopAgent workflow primitives | Sequential: call functions in order. Parallel: asyncio.gather(). Loop: while condition |
| Session | — | Session and State service with typed channels and persistence | A dict passed between function calls: state = {"turns": 0, "context": []} |
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 Google ADK 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 Google ADK
ADK earns its complexity when you need multi-agent orchestration on Google Cloud with Vertex AI deployment. If you're using Gemini and need production-grade agent infrastructure, it's well-designed. For single-agent use cases or non-Google stacks, plain Python keeps things simpler.
What Google ADK does
Google ADK provides a code-first framework for building agents that can delegate work to other agents in a hierarchy. You define an LlmAgent with a model, instructions, tools, and optionally a list of sub-agents. The root agent decides when to hand off tasks to specialized children. ADK ships with workflow primitives — SequentialAgent runs steps in order, ParallelAgent fans out concurrently, LoopAgent repeats until a condition is met. The framework handles session management, state persistence, and streaming out of the box. It's optimized for Gemini models and Vertex AI but works with other providers. For teams already on Google Cloud, the deployment story is seamless: containerize your agent and deploy to Vertex AI Agent Engine or Cloud Run.
The plain Python equivalent
A hierarchical agent is just functions calling other functions. Your root agent calls the LLM, and if the response indicates a sub-task, you call a different function with its own system prompt and tool set. Workflow orchestration is equally straightforward: sequential is calling functions in order, parallel is asyncio.gather(), and looping is a while loop with a condition check. Session state is a dict you pass between calls and optionally serialize to disk or a database. The entire pattern — root agent, sub-agents, workflows, state — fits in about 80 lines of Python. No class hierarchies, no Runner abstraction, no Agent Engine. When your agent misbehaves, you read your functions instead of tracing through framework internals.
Or build your own in 60 lines
Both AutoGen and Google ADK 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 →