{"id":5165,"date":"2026-09-25T17:13:30","date_gmt":"2026-09-25T17:13:30","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/09\/25\/ag-ui-protocol-now-has-a-first-class-net-sdk\/"},"modified":"2026-09-25T17:13:30","modified_gmt":"2026-09-25T17:13:30","slug":"ag-ui-protocol-now-has-a-first-class-net-sdk","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/09\/25\/ag-ui-protocol-now-has-a-first-class-net-sdk\/","title":{"rendered":"AG-UI Protocol now has a first-class .NET SDK"},"content":{"rendered":"

The .NET team is pleased to announce that we\u2019ve contributed a .NET SDK for AG-UI<\/a> in collaboration with CopilotKit<\/a>. The AG-UI .NET SDK lives in the AG-UI repository<\/a> alongside the TypeScript and Python SDKs, published on NuGet under the MIT license. Any .NET service can now speak AG-UI directly. The Microsoft Agent Framework (MAF) AG-UI support for .NET is now based on the AG-UI .NET SDK.<\/p>\n

What is AG-UI?<\/h2>\n

Agents break the traditional request-and-response paradigm. They are long-running, stream tokens as they work, delegate to subagents, and invoke tools mid-response. Without a shared protocol, each agent framework or service can expose a different streaming format, leaving application developers to parse chunks, track state, and map framework-specific events to UI. This creates boilerplate that you must maintain, and it can break whenever the event format shifts.<\/p>\n

AG-UI (Agent-User Interaction Protocol)<\/a> standardizes how agents communicate with user-facing applications.<\/p>\n

\"A<\/p>\n

It streams the agent lifecycle as typed events, grouped into several categories<\/a>. The frontend listens for RUN_STARTED<\/code>, TEXT_MESSAGE_CONTENT<\/code>, STATE_DELTA<\/code>, and the other events without caring which framework produced them. State events keep the agent, the app, and the user in sync. How those events are displayed is the client\u2019s choice, so the surface can be a web app, terminal, mobile app, or even a chat platform like Slack or Teams.<\/p>\n

The .NET SDK brings that capability to C#. A backend emits those events natively, and a client consumes them from an agent written in any supported language.<\/p>\n

Quickstart<\/h2>\n

The SDK works in both directions. AGUI.Server<\/code> turns an agent into an AG-UI endpoint, and AGUI.Client<\/code> lets a .NET application consume one. The server and client support is built on a common set of AG-UI primitives.<\/p>\n

dotnet add package AGUI.Server<\/code><\/pre>\n
Your agent is an IChatClient<\/code>, the standard chat abstraction from Microsoft.Extensions.AI<\/code>. Assuming your app defines a CreateChatClient()<\/code> method that returns a configured IChatClient<\/code>, register the client and the AG-UI serializer:<\/p>\n
using AGUI.Abstractions;\nusing AGUI.Server;\nusing Microsoft.AspNetCore.Http.Json;\nusing Microsoft.Extensions.AI;\nusing Microsoft.Extensions.Options;\n\nvar builder = WebApplication.CreateBuilder(args);\nbuilder.Services.AddSingleton(CreateChatClient());\nbuilder.Services.Configure<JsonOptions>(options =>\n    options.SerializerOptions.TypeInfoResolverChain.Insert(\n        0,\n        AGUIJsonUtilities.DefaultTypeInfoResolver));\n\nvar app = builder.Build();\n\napp.MapPost(\"\/\", (\n    RunAgentInput input,\n    IChatClient chatClient,\n    IOptions<JsonOptions> jsonOptions,\n    CancellationToken cancellationToken) =>\n{\n    var context = input.ToChatRequestContext(\n        jsonOptions.Value.SerializerOptions);\n\n    var events = chatClient\n        .GetStreamingResponseAsync(\n            context.Messages,\n            context.ChatOptions,\n            cancellationToken)\n        .AsAGUIEventStreamAsync(context, cancellationToken);\n\n    return TypedResults.ServerSentEvents(events);\n});\n\nawait app.RunAsync();<\/code><\/pre>\n
ToChatRequestContext<\/code> unpacks the incoming RunAgentInput<\/code>, the protocol\u2019s request payload, into the messages and options your IChatClient<\/code> expects.<\/p>\n
AsAGUIEventStreamAsync<\/code> turns the response stream back into protocol events. It emits RUN_STARTED<\/code> and RUN_FINISHED<\/code> around the run, closes open text and reasoning blocks before switching to a different message or tool call, and collapses multiple interrupts into a single terminal RUN_FINISHED<\/code>.<\/p>\n
The SDK handles the protocol. The web server is yours, which is why Agent Framework\u2019s ASP.NET Core package wraps these same primitives as AddAGUIServer()<\/code> and MapAGUIServer()<\/code>.<\/p>\n
In Agent Framework, the same endpoint takes only a few lines. Given an existing IChatClient<\/code> named chatClient<\/code>, the following code creates and hosts the agent. Read the full walkthrough on Microsoft Learn<\/a> for a complete server and client.<\/p>\n
dotnet add package Microsoft.Agents.AI.Hosting.AGUI.AspNetCore --prerelease<\/code><\/pre>\n
using Microsoft.Agents.AI;\nusing Microsoft.Agents.AI.Hosting.AGUI.AspNetCore;\nusing Microsoft.Extensions.AI;\n\nvar builder = WebApplication.CreateBuilder(args);\nbuilder.Services.AddAGUIServer();\n\nvar app = builder.Build();\n\nAIAgent agent = chatClient.AsAIAgent(\n    name: \"AGUIAssistant\",\n    instructions: \"You are a helpful assistant.\");\n\napp.MapAGUIServer(\"\/\", agent);\nawait app.RunAsync();<\/code><\/pre>\n
AGUI.Client<\/code> handles the other direction, connecting a .NET application to any AG-UI agent.<\/p>\n
dotnet add package AGUI.Client<\/code><\/pre>\n
using AGUI.Client;\n\nusing var httpClient = new HttpClient();\n\nvar chatClient = new AGUIChatClient(\n    new(httpClient, \"http:\/\/localhost:5001\"));<\/code><\/pre>\n
AGUIChatClient<\/code> is an IChatClient<\/code>, so it works anywhere your code already takes an IChatClient<\/code>. The agent on the other end can be written in Python, TypeScript, or C#, and your code does not change.<\/p>\n
Once your endpoint speaks AG-UI, any AG-UI client can drive it: a .NET application through AGUI.Client<\/code>, or a React frontend through CopilotKit<\/a>. The CopilotKit Interactive Dojo has running examples<\/a> against a .NET backend.<\/p>\n
The repository has worked examples<\/a> for each part of the protocol. There is one client and server pair per step, covering chat, backend and frontend tools, human in the loop, shared state, reasoning, multimodal input, interrupts, parallel tool calls, protobuf, and telemetry.<\/p>\n
Architecture<\/h2>\n
Here is how everything works together. A request arrives from any AG-UI client, the endpoint hands it to your agent in Microsoft Agent Framework or your own agent code, and the response streams back as protocol events while the agent calls your tools and the model.<\/p>\n
\"An<\/p>\n
The packages<\/h2>\n
The SDK ships as five packages on NuGet: protocol types, wire formatters, protobuf support, an HTTP client, and a framework-agnostic server adapter built on Microsoft.Extensions.AI<\/code>.<\/p>\n\n\n\n\n\n\n\n\n\n
Package<\/th>\nWhat it is<\/th>\n<\/tr>\n<\/thead>\n
AGUI.Abstractions<\/code><\/a><\/td>\nProtocol model: events, messages, tools, capabilities, interrupts, state, and the source-generated serializer<\/td>\n<\/tr>\n
AGUI.Formatting<\/code><\/a><\/td>\nWire format abstraction and the default Server-Sent Events implementation<\/td>\n<\/tr>\n
AGUI.Protobuf<\/code><\/a><\/td>\nOpt-in protobuf codec generated from the TypeScript .proto<\/code> definitions. It covers a subset of event types. SSE is the default and carries all of them<\/td>\n<\/tr>\n
AGUI.Client<\/code><\/a><\/td>\nConsumes AG-UI<\/td>\n<\/tr>\n
AGUI.Server<\/code><\/a><\/td>\nProduces AG-UI<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
The client and server packages pull in the abstractions they need, so most applications reference one of them.<\/p>\n
What this means for Microsoft Agent Framework<\/h2>\n
Agent Framework, our SDK for building AI agents in .NET and Python, used to include its own implementation of the AG-UI protocol. It now depends on the AGUI.*<\/code> packages from NuGet and keeps the ASP.NET Core integration that turns an agent into an endpoint.<\/p>\n
The protocol is maintained in the AG-UI C# SDK and stays wire-compatible with the TypeScript and Python SDKs. See the migration notice<\/a> for full details.<\/p>\n
For existing Agent Framework users, the programming model is unchanged, though a few APIs were renamed:<\/p>\n\n\n\n\n\n\n\n\n
Before<\/th>\nNow<\/th>\n<\/tr>\n<\/thead>\n
AddAGUI()<\/code>, MapAGUI()<\/code><\/td>\nAddAGUIServer()<\/code>, MapAGUIServer()<\/code><\/td>\n<\/tr>\n
Microsoft.Agents.AI.AGUI<\/code> namespace<\/td>\nAGUI.Client<\/code>, AGUI.Server<\/code>, AGUI.Abstractions<\/code><\/td>\n<\/tr>\n
AGUIChatClient<\/code> positional constructor<\/td>\nOptions-based constructor<\/td>\n<\/tr>\n
Reading the originating request<\/td>\nchatOptions.TryGetRunAgentInput(out RunAgentInput? agentInput)<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
The event format is unchanged, so existing frontends keep working against an upgraded backend without changes of their own.<\/p>\n
Why this matters<\/h2>\n
Any .NET backend can speak the protocol.<\/strong> A worker service, internal API, or existing line-of-business application can expose an agent over AG-UI on its own. No agent framework is required.<\/p>\n
One backend can serve many surfaces.<\/strong> The client decides how to render the events, so the same endpoint serves a web app, terminal, mobile client, or chat platform like Slack and Teams.<\/p>\n
Your existing code remains the same.<\/strong> IChatClient<\/code> is the only integration point. You can consume AG-UI from .NET Framework 4.7.2 and later, and expose an endpoint from current .NET.<\/p>\n
Interoperate across languages.<\/strong> The shared wire protocol keeps the C#, TypeScript, and Python SDKs compatible, so a .NET backend can work with clients built using any of them.<\/p>\n
Get started<\/h2>\n
The AG-UI .NET SDK provides one C# implementation of AG-UI, published on NuGet and usable from any .NET service. Agent Framework consumes it, and so can you.<\/p>\n