AutoGen / Microsoft Agent Framework Platform Research

1. Introduction

1.1 Platform Positioning

AutoGen is an open-source multi-agent conversation framework released by Microsoft Research in 2023 (MIT license), and was once synonymous with "multi-Agent conversational collaboration." Starting in 2025, Microsoft launched a unification strategy: AutoGen and Semantic Kernel were merged into Microsoft Agent Framework (MAF), and both entered maintenance mode.

Per the unified framing of the project parameter card, MAF belongs to the third-generation "Runtime and Evaluation Era" Runtime-type Harness — it is not merely an Agent Framework subset covering L2/L3, but rather makes context engineering, sandboxed execution, trajectory evaluation, and permission governance all first-class citizens — the full form of a Harness rather than a subset.

MAF's most important conceptual contribution is the Harness Agent: it turns the "Agent runtime pattern" itself into an API. A single method call (.AsHarnessAgent(...) / create_harness_agent(...)) turns any chat client into a complete Agent Harness with planning, todo tracking, context compression, file access, memory, tool approval, and observability. In the literal sense of the term "AI Harness," this is the closest production expression seen in 2026.

1.2 Basic Information

1.3 Key Fact: AutoGen Has Been Merged into Microsoft Agent Framework

This is the first premise for understanding this platform: AutoGen is no longer evolving independently — its capabilities have been merged into Microsoft Agent Framework (MAF; also known as Microsoft Agent Framework 365 within the Microsoft 365 ecosystem).

Merger timeline:

Community criticism in 2025: before the merger into MAF, AutoGen saw a concentration of community-level criticism in 2025, mainly including:

These criticisms form part of the real-world backdrop for Microsoft's decision to unify the three SDK lines (AutoGen / Semantic Kernel / new) under MAF. For existing users, this means 2026 is the year to plan migration: staying on AutoGen will only entitle you to community-level maintenance.

2. Glossary

3. Feature Overview

3.1 Four Major Domains

MAF's capability surface is organized into four domains:

1. Agents: building and running a single Agent (AIAgent / ChatClientAgent / Declarative Agent).
2. Harness Agent: the "batteries-included" form for long, multi-step tasks.
3. Workflows: functional and graph-based workflows that provide explicit execution paths.
4. Integrations: model vendors, Agent services, tools, context providers, middleware, evaluation services, UI frameworks.

3.2 Five Orchestration Patterns

All five patterns work out of the box — this is MAF's differentiating advantage over LangGraph, where "there's only a graph and patterns must be built yourself": it pre-bakes common collaboration shapes into patterns, lowering the cost of designing from scratch.

3.3 Agent Harness Extension Components

The Harness Agent assembles capabilities through a set of pluggable Providers (introduced at BUILD 2026):

Middleware and customization capabilities include ToolApprovalAgent ("don't ask again" approval rules for sensitive tools) and OpenTelemetryAgent (automatic OTel semantic-convention tracing).

3.4 Foundry Hosted Agents

The path from local to production is collapsed into a few lines of code:

• .NET: AddFoundryResponses(agent) + MapFoundryResponses()
• Python: ResponsesHostServer(agent).run()

The hosted side provides: scale to zero, full file-system recovery, per-session VM-isolated sandboxes, and OTel traces that automatically flow into Application Insights.

3.5 CodeAct: Folding Orchestration Overhead into a Single Execution

CodeAct addresses the fundamental problem of orchestration overhead: the traditional Agent loop is "choose a tool → wait → choose the next tool," with each step requiring a full model round-trip. CodeAct folds this into "the model writes a short program → executes once in the sandbox → returns merged results," significantly reducing model turns, latency, and token consumption.

Note that CodeAct lives in the agent-framework-hyperlight (alpha) package; its maturity is [To be verified], and it should not be a core path for production dependencies.

3.6 Interoperability and Multi-Language

• MCP + A2A: tool interoperability goes through MCP, and cross-framework Agent collaboration uses A2A 1.0 — both natively supported at 1.0 rather than bolt-on adapter layers.
• Multi-language: C# and Python are dual first-class citizens; Go is a public preview with feature gaps (no declarative Agent, RAG, CodeAct, or functional workflows).
• Declarative YAML Agent and DevUI browser debugging.

4. Platform Architecture

图 4-1｜MAF 五层架构：从 Interop 互操作层到 Connectors 连接器层

数据来源：基于本文分析绘制的示意图。

4.1 Five-Layer Architecture

Interop 层      MCP 客户端 / A2A 协议适配器
Orchestration   图工作流引擎（Sequential / Concurrent / Handoff / Group Chat / Magentic-One）
Agents          AIAgent / ChatClientAgent / Declarative Agent / Harness Agent
Runtime         Session 管理 / Middleware 管线 / Memory & Context / 执行循环
Connectors      Azure OpenAI / OpenAI / Anthropic / Bedrock / Gemini / Ollama（均实现 IChatClient）

The key architectural design is that the Connectors layer uniformly implements the IChatClient interface: this downgrades "switching model vendors" from a code change to a configuration change, and is the engineering foundation for L1-layer model-routing capability.

4.2 Division of Legacy between AutoGen and Semantic Kernel

Each of the two predecessor frameworks left half of itself in MAF:

Consequently, AutoGen's trio of ConversableAgent / GroupChat / Selector is re-expressed in MAF as ChatClientAgent / the Group Chat orchestration pattern / type-safe routing. The concepts are continuous, but the APIs are incompatible — precisely why existing users need to plan their migration.

4.3 The Path from Local to Production

本地：ChatClientAgent + Harness Agent（本地文件记忆、沙箱 shell、DevUI 调试）
  ↓   AddFoundryResponses / ResponsesHostServer
生产：Foundry Hosted Agents（容器打包、scale to zero、每会话 VM 隔离、Application Insights 追踪）

The engineering significance of this path is that Harness's local and hosted forms are the same API — there is no "runs locally but must be rewritten for the cloud" discontinuity.

5. Harness Design

5.1 Six-Layer Capability Overview

MAF is the only platform among all those evaluated that reaches "Strong" across all six layers.

5.2 L1 Context Engineering Layer

Rating: Strong.

• Auto context compression: The Harness Agent monitors token usage mid-loop and compresses chat history to prevent long tool-call chains from overflowing the context window. This is the hallmark of turning "context engineering" from a developer responsibility into a runtime responsibility.
• Context Providers: Pluggable context providers for Agent memory.
• Instruction merging: harness instructions come first, custom instructions follow, preventing user instructions from overriding critical runtime constraints.
• Planning/execution mode separation: AgentModeProvider supports plan and execute modes, allowing the planning and execution phases to use different context strategies.

Relative shortcoming: the researched materials do not mention MAF offering a "forget recent turns" capability like Google ADK's Session Rewind, nor optimization details at the KV-cache-reuse level.

5.3 L2 Tools and Execution Layer

Rating: Strong.

• MCP client (tool interoperability).
• Hosted Web search.
• ShellExecutor (.NET sandboxed shell).
• AgentSkillsProvider: file-system skill discovery and execution — isomorphic to the Claude Agent SDK's Skills mechanism.
• BackgroundAgentsProvider: parallel sub-Agent delegation.
• CodeAct: folds multi-round tool calls into a single sandboxed program execution, directly attacking the orchestration-overhead bottleneck (alpha stage).
• Foundry Hosted provides per-session VM-isolated sandboxes.

5.4 L3 Orchestration and Control Layer

Rating: Strong.

On this layer MAF simultaneously offers two toolkits — patterns and graphs — which is its key differentiator relative to peer platforms:

Tension One (flexibility ↔ predictability) on MAF is resolved through a "graph + pattern" two-tier supply: use patterns directly for common scenarios, and fall back to explicit graphs for complex ones. Type-safe routing is the finishing touch here — routing conditions are constrained at the data-structure level, rather than relying on prompts to make the model "remember" which branch to take. This turns routing from a probabilistic judgment into compilable, verifiable logic.

In addition, graph workflows support checkpointing and HITL, and checkpoints can be persisted, so long-running flows can survive being reclaimed and resumed across processes — a hard requirement for long-transaction scenarios.

5.5 L4 Memory and State Layer

Rating: Strong.

• Agent Session: Basic building block for session-state management.
• Multi-backend memory: Three optional forms — session history / persistent KV / vector retrieval.
• FileMemoryProvider: Session-level file memory at path agent-file-memory/{session}/.
• Replaceable storage: FileMemoryStore / FileAccessStore can be swapped for any AgentFileStore implementation (e.g., blob storage).
• Hosted environment recovery: After scale to zero, the file system and session identity are fully restored — a rare solution to the "stateless hosting + stateful Agent" contradiction.

5.6 L5 Evaluation and Observability Layer

Rating: Strong.

• OpenTelemetryAgent: Automatically injects OTel semantic-convention tracing for end-to-end traces.
• Zero-wiring Application Insights integration: In hosted scenarios, traces flow in automatically with no extra configuration.
• DevUI: Browser-side debugging tool.
• Evaluation service integration: MAF provides an evaluation-service integration point.

Relative shortcoming: the researched materials do not mention MAF offering a built-in evaluation set / golden dataset / judge system like OpenAI Evals, LangSmith, or Alibaba Cloud OpenJudge. MAF's strength is "standardizing traces and wiring them out," not "providing its own evaluation loop."

5.7 L6 Governance and Security Layer

Rating: Strong.

MAF's governance capability is the most complete among all platforms under review, stemming from its inheritance of Semantic Kernel's enterprise-grade filter pipeline:

Tension Two (openness ↔ governance) has its clearest answer on MAF: both MCP and A2A are native 1.0 (opening up interoperability), yet every layer has a corresponding governance handle — the protocol layer has adapters, the tool layer has approval, the invocation layer has Filters, the identity layer has Entra, the execution layer has a sandbox, and the deployment layer has hosted identity and version management.

On Tension Three (cost ↔ depth): Foundry Hosted Agents uses usage-based billing of compute $0.0994 / vCPU-hour + memory, combined with scale to zero and CodeAct (reducing model turns and tokens) — one of the few offerings designed at the pricing-model level for "deep agent chains." However, the researched materials do not mention a task-level hard budget cap (budget guardrail) mechanism; flagged [To be verified].

5.8 Projection of the Three Inherent Tensions onto MAF

6. Real-World Cases

No enterprise adoption cases with quantified results were found. The materials retrieved were mainly release notes, architecture analyses, and migration guides.

Qualitative evidence available for reference:

• Together, AutoGen and Semantic Kernel accumulated over 75,000 GitHub stars and three years of enterprise field experience, all of which MAF inherits.
• MAF 1.0 offers a long-term support (LTS) commitment and a documented upgrade path — rare in the Agent-framework space, indirectly reflecting its enterprise customer base.

Honest note: the above are all qualitative descriptions and do not constitute evidence of deployment results. Any claim citing MAF's results must be flagged "no public quantified data found."

7. Summary

7.1 Strengths

• Most balanced across six layers: the only platform rated Strong in all six layers.
• Harness Agent is the closest production implementation of the literal meaning of "AI Harness": it turns the runtime pattern into an API — a single call yields the full set of planning, todo, compression, files, memory, approval, and observability capabilities.
• .NET and Python are dual first-class citizens: extremely rare in a Python-centered Agent-framework ecosystem.
• MCP + A2A native 1.0, not bolt-on adapters.
• Long-term support (LTS) commitment: a rare enterprise-grade promise that reduces API-drift risk.
• Strongest enterprise governance: Middleware + Filters + Entra + sandbox + audit, with governance granularity down to individual tool calls.
• Very short Foundry Hosted path: a few lines of code from local to production, with full state recovery after scale to zero.
• CodeAct strikes at the essence of orchestration overhead (alpha; maturity needs assessment).

7.2 Weaknesses

• Go SDK is still in public preview with feature gaps: no declarative Agent, RAG, CodeAct, or functional workflows.
• Ecosystem and community momentum lower than LangGraph / CrewAI: insufficient third-party tutorials, examples, and community contributions.
• Strong gravitational pull of the Microsoft ecosystem: the best experience for governance, identity, hosting, and observability all sits within the Azure stack; capabilities decay cross-cloud.
• Existing SK / AutoGen users face migration pressure in 2026: the cost of digesting legacy baggage.
• Community criticisms that AutoGen left behind in 2025 (concurrency, documentation, enterprise usability) need to be resolved by MAF's actual track record; there is currently insufficient public evidence.
• No public quantified deployment results were found.

7.3 Applicability Boundaries

Suitable for:

• Default choice for enterprises in the Microsoft ecosystem (.NET / Azure / Foundry).
• Regulated industries requiring strong governance, long-running flows, and durable execution (finance, healthcare, public sector).
• Organizations already invested in Semantic Kernel or AutoGen that need a clear migration destination.
• Enterprise projects requiring an LTS commitment and that cannot tolerate frequent API drift.

Not suitable for:

• Teams pursuing the largest open-source ecosystem and community density.
• Lightweight prototyping/validation (higher cognitive load than the OpenAI Agents SDK).
• Organizations with no Microsoft/Azure investment and that wish to avoid platform lock-in.
• Scenarios needing an out-of-the-box evaluation loop (golden dataset / judge) — MAF excels at trace standardization rather than an evaluation loop.

7.4 Selection Recommendations

Bottom line: Microsoft Agent Framework is an engineered Harness exemplar with "no weaknesses across six layers," leading especially in enterprise governance and durable long-running execution; its costs are ecosystem gravity, community momentum, and the Go-language maturity gap. AutoGen users should treat 2026 as a migration window, not a wait-and-see window.

Information-Gap Statement

1. Enterprise adoption cases and quantified results: after 3 rounds of searching, no enterprise adoption cases with quantified results were found. What was retrieved were all release notes, architecture analyses, and migration guides.
2. Complete Foundry Hosted Agents pricing: compute at $0.0994 / vCPU-hour; the memory billing unit is unclear, flagged unit.
3. Detailed list of Go SDK feature gaps: the known gaps are "no declarative Agent, no RAG, no CodeAct, no functional workflows," but a line-by-line comparison table is missing.
4. CodeAct maturity: it sits in the agent-framework-hyperlight (alpha) package; maturity and production-readiness.
5. Built-in evaluation set / judge system: the researched materials do not mention MAF offering a built-in golden dataset or judge framework, only "evaluation service integration" and OTel tracing. This judgment is based on "not seen," not an official statement of "nonexistence," flagged [To be verified].
6. Task-level budget guardrail: no mandatory budget-cap mechanism such as max_budget_usd was found, flagged [To be verified].
7. AutoGen's 2025 community criticisms: the three points — poor concurrency, poor documentation, and enterprise-user feedback — are a summary of community-level feedback; no formal response document from Microsoft was found, flagged [To be verified].
8. MAF 365 naming convention: the exact naming and product boundaries of Microsoft Agent Framework within the Microsoft 365 ecosystem have not been confirmed from official primary sources, flagged [To be verified].
9. Version numbers are time-sensitive: .NET 1.13.0 (2026-07-03) and MAF 1.0 GA (2026-04-02/03) are both data points from the 2026-09 search date.
10. Transparency / AI-generated-content labeling: no public material from MAF or AutoGen on transparency statements or AI-generated-content labeling policies was found.

8. References

1. Microsoft Agent Framework — official Microsoft Learn documentation. https://learn.microsoft.com/en-us/agent-framework/overview/
2. Microsoft Agent Framework at BUILD 2026: Agent Harness, Hosted Agents, CodeAct — Microsoft official. https://aka.ms/Build2026MicrosoftAgentFramework
3. Microsoft Agent Framework 1.0 Ends the Semantic Kernel Era — SourceFeed. https://sourcefeed.dev/a/microsoft-agent-framework-10-ends-the-semantic-kernel-era
4. Microsoft Agent Framework 1.0: .NET and Python 2026 — DigitalApplied. https://www.digitalapplied.com/blog/microsoft-agent-framework-1-0-dotnet-python-guide
5. Microsoft Agent Framework Developer Guide 2026 — Developer's Digest. https://www.developersdigest.tech/blog/microsoft-agent-framework-developer-guide-2026
6. Microsoft Agent Framework 1.0 — Unified SDK for AI Agents on .NET 10 — anhtu.dev. https://anhtu.dev/microsoft-agent-framework-1-0-unified-sdk-for-ai-agents-on-dotnet-10-1096
7. Microsoft Agent Framework vs Semantic Kernel for a Greenfield .NET Agent — Start Debugging. https://startdebugging.net/2026/06/microsoft-agent-framework-vs-semantic-kernel-for-a-greenfield-net-agent
8. Migrate a Semantic Kernel App to Microsoft Agent Framework 1.0 — Start Debugging. https://startdebugging.net/2026/07/migrate-a-semantic-kernel-app-to-microsoft-agent-framework-1-0
9. Semantic Kernel: Enterprise Agent Framework — Agent DevPro. https://agentdevpro.com/frameworks/semantic-kernel
10. Microsoft's Quiet Shift: Why Semantic Kernel Is Moving to Maintenance Mode — FrontierNews. https://www.frontiernews.ai/news/article/microsofts-quiet-shift-why-semantic-kernel-is-movi-23683b05