Building Autonomous AI Agents with .NET: The Microsoft Agent Framework Explained

Welcome back to our series on AI building blocks for .NET. In the first part, we covered Microsoft Extensions for AI (MEAI) and its unified interface for large language models. The second part introduced Microsoft.Extensions.VectorData for semantic search and RAG patterns. Now we dive into the third component: the Microsoft Agent Framework. While MEAI and VectorData enable conversation and knowledge retrieval, the Agent Framework brings autonomy. It allows AI to not only answer questions but also take actions, use tools, maintain context across conversations, and coordinate multiple agents to solve complex tasks. This framework reached its 1.0 release in April 2026 and is available for .NET (C#) and Python. Let's explore what AI agents are and how to build them with this SDK.

What Is an AI Agent and How Is It Different from a Simple Chatbot?

A chatbot typically receives user input, passes it to a language model, and returns the generated response. In contrast, an AI agent possesses autonomy. It can reason about a task, decide which tools to use, invoke those tools, evaluate the results, and determine the next step—all without requiring explicit step-by-step instructions. Think of it like handing a colleague a to-do list and letting them figure out the best way to accomplish it. They might search databases, run calculations, check APIs, or perform any action you've made available. The Microsoft Agent Framework enables this behaviour in .NET by building directly on the MEAI IChatClient abstraction.

How Does the Microsoft Agent Framework Build on MEAI?

The Agent Framework is designed to integrate seamlessly with the earlier building blocks. It leverages the IChatClient interface from Microsoft Extensions for AI (MEAI), which provides a uniform way to connect with different language model providers (such as Azure OpenAI, OpenAI, or local models). By using the same abstraction, developers can reuse existing MEAI configurations and easily migrate from simple chat scenarios to agent-powered applications. The framework adds agent-specific capabilities like tool calling, conversation memory, and multi-agent orchestration. It also includes a graph-based orchestration engine for complex workflows where multiple agents collaborate.

How Do You Create a Simple Agent with the Framework?

Creating your first agent is straightforward. Start by adding the NuGet package:

dotnet add package Microsoft.Agents.AI

Then, in a console application, you can create an agent using the .AsAIAgent() extension method on a chat client. Here's an example (named 01_hello_agent):

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("...");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME")
    ?? "gpt-5.4-mini";

AIAgent agent = new AzureOpenAIClient(
    new Uri(endpoint),
    new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(
        instructions: "You are good at telling jokes.",
        name: "Joker");

Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));

This code sets up an agent that specializes in jokes, then runs it with a prompt. The RunAsync method handles the entire conversation loop, including any tool calls if defined.

What Does the .AsAIAgent() Extension Method Do?

The .AsAIAgent() extension method is the key bridge between a standard chat client and an agent. It extends any object that implements IChatClient (or a compatible client like AzureOpenAIClient's chat client) to add agent behaviours. This method takes optional parameters: instructions (a system message that defines the agent's persona and constraints) and name (for identification). Under the hood, it wraps the chat client into an AIAgent instance that manages conversation history, tool registration, and the decision-making loop. This design ensures that you can leverage all the benefits of MEAI—like provider abstraction and dependency injection—while giving your AI autonomy. It's analogous to the .AsIChatClient() bridge that adapts provider SDKs to the MEAI standard.

What Production-Ready Features Does the Agent Framework Offer?

The framework is built for real-world applications. Key features include:

• Tool calling: Define custom functions (e.g., database queries, API calls) that the agent can autonomously invoke.
• Conversation memory: Maintain context across multiple turns, not just within a single prompt.
• Multi-agent orchestration: Coordinate several agents using a graph-based workflow. Each agent can be responsible for a subtask, and the graph defines how they interact.
• Streaming responses: Support for real-time output, useful for chat applications.
• OpenTelemetry integration: Monitor agent behaviour, tool usage, and performance.
• Extensibility: Plug in custom model providers or custom tool registries.

These features make the framework suitable for scenarios like automated customer support, data analysis pipelines, and multi-step research assistants.

How Does Multi-Agent Orchestration Work with Graph-Based Workflows?

For complex tasks, a single agent may not be enough. The Agent Framework includes a graph-based orchestration engine where you define nodes (agents) and edges (transitions) to create a workflow. For example, you might have an orchestrator agent that receives a user request, breaks it into subtasks, and delegates them to specialized agents—such as a search agent for information retrieval, a calculation agent for math, and a summary agent to combine results. The graph can include conditional branching, loops, and parallel execution. This approach allows you to build robust, maintainable systems where each agent focuses on a single domain, much like microservices in software architecture. The framework handles state management, error recovery, and message routing automatically.