Building AI agents in C# and .NET: the 2026 stack

Building AI agents in C# and .NET in 2026 runs on a stack that finally consolidated, and knowing the layers saves teams from betting on a deprecated one. At the base, Microsoft.Extensions.AI provides the provider abstraction, the IChatClient interface that every model provider (Azure OpenAI, OpenAI, Ollama, Anthropic, and others) implements, so you write against one interface and swap providers freely. On top of it, Microsoft Agent Framework is the agent and orchestration layer, and it reached 1.0 general availability on April 3, 2026, unifying the previous two options, Semantic Kernel and AutoGen, into a single production-ready SDK built by the same teams. Semantic Kernel is now in maintenance mode and AutoGen is maintenance-only, so new agent work should start on Agent Framework. The upshot: .NET is no longer a second-class citizen for agents, it has a supported, first-class stack, and this explains what it is and how the pieces fit.

‍

We build production AI agents in .NET, on Orleans and the Microsoft agent stack, so this is a practitioner's map of the 2026 C#/.NET agent landscape and where the real decisions are.

‍

The stack, layer by layer

The current .NET AI stack is a clean progression, and each layer has a distinct job:

• Microsoft.Extensions.AI (the root). The foundational abstraction layer. It defines IChatClient and related interfaces that unify how you talk to any model provider, plus middleware for things like telemetry, caching, and tool invocation. Write your code against this, and the provider underneath (Azure OpenAI, OpenAI, Ollama, a local model) becomes a swappable detail. This is the layer everything else builds on.
• Microsoft Agent Framework (agents and orchestration). The layer that turns model calls into agents: agent abstractions, tool/function calling, memory, and multi-agent orchestration (sequential, concurrent, handoff, and group patterns). It reached 1.0 GA in April 2026 with stable APIs and long-term support, and it is where all of Microsoft's new agentic investment goes, MCP integration, A2A support, checkpointing, human-in-the-loop, and observability.
• The provider layer. Azure OpenAI, OpenAI, Anthropic, or local runtimes (Ollama, Foundry Local, ONNX), reached through the abstraction so the choice is not hard-wired into your logic.

‍

The mental model: Microsoft.Extensions.AI is how .NET talks to models, Agent Framework is how .NET builds agents on top of that, and the provider is a plug at the bottom. Get the layers right and the stack is coherent; conflate them and you end up coupling agent logic to a specific provider you later want to change.

‍

The Semantic Kernel question (get this right)

The single most important thing to get right in 2026 is the Semantic Kernel situation, because a lot of older material is now out of date. Semantic Kernel was the main .NET framework for LLM orchestration for years, but on April 3, 2026, Microsoft shipped Agent Framework 1.0 as the production-ready unification of Semantic Kernel and AutoGen, described as combining Semantic Kernel's enterprise foundations with AutoGen's orchestration innovations into one supported SDK. It is a successor, not a wrapper, built by the same teams.

‍

What that means practically: Semantic Kernel is now in maintenance, it receives critical bug fixes for at least a year after Agent Framework GA, but no new features, and AutoGen is maintenance-only, not for new projects. So the guidance is clear. Start new agent projects on Agent Framework. Existing stable Semantic Kernel agents can stay for now and plan a post-GA migration, especially if they need the new orchestration patterns, MCP, or A2A that only Agent Framework gets. Building a new .NET agent on Semantic Kernel in 2026 means building on a frozen framework, which is the mistake this section exists to prevent. If a tutorial tells you Semantic Kernel is the way to build new agents, check its date.

‍

Why .NET is a real choice for agents now

For a while, serious agent development felt like a Python-only world, most frameworks, examples, and tooling grew up there. That changed. With Agent Framework at GA, .NET has a first-class, Microsoft-backed agent SDK with the same core capabilities (multi-agent orchestration, MCP, A2A, checkpointing, observability) available in both .NET and Python from one framework. For teams already in the Microsoft ecosystem, this removes the old pressure to leave C# for agent work.

‍

The .NET stack also has a genuine strength for production agents: the runtime. Agents that need to run reliably at scale, handling many concurrent sessions, surviving failures, maintaining state, map naturally onto Microsoft Orleans, the distributed actor framework, which is why we build our agent infrastructure on it, including our open-source dotPilot orchestrator and Orleans-native rate-limiting and state-machine libraries. So the .NET agent story in 2026 is not just parity with Python, it is parity plus a strong distributed runtime for the reliability and scale that production agents actually need, the concerns we cover in AI agent observability and why AI agents are expensive.

‍

How to start a .NET agent project in 2026

Practical guidance for building a new agent in C#:

• Start on Agent Framework, not Semantic Kernel. New projects go on the GA framework that gets all the new features, MCP, A2A, orchestration, not the maintenance one.
• Write against Microsoft.Extensions.AI abstractions. Depend on IChatClient rather than a specific provider SDK, so you can swap models (cloud to local, one provider to another) without rewriting agent logic.
• Design for the runtime early. If the agent needs to scale or run reliably, plan for a distributed runtime (Orleans) from the start, rather than retrofitting concurrency and state later.
• Build in observability and guardrails from day one. Tracing, cost tracking, bounded loops, and human approval for consequential actions, the guardrails that make an agent safe to run, are architecture, not additions.
• Use MCP for tools. Connect the agent to tools through MCP so you build on the standard rather than hand-wiring integrations, covered in MCP explained.

‍

Do this and you get a .NET agent on the supported stack, portable across providers, ready to scale, and built on the current standards rather than a deprecated framework.

‍

The takeaway

The 2026 .NET AI agent stack is Microsoft.Extensions.AI at the root (the IChatClient provider abstraction) and Microsoft Agent Framework as the agent and orchestration layer, at 1.0 GA since April 3, 2026, unifying the now-maintenance Semantic Kernel and AutoGen into one supported SDK. New agent projects should start on Agent Framework, write against the Extensions.AI abstractions for provider portability, and plan for a distributed runtime like Orleans for scale. The headline for .NET teams: agent development is now first-class and Microsoft-backed, with MCP and A2A support and a strong distributed runtime, so C# is a real, and in some ways advantaged, choice for building production agents, not a compromise you make to stay in the ecosystem.

‍

If you want production AI agents built on the current .NET stack, Agent Framework, Extensions.AI, and Orleans for scale, that is exactly where our AI Dev Team work lives.

‍

FAQ

What is the best framework for building AI agents in .NET in 2026? Microsoft Agent Framework, which reached 1.0 GA on April 3, 2026. It unifies the former Semantic Kernel and AutoGen into one supported SDK with multi-agent orchestration, MCP and A2A support, checkpointing, and human-in-the-loop. New agent projects should start on it rather than Semantic Kernel.

‍

Is Semantic Kernel deprecated? It is in maintenance mode. Semantic Kernel receives critical bug fixes for at least a year after Agent Framework's GA but no new features, and Microsoft's new agentic investment goes into Agent Framework. Existing stable SK agents can remain for now, but new projects should start on Agent Framework.

‍

What is Microsoft.Extensions.AI? The foundational abstraction layer of the .NET AI stack. It defines IChatClient and related interfaces that unify how your code talks to any model provider (Azure OpenAI, OpenAI, Ollama, Anthropic, and more), plus middleware for telemetry, caching, and tool calls, so providers become swappable without rewriting your logic.

‍

Can you build production AI agents in C# instead of Python? Yes. With Microsoft Agent Framework at GA, .NET has a first-class, Microsoft-backed agent SDK with the same core capabilities as the Python version. .NET also pairs well with Microsoft Orleans for distributed, reliable, scalable agent runtimes, which is a real advantage for production systems.

‍

How do Microsoft.Extensions.AI and Agent Framework relate? They are different layers. Microsoft.Extensions.AI is the root abstraction for talking to models (the IChatClient interface). Microsoft Agent Framework builds on top of it to create agents and orchestrate multi-agent workflows. You write agent logic in Agent Framework against the Extensions.AI abstractions underneath.