AiCybr

AG-UI Gets a First-Class .NET SDK: Packages, Protocol 1.0 and Microsoft Agent Framework Migration

By AiCybr Editorial · Published September 27, 2026

Microsoft's .NET team announced a first-class .NET SDK for AG-UI on September 25, 2026, developed with CopilotKit and published as MIT-licensed NuGet packages in the upstream AG-UI repository. The SDK lets .NET applications both expose agents over the Agent-User Interaction Protocol and consume AG-UI endpoints implemented in C#, Python, TypeScript or another compatible stack.

The current AG-UI .NET packages are at 1.0.0 on NuGet. The 1.0 release aligns the generated .NET models with the frozen AG-UI 1.0 JSON schema, makes clients declare protocol version 1.0, and adds producer-version validation on the client side. Microsoft's Agent Framework now builds its AG-UI support on these shared packages instead of maintaining a separate protocol implementation.

For developers, the practical change is a reusable wire layer between an agent runtime and its user-facing application. AG-UI carries typed lifecycle events for streamed text, tool calls, shared state, interrupts and other agent interactions, while the application remains responsible for rendering the experience.

What ships in the .NET SDK

Microsoft documents five core NuGet packages:

Package Role
AGUI.Abstractions Protocol events, messages, tools, capabilities, interrupts, state and serialization
AGUI.Formatting Wire-format abstraction and the default Server-Sent Events formatter
AGUI.Protobuf Optional protobuf codec for a subset of event types
AGUI.Client Consumes an AG-UI endpoint from .NET
AGUI.Server Exposes an agent as an AG-UI producer

The default transport in the .NET implementation is Server-Sent Events. SSE carries the full supported event set; protobuf is optional and currently covers a subset.

The 1.0.0 packages target .NET 8 while key packages such as AGUI.Abstractions and AGUI.Client also publish compatibility for .NET Standard 2.0 and .NET Framework 4.7.2. Microsoft's announcement says a .NET application can consume AG-UI from .NET Framework 4.7.2 and later, while exposing an endpoint uses current .NET server infrastructure.

Server and client paths

AGUI.Server is framework-agnostic and integrates through Microsoft.Extensions.AI. On the consuming side, AGUI.Client provides AGUIChatClient, which implements the standard IChatClient abstraction.

That means an application already written around IChatClient can point at a remote AG-UI endpoint without adopting the remote agent's implementation language. The endpoint can be backed by C#, Python or TypeScript as long as it speaks the same protocol.

For Microsoft Agent Framework, the ASP.NET Core hosting package remains the shortest server path:

dotnet add package Microsoft.Agents.AI.Hosting.AGUI.AspNetCore --prerelease

The current API registers AG-UI hosting with AddAGUIServer() and maps an agent endpoint with MapAGUIServer(). A standalone consumer can add the shared client package directly:

dotnet add package AGUI.Client

Microsoft's examples also cover backend and frontend tools, human-in-the-loop interactions, shared state, reasoning events, multimodal input, interrupts, parallel tool calls, protobuf and telemetry.

What changed for Microsoft Agent Framework

Agent Framework previously carried its own AG-UI implementation. It now depends on the upstream AGUI.* NuGet packages while retaining the ASP.NET Core integration used to host an AIAgent.

Existing Agent Framework applications have several API-name changes to check during an upgrade:

Previous API Current API
AddAGUI() AddAGUIServer()
MapAGUI() MapAGUIServer()
Microsoft.Agents.AI.AGUI namespace AGUI.Client, AGUI.Server, AGUI.Abstractions
Positional AGUIChatClient constructor Options-based constructor

Microsoft says the event format remains wire-compatible, so an existing AG-UI frontend can continue talking to an upgraded backend even though the .NET API surface changed.

This consolidation also separates protocol evolution from Agent Framework itself. The C# SDK now lives alongside the TypeScript and Python SDKs in the AG-UI repository, giving the implementations a common upstream protocol surface.

AG-UI's role beside MCP and A2A

AG-UI targets the agent-to-user-interface boundary. Its upstream documentation positions the three protocols around different connections: MCP supplies tools and external context to agents, A2A covers agent-to-agent communication, and AG-UI standardizes communication between agents and user-facing applications.

The distinction matters in an application architecture. A backend agent can use MCP to reach tools, communicate with another agent over A2A, then stream its lifecycle, state and tool interactions to a frontend over AG-UI. These protocols can therefore coexist in one system instead of competing for the same wire boundary.

AG-UI's typed event model is especially useful for long-running agent work because the UI can receive incremental text, state deltas, tool activity and interrupts instead of waiting for a single request-response payload.

Protocol 1.0 upgrade considerations

The upstream 1.0.0 release introduces breaking model changes for .NET consumers. Generated model names now follow the frozen 1.0 schema, optional nulls are omitted during serialization while payload nulls are preserved, and the client/server packages use the generated AGUIProtocol.Version value.

AGUI.Client sends protocol version 1.0 with RunAgentInput and validates the producer's protocol version. Teams upgrading from pre-1.0 packages should therefore test custom serializers, code that references renamed model types, and any middleware that inspects raw event payloads.

The protocol remains under active development around its broader ecosystem. Production deployments should pin package versions and run client/server compatibility tests during upgrades, particularly when applications depend on custom events or less common interaction patterns.

Deployment fit

The new SDK is most useful for .NET teams that want agent frontends without binding the UI to a single agent framework. Existing ASP.NET Core and Microsoft.Extensions.AI applications can expose an AG-UI boundary, while desktop, terminal, web or other clients can consume the same event stream.

It also gives mixed-language teams a clearer interoperability path. A C# application can consume an AG-UI agent implemented elsewhere, and a .NET-hosted agent can serve a React/CopilotKit frontend without inventing another application-specific streaming contract.

For Microsoft Agent Framework users, the immediate work is smaller: verify the renamed hosting APIs and package references, then test the existing frontend against the upgraded backend. For framework-independent .NET services, AGUI.Server and AGUI.Client make the protocol available directly through familiar Microsoft.Extensions.AI abstractions.

Bottom line

The first-class .NET SDK moves AG-UI from a framework-specific integration toward a shared C# protocol implementation. Version 1.0 provides five upstream packages, protocol-version negotiation and a common model surface that Microsoft Agent Framework now consumes directly.

The main engineering value is interoperability: .NET services can expose or consume agent interaction streams through one typed protocol while keeping model providers, agent frameworks and frontend technology independently replaceable.

Sources

Continue reading

AI CLM-8B: Open Contrastive Model Scores Agent Actions With Cached Embeddings

CLM-8B uses a frozen Qwen3-8B encoder and small contrastive heads to rank agent actions and verifier candidates. Here are its architecture, reported latency, benchmarks, requirements and deployment limits.

AI Julia 1: 144M Open Decision Model Runs on CPUs and WebGPU

Supersonic Labs' Julia 1 is a 144.3M Apache-2.0 decision model for classification, routing and scoring. Here are its CPU/WebGPU deployment options, benchmarks, limits and fit.

AI GLiNER2.5-Decide: 340M Open-Weight Decision Model Runs on CPUs

Fastino's GLiNER2.5-Decide is a 340M Apache-2.0 model for schema-defined classification, routing and triage. Here are its CPU latency, benchmark results, limits and deployment fit.