# 10xGraph vs Microsoft AutoGen: Python Compared > 10xGraph vs Microsoft AutoGen compared with sources. AutoGen is in maintenance mode, so this covers the production layer and what Microsoft recommends instead. Source: https://10xgraph.com/docs/compare/10xgraph-vs-autogen Last updated: 2026-10-28 > **AutoGen is in maintenance mode** > > The AutoGen repository says AutoGen "will not receive new features or enhancements and is community managed going forward", and recommends Microsoft Agent Framework for new users ([microsoft/autogen](https://github.com/microsoft/autogen)). Checked 2026-10-06. This page is written by the 10xGraph team, so read it with that in mind. Claims about AutoGen link to its repository, docs or package metadata, checked on 2026-10-06. **AutoGen** is a Microsoft framework for conversational multi-agent systems, dual-licensed under MIT and CC-BY-4.0 per its [repository](https://github.com/microsoft/autogen). Its AgentChat layer offers teams such as `RoundRobinGroupChat`, `SelectorGroupChat`, `Swarm` and `GraphFlow` ([teams docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)). **10xGraph** models work as a typed state graph and ships the production server layer in the open-source install. Microsoft describes [Microsoft Agent Framework](https://github.com/microsoft/agent-framework) as the successor to AutoGen: MIT-licensed, for Python and .NET, with checkpointing and several hosting options. If you are choosing between a maintained Microsoft framework and 10xGraph, compare against that project too. ## Production layer compared The first rows are where the two differ most. Orchestration basics are at the bottom. | | 10xGraph | AutoGen | |---|---|---| | Production server (REST, NDJSON streaming, WebSocket) in the open-source install | Yes. The `10xgraph-api` server generates REST, NDJSON streaming, WebSocket and realtime-audio endpoints from the compiled graph | No production server documented. AutoGen Studio is a prototyping UI that its README says is "not meant to be a production-ready app" ([README](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-studio)) | | Auth (JWT or custom) | JWT (`"auth": "jwt"`) or a custom `BaseAuth` subclass | Not documented for the framework. The Studio README tells developers to implement authentication and security themselves ([README](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-studio)) | | Authorization | Role scopes (such as `graph:invoke`, `checkpointer:read`) or a custom `AuthorizationBackend` | Not documented | | Thread ownership isolation | Built-in `"authorization": "ownership"` backend, with a two-tier cached owner check | Not documented | | Security and isolation defaults when served | The server refuses to start if any non-public route lacks a permission guard. With auth on or `MODE=production`, threads are owner-only. In production it refuses wildcard `ORIGINS`, and replaces 5xx error messages with a generic text. `auth: null` still starts an open server ([limits](/docs/production/limits)) | See their docs | | Rate limiting | Memory or Redis sliding-window limits on the API, set in `10xgraph.json` | Not documented | | Replay-safe tool calls after a crash | Tool ledger in the checkpointer: a tool that already ran is not executed again on resume. Needs a checkpointer | Not documented. State is saved and loaded with `save_state()` and `load_state()` ([state docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html)) | | Versioned (compare-and-swap) state writes | Optimistic version check on durable writes in `PgCheckpointer` | Not documented. AutoGen returns state as a serializable dictionary and leaves storage to you ([state docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html)) | | Node and tool timeouts | `node_timeout` and `tool_timeout`, off until you set them | `TimeoutTermination` stops a team after a duration in seconds ([termination docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/termination.html)) | | Docker Compose and Kubernetes manifests | `10xgraph build --docker-compose --k8s` writes `Dockerfile`, `docker-compose.yml`, `k8s.yaml` | Not documented | | License | MIT, including API/CLI and client | MIT and CC-BY-4.0 dual license per the repository ([repository](https://github.com/microsoft/autogen)). `autogen-agentchat` on PyPI lists MIT ([PyPI](https://pypi.org/project/autogen-agentchat/)) | | TypeScript client | Typed `10xgraph-client` | Not documented | | Project status | Pre-1.0, actively developed | Maintenance mode, community managed ([repository](https://github.com/microsoft/autogen)) | | Orchestration | Typed `StateGraph` with conditional edges and sub-graphs | Group chat teams, including `SelectorGroupChat` where a model picks the next speaker, and `GraphFlow` for structured workflows ([teams docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)) | | State persistence | `InMemoryCheckpointer`, `PgCheckpointer` (Postgres plus Redis), SQLite, keyed by `thread_id` | `save_state()` and `load_state()` on agents and teams, with no built-in database persistence ([state docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html)) | | Python version | 3.12 or newer | 3.10 or newer ([PyPI](https://pypi.org/project/autogen-agentchat/)) | ## Why teams choose 10xGraph over AutoGen for production 1. **The server layer is included.** AutoGen's own README points developers to build their own application with authentication and security. 10xGraph generates the endpoints and the auth, ownership and rate-limit settings. 2. **Side effects survive crashes.** 10xGraph's tool ledger skips tools that already ran when a run resumes. See [replay-safe tools](/docs/concepts/replay-safe-tools). 3. **One state, one history.** Every node reads the same `AgentState`, and the checkpointer stores it per thread. 4. **Active development.** 10xGraph is at its 1.0 release candidate and under active development, while AutoGen is in maintenance mode. ## A planner and coder loop in 10xGraph A two-agent flow with an order of execution fixed by edges: Install with `pip install "10xgraph[google-genai]"` and set `GEMINI_API_KEY` or `GOOGLE_API_KEY`. ```python title="graph/plan_code.py" from tenxgraph.core.graph import Agent, StateGraph from tenxgraph.core.state import AgentState from tenxgraph.storage.checkpointer import InMemoryCheckpointer from tenxgraph.utils import END planner = Agent( model="gemini-2.5-flash", provider="google", system_prompt=[{"role": "system", "content": "Break the task into 3 numbered steps."}], ) coder = Agent( model="gemini-2.5-flash", provider="google", system_prompt=[{"role": "system", "content": "Use the plan in context to write Python code that implements it."}], ) graph = StateGraph(AgentState) graph.add_node("PLAN", planner) graph.add_node("CODE", coder) graph.set_entry_point("PLAN") graph.add_edge("PLAN", "CODE") graph.add_edge("CODE", END) app = graph.compile(checkpointer=InMemoryCheckpointer()) ``` To turn this into a loop (plan, code, review, re-plan if the reviewer says no), add a conditional edge from a `REVIEW` node back to `PLAN`. For the AutoGen version of a team with termination conditions, see AutoGen's [teams](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html) and [termination](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/termination.html) docs. ## When you want agents that converse AutoGen's selector team lets a model pick the next speaker ([teams docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)). In 10xGraph, the same idea is a router plus handoff tools: ```python title="graph/handoff_fragment.py" from tenxgraph.core.graph import Agent, StateGraph, ToolNode from tenxgraph.core.state import AgentState from tenxgraph.prebuilt.tools import create_handoff_tool # The handoff tool transfers control to the node named "critic" author_tools = ToolNode([create_handoff_tool("critic", "Send the draft to the critic")]) author = Agent( model="gemini-2.5-flash", provider="google", system_prompt=[{"role": "system", "content": "Draft and revise the customer reply."}], tool_node="AUTHOR_TOOLS", ) graph = StateGraph(AgentState) graph.add_node("AUTHOR", author) graph.add_node("AUTHOR_TOOLS", author_tools) # Add the "critic" node and the edges as shown in the handoff guide ``` Each handoff is a tool call you can log and cap with `recursion_limit`. See [the handoff how-to](/docs/guides/handoff-between-agents) for the full graph. ## Persistence and resumable threads Install the Postgres checkpointer extra (`pip install "10xgraph[pg_checkpoint,google-genai]"`) and reuse the `graph` from the planner example. Calling again with the same `thread_id` continues the stored thread. ```python title="graph/resume_thread.py" import asyncio from tenxgraph.core.state import Message from tenxgraph.storage.checkpointer import PgCheckpointer async def main() -> None: checkpointer = PgCheckpointer( postgres_dsn="postgresql://user:password@localhost:5432/agents", redis_url="redis://localhost:6379/0", ) await checkpointer.asetup() # creates the schema app = graph.compile(checkpointer=checkpointer) await app.ainvoke( {"messages": [Message.text_message("Continue from the last revision.")]}, config={"thread_id": "session-42"}, ) asyncio.run(main()) ``` ## Serving as an API ```bash pip install 10xgraph 10xgraph-api 10xgraph init --yes --template production --auth jwt 10xgraph dev --host 0.0.0.0 --port 8000 --no-open 10xgraph build --docker-compose --k8s ``` Endpoints include: - `POST /v1/graph/invoke`: run the graph and return final messages - `POST /v1/graph/stream`: newline-delimited JSON (NDJSON) for streaming - `GET /v1/threads/{thread_id}`: fetch persisted state ## TypeScript client ```typescript import { TenxGraphClient, Message, StreamEventType, bearerAuth } from "10xgraph-client"; const client = new TenxGraphClient({ baseUrl: "http://127.0.0.1:8000", auth: bearerAuth(token), }); for await (const chunk of client.stream( [Message.text_message("Plan and write a script that exports yesterday's refunds.")], { config: { thread_id: "ts-stream-1" } }, )) { if (chunk.event === StreamEventType.MESSAGE && chunk.message) { process.stdout.write(chunk.message.text()); } } ``` ## Migrating from AutoGen 1. Each `AssistantAgent` becomes a `tenxgraph.core.graph.Agent` with the same `system_message` content as its `system_prompt`. 2. `RoundRobinGroupChat` becomes a chain of `add_edge` calls. 3. `SelectorGroupChat` becomes a router node, either a plain Python function or an LLM router. 4. `TextMentionTermination` and similar conditions become a conditional edge that returns `END` when a flag is set, or a `recursion_limit` in the invoke config. 5. AutoGen tools become `ToolNode([fn, fn, ...])` with regular Python functions. 6. Per-agent message lists become the shared `AgentState.messages`. ## Where AutoGen is the better choice - **Research on multi-agent conversation.** AutoGen's team types, including selector and Magentic-One teams, are built for exploring agent dialogue ([teams docs](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)). - **Existing AutoGen code you do not need to change.** If it works and you do not need new features, staying put costs nothing. - **A Microsoft stack.** If you are on .NET or Azure, look at Microsoft Agent Framework, which supports Python and .NET ([repository](https://github.com/microsoft/agent-framework)). - **Python 3.10 or 3.11.** 10xGraph requires 3.12 or newer. ## Weak spots of 10xGraph - Smaller community and fewer integrations than the Microsoft ecosystem. - Pre-1.0: pin versions and read changelogs before upgrading. - Renamed from Agentflow, so the 10xGraph name has little search history yet. - No Studio-style visual builder. The playground is a test chat. - Code-first only, and Python 3.12 or newer. ## Sources Verified on 2026-10-06. - [microsoft/autogen repository](https://github.com/microsoft/autogen) (maintenance mode, licenses) - [AutoGen Studio README](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-studio) - [autogen-agentchat on PyPI](https://pypi.org/project/autogen-agentchat/) - [AgentChat teams](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html) - [AgentChat state](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html) - [AgentChat termination conditions](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/termination.html) - [microsoft/agent-framework repository](https://github.com/microsoft/agent-framework) ## Next steps - [Get started with 10xGraph](https://10xgraph.com/docs/get-started): Install, build, expose, and connect a typed client. - [Handoff between agents](https://10xgraph.com/docs/guides/handoff-between-agents): Explicit, debuggable agent-to-agent control flow. - [Streaming and async patterns](https://10xgraph.com/docs/concepts/streaming): How async streams work end-to-end. ## Frequently asked questions ### Is AutoGen still actively developed? According to the AutoGen repository, AutoGen is in maintenance mode. It receives no new features and is community managed, and Microsoft recommends Microsoft Agent Framework for new projects. ### Can I get AutoGen-style agents that talk to each other in 10xGraph? Yes. Model the conversation as a router plus handoff tools. Each handoff is a tool call you can log and inspect, and routing can be a plain Python function or an LLM router. ### Does 10xGraph support OpenAI, Azure OpenAI, and Anthropic like AutoGen does? 10xGraph ships providers for OpenAI, Anthropic (direct, Vertex AI, Bedrock) and Google (Gemini and Vertex AI), and works with OpenAI-compatible endpoints. See the providers section of the docs. ### How does the 10xGraph API server compare to AutoGen Studio? AutoGen Studio is a prototyping UI that its own README says is not meant to be a production-ready app. 10xGraph's CLI generates a REST, NDJSON streaming and WebSocket server with JWT auth and owner-only threads from a compiled graph. ### Can 10xGraph handle human-in-the-loop reviews? Yes. The graph supports interrupts and resumable threads. You can pause at a node, show state to a reviewer, and resume on the same thread_id.