Building Autonomous AI Agents in .NET with Microsoft Agent Framework

Introduction

Welcome to the third part of our series on the building blocks for AI in .NET. In Part 1, we examined Microsoft Extensions for AI (MEAI) and its role in providing a unified abstraction for interacting with large language models. Part 2 introduced Microsoft.Extensions.VectorData, which brings semantic search and RAG (Retrieval-Augmented Generation) capabilities to .NET applications. Now we turn to the next step: giving AI the ability to act independently and complete complex tasks on its own.

Thus far, we have been laying the groundwork. MEAI allows us to communicate with any language model through a common interface, and VectorData enables us to store and retrieve knowledge efficiently. But what if you want an AI that doesn't just answer questions, but actively performs actions—such as using tools, maintaining context across conversations, and even collaborating with other agents to solve sophisticated problems? That is precisely where the Microsoft Agent Framework comes into play.

What Is an AI Agent?

An AI agent is fundamentally different from a basic chatbot. A chatbot receives user input, forwards it to a model, and returns the output—essentially a request-response cycle. An agent, however, possesses autonomy. It can reason about a given task, decide which tools to employ, execute those tools, evaluate the results, and determine the next course of action—all without requiring you to write explicit, step-by-step instructions for every possible scenario.

Think of it this way: if MEAI is like having a conversation with a knowledgeable colleague, an agent is like handing that colleague a to-do list and trusting them to figure out how to complete it. Along the way, they might search for information, perform calculations, check the weather, query a database, or use any other tool you've provided.

The Microsoft Agent Framework is a production-ready SDK for building such intelligent agents in .NET (and other languages like Python, though our focus here is C#). It reached its 1.0 release in April 2026 and supports everything from straightforward single-agent scenarios to complex multi-agent workflows using graph-based orchestration.

Building Your First Agent

Let's start with a simple example. If you're already familiar with MEAI from Part 1, the Agent Framework will feel natural because it builds directly on top of IChatClient. Create a new console application and install the package:

dotnet add package Microsoft.Agents.AI

Here is the complete code needed to create and run your first agent (a joke-telling assistant):

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

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
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."));

Notice the .AsAIAgent() extension method. This works similarly to how .AsIChatClient() bridges a provider's SDK to the MEAI abstraction, but here it elevates the chat client to a fully autonomous agent.

Key Capabilities of the Agent Framework

Tool Use

Agents can be equipped with custom tools—functions they can call during task execution. The framework handles tool registration, invocation, and result reporting seamlessly.

Memory and Context

Agents maintain conversational memory, allowing them to recall earlier exchanges and build on them. This enables coherent multi-turn interactions.

Multi-Agent Orchestration

For complex tasks, you can define multiple agents that work together under a graph-based orchestration model. Each agent specializes in a subtask and communicates results to others.

Production Readiness

With the 1.0 release, the framework includes robust error handling, logging, and scalability features, making it suitable for enterprise applications.

Next Steps

This introduction gives you the flavor of building an agent with just a few lines of code. In upcoming articles, we'll explore more advanced scenarios: adding tools, managing memory, orchestrating multiple agents, and deploying agents in production environments. For now, try running the example above—customize the instructions and see how the agent autonomously crafts responses.

To dive deeper, refer to the official Microsoft Agent Framework documentation.