{"id":3981,"date":"2026-05-04T17:51:19","date_gmt":"2026-05-04T17:51:19","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/05\/04\/microsoft-agent-framework-building-blocks-for-ai-part-3\/"},"modified":"2026-05-04T17:51:19","modified_gmt":"2026-05-04T17:51:19","slug":"microsoft-agent-framework-building-blocks-for-ai-part-3","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/05\/04\/microsoft-agent-framework-building-blocks-for-ai-part-3\/","title":{"rendered":"Microsoft Agent Framework \u2013 Building Blocks for AI Part 3"},"content":{"rendered":"

Welcome back to the building blocks for AI in .NET series! In part one<\/a>, we explored Microsoft Extensions for AI (MEAI) and how it provides a unified interface for working with large language models. In part two<\/a>, we dove into Microsoft.Extensions.VectorData and how it brings semantic search and RAG patterns to .NET. Today, we\u2019re exploring the third building block: the Microsoft Agent Framework<\/strong>.<\/p>\n

Up to this point, we\u2019ve been building the foundation. MEAI gave us a universal way to talk to models, and VectorData gave us the ability to store and search knowledge. But what if you want an AI that can do things<\/em>? Not just answer questions, but take actions, use tools, remember context across conversations, and coordinate with other agents to solve complex problems? That\u2019s where agents come in.<\/p>\n

What is an AI agent?<\/h2>\n

An AI agent is more than a chatbot. A chatbot receives input, passes it to a model, and returns the output. An agent, on the other hand, has autonomy<\/em>. It can reason about a task, decide which tools to use, call those tools, evaluate the results, and decide what to do next. It can accomplish all this without forcing you to write explicit step-by-step instructions for every scenario.<\/p>\n

Think of it this way: if MEAI is like having a conversation with a colleague, an agent is like handing that colleague a to-do list and letting them figure out how to get it done. They might search for information, run calculations, check the weather, look up a database and use whatever tools you\u2019ve made available to them.<\/p>\n

The Microsoft Agent Framework<\/a> provides a production-ready SDK for building these intelligent agents in .NET (and other languages like Python, though we\u2019ll focus on C# here). It achieved its 1.0 release<\/strong> in April 2026 and supports everything from simple single-agent scenarios to complex multi-agent workflows with graph-based orchestration.<\/p>\n

Your first agent<\/h2>\n

Let\u2019s start simple. If you\u2019ve used MEAI and\/or read Part 1<\/a>, the Agent Framework will feel familiar because it builds directly on top of IChatClient<\/code>. Create a console app, then install the agent framework:<\/p>\n

dotnet add package Microsoft.Agents.AI<\/code><\/pre>\n
Here\u2019s all it takes to create an agent (01_hello_agent<\/a>):<\/p>\n
using Azure.AI.OpenAI;\r\nusing Azure.Identity;\r\nusing Microsoft.Agents.AI;\r\n\r\nvar endpoint = Environment.GetEnvironmentVariable(\"AZURE_OPENAI_ENDPOINT\")\r\n    ?? throw new InvalidOperationException(\"AZURE_OPENAI_ENDPOINT is not set.\");\r\nvar deploymentName = Environment.GetEnvironmentVariable(\"AZURE_OPENAI_DEPLOYMENT_NAME\")\r\n    ?? \"gpt-5.4-mini\";\r\n\r\nAIAgent agent = new AzureOpenAIClient(\r\n    new Uri(endpoint),\r\n    new DefaultAzureCredential())\r\n    .GetChatClient(deploymentName)\r\n    .AsAIAgent(\r\n        instructions: \"You are good at telling jokes.\",\r\n        name: \"Joker\");\r\n\r\nConsole.WriteLine(await agent.RunAsync(\"Tell me a joke about a pirate.\"));<\/code><\/pre>\n
Notice the .AsAIAgent()<\/code> extension method. Just like .AsIChatClient()<\/code> bridges a provider\u2019s SDK to the MEAI abstraction, .AsAIAgent()<\/code> takes that a step further and wraps it in an agent that can manage sessions, tools, and memory. This works with multiple providers, including Azure OpenAI, OpenAI, GitHub Models, Microsoft Foundry, or even local models via Foundry Local or Ollama.<\/p>\n
The agent also supports streaming out of the box:<\/p>\n
await foreach (var update in agent.RunStreamingAsync(\"Tell me a joke about a pirate.\"))\r\n{\r\n    Console.Write(update);\r\n}<\/code><\/pre>\n
Giving your agent tools<\/h2>\n
A joke-telling agent is fun, but agents become truly powerful when you give them tools. Tools are simply functions that the model can decide to call based on the user\u2019s request. The Agent Framework uses the same AIFunctionFactory<\/code> from MEAI, so if you\u2019ve already defined tools for your chat client, they work here too.<\/p>\n
Here\u2019s an agent with a weather tool (02_add_tools<\/a>):<\/p>\n
using System.ComponentModel;\r\nusing Microsoft.Agents.AI;\r\nusing Microsoft.Extensions.AI;\r\n\r\n[Description(\"Get the weather for a given location.\")]\r\nstatic string GetWeather(\r\n    [Description(\"The location to get the weather for.\")] string location)\r\n    => $\"The weather in {location} is cloudy with a high of 15\u00b0C.\";\r\n\r\nAIAgent agent = new AzureOpenAIClient(\r\n    new Uri(endpoint),\r\n    new DefaultAzureCredential())\r\n    .GetChatClient(deploymentName)\r\n    .AsAIAgent(\r\n        instructions: \"You are a helpful assistant\",\r\n        tools: [AIFunctionFactory.Create(GetWeather)]);\r\n\r\nConsole.WriteLine(await agent.RunAsync(\"What is the weather like in Amsterdam?\"));<\/code><\/pre>\n
When the user asks about the weather, the agent doesn\u2019t just guess but recognizes that it has a GetWeather<\/code> tool available, calls it with the appropriate parameter, and uses the result to formulate its response. You didn\u2019t have to write any \u201cif the user asks about weather, call this function\u201d logic. The model figures it out.<\/p>\n
The Description<\/code> attributes are important. They tell the model what the tool does and what each parameter means, which helps it decide when and how to use the tool. Think of them as the tool\u2019s instruction manual for the AI.<\/p>\n
Multi-turn conversations with sessions<\/h2>\n
Real conversations don\u2019t happen in a single exchange. Users ask follow-up questions, provide additional context, and expect the agent to remember what was discussed. The Agent Framework handles this with AgentSession<\/code> (03_multi_turn<\/a>):<\/p>\n
AgentSession session = await agent.CreateSessionAsync();\r\n\r\nConsole.WriteLine(\r\n    await agent.RunAsync(\"Tell me a joke about a pirate.\", session));\r\n\r\nConsole.WriteLine(\r\n    await agent.RunAsync(\r\n        \"Now add some emojis to the joke and tell it in the voice of a pirate's parrot.\",\r\n        session));<\/code><\/pre>\n
The session preserves the conversation history between calls. When the user asks to \u201cadd some emojis to the joke,\u201d the agent knows which joke is being referenced because the session maintains that context.<\/p>\n
Sessions can also be serialized and deserialized, which is essential for production scenarios where your agent runs in a stateless service:<\/p>\n
\/\/ Save the session state\r\nJsonElement sessionState = await agent.SerializeSessionAsync(session);\r\n\r\n\/\/ Later, restore it\r\nvar restoredSession = await agent.DeserializeSessionAsync(sessionState);\r\nConsole.WriteLine(\r\n    await agent.RunAsync(\"What were we just talking about?\", restoredSession));<\/code><\/pre>\n
Teaching your agent to remember<\/h2>\n
Sessions preserve conversation history, but what about longer-term memory? What if you want your agent to remember facts about the user across sessions \u2014 their name, preferences, or previous interactions?<\/p>\n
The Agent Framework provides AIContextProvider<\/code>, a mechanism for injecting contextual information into the agent\u2019s workflow. Here\u2019s a simplified version of the memory sample (04_memory<\/a>) that extracts and remembers user information:<\/p>\n
internal sealed class UserInfoMemory : AIContextProvider\r\n{\r\n    private readonly ProviderSessionState<UserInfo> _sessionState;\r\n    private readonly IChatClient _chatClient;\r\n\r\n    public UserInfoMemory(IChatClient chatClient)\r\n    {\r\n        _sessionState = new ProviderSessionState<UserInfo>(\r\n            _ => new UserInfo(),\r\n            GetType().Name);\r\n        _chatClient = chatClient;\r\n    }\r\n\r\n    protected override async ValueTask StoreAIContextAsync(\r\n        InvokedContext context,\r\n        CancellationToken cancellationToken = default)\r\n    {\r\n        var userInfo = _sessionState.GetOrInitializeState(context.Session);\r\n\r\n        if (userInfo.UserName is null\r\n            && context.RequestMessages.Any(x => x.Role == ChatRole.User))\r\n        {\r\n            var result = await _chatClient.GetResponseAsync<UserInfo>(\r\n                context.RequestMessages,\r\n                new ChatOptions()\r\n                {\r\n                    Instructions =\r\n                        \"Extract the user's name from the message if present.\"\r\n                },\r\n                cancellationToken: cancellationToken);\r\n\r\n            userInfo.UserName ??= result.Result.UserName;\r\n        }\r\n\r\n        _sessionState.SaveState(context.Session, userInfo);\r\n    }\r\n\r\n    protected override ValueTask<AIContext> ProvideAIContextAsync(\r\n        InvokingContext context,\r\n        CancellationToken cancellationToken = default)\r\n    {\r\n        var userInfo = _sessionState.GetOrInitializeState(context.Session);\r\n\r\n        var instructions = userInfo.UserName is null\r\n            ? \"Ask the user for their name.\"\r\n            : $\"The user's name is {userInfo.UserName}.\";\r\n\r\n        return new ValueTask<AIContext>(\r\n            new AIContext { Instructions = instructions });\r\n    }\r\n}<\/code><\/pre>\n
The AIContextProvider<\/code> has two key methods:<\/p>\n