Tutorials | The .NET Blog

Getting Started with Microsoft Agent Framework

Emiliano Montesdeoca — Thu, 05 Mar 2026 00:00:00 +0000

The Microsoft Agent Framework (MAF) is a .NET SDK for building multi-agent AI systems. Rather than a single “do everything” prompt, you compose specialized agents — each with their own tools and instructions — and let them hand off work to each other.

This tutorial walks you through building a simple two-agent system: a triage agent that routes requests and a resolver agent that handles them.

Prerequisites

.NET 8 or later
NuGet: Microsoft.AI.Agents.Core
An Azure OpenAI or OpenAI API key

Step 1: Install packages

dotnet new console -n AgentDemo
cd AgentDemo
dotnet add package Microsoft.AI.Agents.Core
dotnet add package Microsoft.SemanticKernel

Step 2: Define your first agent

Agents are defined with a name, instructions, and a set of tools (Semantic Kernel plugins):

using Microsoft.AI.Agents.Core;
using Microsoft.SemanticKernel;

var kernel = Kernel.CreateBuilder()
 .AddAzureOpenAIChatCompletion(
 deploymentName: "gpt-4o",
 endpoint: Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")!,
 apiKey: Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY")!
 )
 .Build();

var triageAgent = new ChatCompletionAgent
{
 Name = "TriageAgent",
 Instructions = """
 You are a triage agent. Classify incoming requests as either:
 - 'billing' — questions about invoices, payments, or subscriptions
 - 'technical' — questions about bugs, features, or how the product works
 Then hand off to the appropriate agent.
 """,
 Kernel = kernel
};

Step 3: Define the resolver agent

var resolverAgent = new ChatCompletionAgent
{
 Name = "ResolverAgent",
 Instructions = """
 You are a support resolver. You receive pre-triaged requests and provide
 clear, concise answers. Always end with a confirmation question.
 """,
 Kernel = kernel
};

Step 4: Set up handoff topology

MAF’s HandoffBuilder lets you declare a routing graph between agents:

var chat = new AgentGroupChat(triageAgent, resolverAgent)
{
 ExecutionSettings = new AgentGroupChatSettings
 {
 TerminationStrategy = new ApprovalTerminationStrategy()
 }
};

Step 5: Run the workflow

chat.AddChatMessage(new ChatMessageContent(
 AuthorRole.User,
 "My invoice from last month looks wrong — I was charged twice."
));

await foreach (var response in chat.InvokeAsync())
{
 Console.WriteLine($"[{response.AuthorName}]: {response.Content}");
}

MAF will call the triage agent first, which classifies the issue as “billing” and hands off to the resolver agent. You’ll see each agent’s turn in the output.

What to explore next

Tool calling — give agents access to APIs, databases, or file systems via SK plugins
Human-in-the-loop — use ApprovalTerminationStrategy to pause for human confirmation before high-risk actions
AG-UI integration — stream agent events to a frontend using the AG-UI protocol for real-time visibility
Observability — connect to Azure Monitor or OpenTelemetry to trace agent decisions

The MAF documentation and samples on GitHub cover production patterns including state persistence and long-running workflows.

Getting Started with Semantic Kernel

Emiliano Montesdeoca — Tue, 10 Feb 2026 00:00:00 +0000

Semantic Kernel (SK) is Microsoft’s open-source SDK for building AI orchestration into .NET (and Python/Java) applications. It’s the layer between your app code and LLMs: it handles prompts, plugins, memory, and multi-step planning so you don’t have to wire everything together manually.

This tutorial gets you from zero to a working SK-powered console app that calls an LLM and uses a plugin.

Prerequisites

.NET 8 or later
An OpenAI API key or an Azure OpenAI deployment

Step 1: Install the SDK

dotnet new console -n SkDemo
cd SkDemo
dotnet add package Microsoft.SemanticKernel

Step 2: Set up the kernel

The Kernel is the central object in SK. You configure it with an AI service (OpenAI, Azure OpenAI, or a local model):

using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder();

builder.AddOpenAIChatCompletion(
 modelId: "gpt-4o-mini",
 apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")!
);

Kernel kernel = builder.Build();

Step 3: Invoke a prompt

The simplest thing SK does: send a prompt to the LLM and get a response.

var result = await kernel.InvokePromptAsync(
 "Summarize the key features of .NET 10 in three bullet points."
);

Console.WriteLine(result);

That’s it for the basics. But SK’s real power is in plugins.

Step 4: Create a plugin

A plugin is a C# class whose methods SK can call as tools. Here’s a simple one:

using System.ComponentModel;
using Microsoft.SemanticKernel;

public class DatePlugin
{
 [KernelFunction, Description("Returns the current date and time.")]
 public string GetCurrentDate() => DateTime.UtcNow.ToString("R");
}

kernel.ImportPluginFromObject(new DatePlugin());

Step 5: Let the kernel call the plugin

Enable automatic function calling so the LLM can invoke plugins when needed:

var settings = new OpenAIPromptExecutionSettings
{
 ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions
};

var result = await kernel.InvokePromptAsync(
 "What is today's date? Format it nicely.",
 new KernelArguments(settings)
);

Console.WriteLine(result);

The model will call GetCurrentDate() automatically and incorporate the result into its response.

What to explore next

Planners — have SK break a complex task into steps and execute them
Memory — add semantic search over your documents using embeddings
Agents — build multi-agent workflows using the AgentGroupChat API

The Semantic Kernel repo on GitHub has a rich set of samples in dotnet/samples/ covering all of these scenarios.

Single-File Apps in .NET 10

Emiliano Montesdeoca — Thu, 15 Jan 2026 00:00:00 +0000

Single-file publishing has been part of .NET since version 5, but .NET 10 takes it to a new level with improved ahead-of-time (AOT) compilation, better trimming analysis, and smaller default output sizes. This tutorial walks you through publishing a real app as a single binary — no install required on the target machine.

Prerequisites

.NET 10 SDK installed (dotnet --version should show 10.x.x)
A console or ASP.NET Core app to work with

Step 1: Create a new console app

dotnet new console -n SingleFileDemo
cd SingleFileDemo

Step 2: Publish as a single file

The minimal publish command for a self-contained single-file app:

dotnet publish -c Release -r linux-x64 \
 --self-contained true \
 -p:PublishSingleFile=true \
 -o ./output

Replace linux-x64 with your target runtime identifier (win-x64, osx-arm64, etc.). The --self-contained true flag bundles the .NET runtime into the output binary.

After publishing, ./output/ contains a single executable file.

Step 3: Add trimming

Trimming removes unreachable code from the final binary, often cutting size by 60–80%:

<!-- Add to your .csproj -->
<PropertyGroup>
 <PublishSingleFile>true</PublishSingleFile>
 <SelfContained>true</SelfContained>
 <PublishTrimmed>true</PublishTrimmed>
 <TrimMode>full</TrimMode>
</PropertyGroup>

Then just run:

dotnet publish -c Release -r linux-x64 -o ./output

Step 4: Native AOT (optional but powerful)

For the smallest and fastest binaries, use Native AOT instead of single-file:

<PropertyGroup>
 <PublishAot>true</PublishAot>
</PropertyGroup>

Native AOT compiles your app to native machine code at publish time. There’s no JIT at runtime, which means near-instant startup and a much smaller memory footprint.

Note: Native AOT doesn’t support all reflection patterns. Run dotnet publish once and review any AOT compatibility warnings before committing to this approach.

Checking binary size

ls -lh ./output/
# -rwxr-xr-x 1 user staff 12M SingleFileDemo

With trimming + AOT on a simple console app, expect 5–15 MB depending on dependencies.

Wrapping up

Single-file publishing in .NET 10 is production-ready for most workloads. Start with PublishSingleFile=true, add trimming once your app is stable, and consider Native AOT if startup time or binary size are hard constraints.