Comparisons / AutoGen vs Semantic Kernel
AutoGen vs Semantic Kernel: Which Agent Framework to Use?
AutoGen autogen by microsoft models agents as conversableagents that chat with each other. Semantic Kernel semantic kernel is microsoft's enterprise sdk for building ai agents. 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
Semantic Kernel
27.6k
4.5k
C#
MIT
2023-02-27
Microsoft
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | AutoGen | Semantic Kernel | Plain Python |
|---|---|---|---|
| Agent | ConversableAgent with system_message, llm_config | ChatCompletionAgent with Kernel, instructions, and service config | A function with a system prompt that POSTs to the LLM API |
| Tools | register_for_llm() and register_for_execution() | — | 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 |
| Tools / Plugins | — | KernelPlugin with @kernel_function decorators, typed parameters | A dict of callables: tools = {"search": lambda q: ...} |
| Planning | — | StepwisePlanner, HandlebarsPlanner for multi-step decomposition | A system prompt that says 'break this into steps' — the LLM plans natively |
| Memory | — | SemanticTextMemory with embeddings and vector stores | A dict injected into the system prompt, or a list searched with embeddings |
| Orchestration | — | Kernel.invoke() with plugin resolution and filter pipeline | A while loop: call LLM, check for tool_calls, dispatch, repeat |
| Multi-Language | — | C#, Python, Java SDKs with shared abstractions | The HTTP API is the same in every language — just POST JSON |
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 Semantic Kernel 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 Semantic Kernel
Semantic Kernel earns its complexity in enterprise environments with Azure OpenAI, .NET backends, and existing Microsoft infrastructure. But the core agent pattern — LLM call, tool dispatch, loop — is identical to what you can build in 60 lines of Python.
What Semantic Kernel does
Semantic Kernel is Microsoft's SDK for building AI-powered applications. The central object is the Kernel — it holds your AI service connections, plugins, and configuration. Plugins are collections of KernelFunctions (decorated Python/C# methods) that the LLM can call as tools. Planners like StepwisePlanner break complex goals into multi-step plans, choosing which plugins to invoke at each step. The SDK provides deep integration with Azure OpenAI, including managed identity auth, content filtering, and deployment management. It also ships memory connectors for vector stores (Azure AI Search, Qdrant, Pinecone) and supports filters — middleware that runs before and after each function invocation. For teams already on Azure with .NET backends, it fits naturally into the existing stack.
The plain Python equivalent
The Kernel is a config object that holds your API key and a dict of tools. A KernelFunction is a regular function in that dict. The Planner is a system prompt instruction — tell the LLM to break the task into steps and it will, no planner class needed. Memory is a list of strings you embed and search, or just a dict you inject into the prompt. Orchestration is the same while loop every agent uses: call the LLM, check if the response has tool_calls, look up the function in your tools dict, call it, append the result, repeat. The filter pipeline is a try/except around your function calls. The entire agent — including plugin dispatch, planning, and memory — is about 60 lines. No Kernel object, no plugin registry, no planner hierarchy.
Or build your own in 60 lines
Both AutoGen and Semantic Kernel 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 →