Comparisons / AutoGen vs DSPy
AutoGen vs DSPy: Which Agent Framework to Use?
AutoGen autogen by microsoft models agents as conversableagents that chat with each other. DSPy dspy replaces hand-written prompts with compiled modules. 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
DSPy
33.4k
2.8k
Python
MIT
2023-01-09
Stanford NLP (Omar Khattab)
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | AutoGen | DSPy | Plain Python |
|---|---|---|---|
| Agent | ConversableAgent with system_message, llm_config | dspy.ReAct module with signature and tools | A function with a system prompt that POSTs to the LLM API |
| Tools | register_for_llm() and register_for_execution() | Tools passed to ReAct module as callable list | 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 |
| Prompts | — | dspy.Signature defines input/output fields, compiled to optimized prompts | An f-string template: prompt = f"Given {input}, return {output}" |
| Optimization | — | dspy.BootstrapFewShot, MIPROv2 auto-tune prompts against a metric | Manual iteration: try different prompts, measure accuracy, pick the best one |
| Chaining | — | dspy.ChainOfThought, dspy.Module with forward() composition | Function calls in sequence: step1 = summarize(text); step2 = classify(step1) |
| Evaluation | — | dspy.Evaluate with metric functions and dev sets | A for loop over test cases: scores = [metric(predict(x), y) for x, y in test_set] |
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 DSPy 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 DSPy
DSPy's real innovation is automated prompt optimization — replacing manual prompt engineering with algorithmic tuning. This is genuinely novel and valuable for production systems where prompt quality matters at scale. For simple agents or learning, hand-written prompts are easier to understand and modify.
What DSPy does
DSPy takes a fundamentally different approach from other agent frameworks. Instead of providing agent orchestration abstractions, it replaces the prompt engineering process itself. You define a Signature — a typed declaration of inputs and outputs like "question -> answer" — and DSPy compiles it into an optimized prompt. The framework provides modules like ChainOfThought (adds reasoning steps), ReAct (adds tool use), and ProgramOfThought (generates code). The key innovation is Optimizers: algorithms like BootstrapFewShot and MIPROv2 that automatically find the best instructions and few-shot examples by evaluating against a metric you define. This means prompts improve systematically rather than through trial-and-error. DSPy treats prompts as a compilation target, not a hand-authored artifact.
The plain Python equivalent
A Signature is an f-string template with named placeholders. ChainOfThought adds "Let's think step by step" to your prompt — literally one line. ReAct is the standard agent loop: call the LLM, parse tool calls, execute them, repeat. The real difference is optimization. In plain Python, you manually write prompts, test them against examples, adjust wording, and repeat. DSPy automates this cycle with search algorithms. The plain equivalent is a script that tries N prompt variants, scores each against a test set, and picks the winner. This is tedious but conceptually simple — a for loop over prompt templates with an accuracy check. The agent pattern itself (function + dict + loop) is identical to every other framework.
Or build your own in 60 lines
Both AutoGen and DSPy 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 →