On October 1, 2025, Microsoft published the first preview of Microsoft Agent Framework, an open-source framework for building AI agents and multi-agent workflows in .NET and Python. The .NET package, Microsoft.Agents.AI, appeared on NuGet that day, with a Python implementation in the same repository, and Microsoft's documentation describes the framework as the direct successor to both Semantic Kernel and AutoGen, created by the same teams. For .NET developers who had been choosing between two overlapping Microsoft projects, the preview signaled where Microsoft's agent investment would go next.

Key Facts#

  • Release: Microsoft.Agents.AI 1.0.0-preview.251001.1 was published to NuGet on October 1, 2025, and the repository tagged its first .NET build the same day.
  • Languages: .NET and Python with consistent APIs, installed with dotnet add package Microsoft.Agents.AI or pip install agent-framework.
  • Lineage: Microsoft's docs call it the direct successor to Semantic Kernel and AutoGen, built by the same teams.
  • Headline features: graph-based workflows with streaming, checkpointing, human-in-the-loop and time-travel support, a middleware pipeline, built-in OpenTelemetry observability, multiple model providers and a developer UI called DevUI.
  • Compatibility: the NuGet package listed support for .NET 8, .NET Standard 2.0 and .NET Framework.
  • Outcome: version 1.0.0 of the .NET package shipped on NuGet on April 2, 2026.

What Happened#

The preview arrived as a public GitHub repository, microsoft/agent-framework, with .NET and Python implementations side by side. Its README at launch described a comprehensive multi-language framework for building, orchestrating and deploying AI agents, and listed a set of highlights that mapped closely to what teams had struggled to assemble themselves: graph-based workflows that can stream intermediate results, persist checkpoints and pause for human approval; a middleware system for request and response processing and exception handling; OpenTelemetry-based tracing; support for multiple agent providers; and DevUI, an interactive interface for testing and debugging agents and workflows. An experimental area called AF Labs was set aside for benchmarking, reinforcement learning and research features.

The first tagged .NET build laid down the core abstractions: agents and conversation threads, chat-client-based agents, OpenAI and Azure OpenAI integrations, tool abstractions such as a code interpreter, an orchestration runtime, dependency injection samples and observability hooks. The quickstart in the README showed how little code a basic agent needed:

C#
using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")!;
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME")!;

var agent = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential())
    .GetOpenAIResponseClient(deploymentName)
    .CreateAIAgent(
        name: "HaikuBot",
        instructions: "You are an upbeat assistant that writes beautifully.");

Console.WriteLine(await agent.RunAsync("Write a haiku about Microsoft Agent Framework."));

That sample reflects the preview-era API. Method names and packaging changed on the way to 1.0, so treat it as a snapshot of the launch rather than current guidance.

Under the hood, the design leans on Microsoft.Extensions.AI. The framework's ChatClientAgent wraps any IChatClient, which means every provider with a Microsoft.Extensions.AI adapter can power an agent, and the middleware and telemetry conventions that .NET developers already used for plain chat calls carry over to agents.

Background#

Before the Agent Framework, Microsoft offered two separate answers to the question of how to build agents. Semantic Kernel was the enterprise-oriented SDK for adding language models to applications, with plugins, filters, vector store connectors and, later, agent abstractions. AutoGen, which came out of Microsoft Research, focused on multi-agent conversation patterns and experimentation. Both had active communities, but they used different programming models, and teams often had to pick one and later bolt on ideas from the other.

Meanwhile, the building blocks underneath had stabilized. Microsoft.Extensions.AI reached general availability in May 2025, giving .NET a stable IChatClient and IEmbeddingGenerator contract (see our story on Microsoft.Extensions.AI reaching GA), and the official MCP C# SDK had been available in preview since April 2025. A new framework could build on those layers instead of reinventing them, which is essentially what Agent Framework did.

Why It Matters for Developers#

The preview mattered less for its individual features than for the direction it set. With Microsoft stating that the framework succeeds both Semantic Kernel and AutoGen, new agent projects had a clear default, and existing projects gained a migration target rather than an uncertain future.

Practical guidance for .NET teams at the time, and still relevant for anyone migrating today:

  • Separate agents from workflows. Microsoft's documentation recommends agents for open-ended or conversational tasks that need autonomous tool use and planning, and workflows when a process has well-defined steps and multiple agents or functions must coordinate. Deciding this early prevents the common failure mode of an agent that is asked to follow a rigid business process. Our AI agent architecture patterns guide walks through both styles.
  • Keep business logic behind abstractions. Because agents sit on IChatClient, code written against Microsoft.Extensions.AI today moves into agents with little change.
  • Plan migrations deliberately. Semantic Kernel applications did not break on October 1, 2025. Evaluate which parts, such as plugins, prompt templates or custom orchestration, map cleanly onto agents and workflows, and migrate incrementally. Our Semantic Kernel guide covers where it still fits.
  • Instrument from the start. The built-in OpenTelemetry support means agent runs, tool calls and model calls can be traced with the same tooling you use for web services.
  • Respect the preview label. Early adopters had to absorb API changes throughout the preview period, so pinning package versions and isolating framework types behind your own interfaces was a sensible defense.

The inclusion of .NET Standard 2.0 and .NET Framework support also stood out. It meant teams maintaining older line-of-business applications could experiment with agents without first completing a full migration to modern .NET.

What's Next#

The preview ran for six months. The .NET 1.0.0 packages landed on NuGet on April 2, 2026, with support for .NET 8, .NET Standard 2.0 and .NET Framework 4.7.2, and Microsoft announced the production-ready release shortly afterward, which we cover in Microsoft Agent Framework 1.0. The framework has kept a rapid cadence since then: the .NET packages reached version 1.22.0 in September 2026, and a Go implementation is now in public preview.

For a full tutorial covering agents, tools, MCP integration and workflows in C#, see our Microsoft Agent Framework guide.

Sources#