The story most people know about AutoGen is a naming soap opera: Microsoft's research project, a community fork, a rebrand to AG2, and the recurring question of which thing you're actually installing. That story is already told. The more interesting one is what the survivors decided to rebuild, and why.
AG2's v1.0 beta (v1.0.0b0) closes a rewrite that ran all year. The ground-up API that had been quarantined under the autogen.beta namespace is promoted to the top level, and the classic stack — ConversableAgent, GroupChat, the whole chatty-object model that made AutoGen famous — is lifted out into a separate ag2ai/ag2-classic repository in maintenance mode. The split is now legible in one line at the terminal: pip install ag2 gets you the future, pip install autogen gets you the past under glass.
The old agent was a mutable object. That was the bug.#
In the classic model, a conversation was state that lived on the agent. Messages, history, scratch variables — mutable fields hanging off a ConversableAgent instance. That is a perfectly good shape for a notebook demo and a genuinely bad shape for a server, because the moment two users share one agent instance, their conversations bleed into each other. The usual workaround is to construct a fresh agent per request, which quietly throws away any reuse and turns every session into cold-start object graph assembly.
AG2's answer is the MemoryStream: every conversation runs on a publish/subscribe event bus, with an append-only event log per channel. State stops being fields you mutate and becomes an ordered stream of events an agent subscribes to. Isolate the channel and you isolate the conversation; a single agent instance can now serve many concurrent users without their histories touching, and because events publish to the bus as they occur, streaming a run stops being a feature you bolt on and becomes the default way the thing already works.
A framework's 1.0 is usually the release where it stops optimizing for the demo and starts optimizing for the second concurrent user.
The Harness: an agent as four swappable protocols#
Sitting on top of the stream is the Agent Harness, which refuses to treat "a stateful agent" as one monolithic thing and splits it into four protocols you can swap independently:
- Persistence — durable knowledge behind a
KnowledgeStore. - Assembly — how context is composed for the next call, via policies:
ConversationPolicy,TokenBudgetPolicy,EpisodicMemoryPolicy,WorkingMemoryPolicy. - Execution — the actual LLM call.
- Post-Processing — compaction and aggregation of what came back.
The unglamorous win here is that the two hardest problems in a long-running agent — what do I remember and what do I fit in the window — are pulled out of the control flow and made into named, replaceable objects. You can cap a token budget or change an episodic-memory strategy without rewriting the agent, because those were never really the agent's job; they were policies pretending to be code.
The rest is production hygiene, and that's the point#
The supporting cast reads like a checklist of things conversation-first frameworks skip until something breaks in production. Providers unify behind a single ModelConfig protocol spanning OpenAI, Anthropic, Gemini, Qwen/DashScope, and Ollama, so swapping a model is configuration, not a rewrite. Tools are typed and auto-generate their JSON schema from Python type hints, which kills the drift between what a function actually accepts and what the model was told it accepts. And TestConfig / TestClient let you feed canned model responses, so agent logic becomes unit-testable — you can assert on control flow without paying a nondeterministic API on every run, the single most common reason agent code goes untested.
None of that makes an individual AG2 agent smarter. It makes agents concurrent, streamable, and testable — the boring web-server properties. And that is exactly why it matters. Look at what shipped across the ecosystem this year: MCP is deleting its session to go stateless, every framework quietly became a graph, and now AutoGen's successor has turned its agent into a handler over an event stream. These are the same move under three logos. The industry spent its first act arguing about orchestration cleverness; the second act, the one AG2's 1.0 belongs to, is about the unfashionable question of who holds the state — and answering it with "not the agent object, the log." That's not a rewrite for the demo. It's a rewrite for the second user.
