AI Agents Can Now Operate Inside Your .NET App: The Rise of Agentic UI
AI is changing how users interact with software.
For years, the standard model was simple: users clicked buttons, filled forms, navigated menus, and read dashboards.
Then came AI chat interfaces.
Now, the next shift is emerging: AI agents that can work inside the application itself.
Instead of simply answering a question, an agent can gather information, use tools, update application state, perform multi step tasks, and ask the user for approval when an action is important.
Microsoft is now bringing these capabilities closer to the .NET ecosystem through AG UI, the Microsoft Agent Framework, and new experimental Blazor AI components. Microsoft for Developers
What Is Agentic UI?
Traditional AI applications often follow this pattern:
User → Chat → AI → Response
Agentic applications are different:
User → AI Agent → Tools → Business Data → Actions → User
The agent is no longer just generating text. It can participate in the application's workflow.
For example, imagine an ERP application.
A manager could ask:
"Show me projects that are over budget and prepare a summary."
An agent could:
- Retrieve project information
- Analyze expenses
- Identify projects exceeding their budgets
- Generate a summary
- Display the findings inside the application
- Ask the manager for approval before taking further action
This is where Agentic UI becomes important.
Microsoft describes Agentic UI as an application experience where the user, agent, and application can work together while sharing state and maintaining visibility and control over agent actions. Microsoft for Developers
Why Chat Alone Isn't Enough
Chat is useful for questions.
But it becomes less effective when an agent starts doing actual work.
Imagine an agent that is:
- Calling multiple APIs
- Searching business data
- Running tools
- Waiting for results
- Updating application state
- Requesting approval
- Performing a multi step workflow
A simple chat window doesn't necessarily show users what is happening.
Users need answers to questions such as:
What is the agent doing?
What information is it using?
What will it change?
Does it need my approval?
What happened after I approved it?
Agentic UI is designed to make these interactions visible within the application instead of hiding everything behind a chat response.
Microsoft's New Blazor AI Components
On September 28, 2026, Microsoft introduced new experimental Blazor AI components for building Agentic UI experiences. Microsoft for Developers
These components provide building blocks for:
- Streaming agent responses
- Tool interactions
- Approval workflows
- Shared state
- Generative experiences
- Rendering agent output through Blazor components
This is significant because developers can combine AI interactions with the existing application UI rather than creating a completely separate chatbot experience.
An agent can become part of the application itself.
What Is AG UI?
A major piece of this ecosystem is AG UI, or Agent User Interaction Protocol.
AG UI standardizes communication between AI agents and user facing applications.
Agents can stream structured events to the client, including events related to messages, state changes, tool calls, and approvals. The client decides how those events should be displayed. Microsoft for Developers
A simplified flow looks like this:
AI Agent
↓
AG UI Protocol
↓
Web / Mobile / Desktop UI
↓
User
This separation is useful because the agent doesn't have to be tightly coupled to one particular frontend.
.NET Gets a First Class AG UI SDK
This is one of the most interesting developments for .NET developers.
On September 25, 2026, Microsoft announced a first class AG UI .NET SDK, developed in collaboration with CopilotKit. The SDK is available through NuGet and allows .NET services to communicate using the AG UI protocol. Microsoft for Developers
The SDK includes components such as:
AGUI.Abstractions
AGUI.Client
AGUI.Server
AGUI.Formatting
AGUI.Protobuf
A .NET service can expose an agent through AG UI, while a .NET application can consume an AG UI agent through the client SDK. Microsoft for Developers
Even more importantly, the protocol is designed to work across languages.
A .NET backend can communicate with clients or agents built using other supported technologies.
How Does It Work With Microsoft Agent Framework?
Microsoft Agent Framework provides the agent layer.
AG UI provides the communication layer between that agent and the user facing application.
A simplified architecture looks like this:
User
↓
Blazor / Web UI
↓
AG UI
↓
Microsoft Agent Framework
↓
AI Model + Tools
↓
APIs / Database / ERP
Microsoft's integration exposes an AIAgent through an AG UI HTTP endpoint. Responses can then be streamed to the client using Server Sent Events. Microsoft Learn
The client determines how the agent's messages, tool calls, approvals, and state changes are presented.
From Chatbots to Actions
This is where Agentic UI becomes more interesting than another AI chatbot.
Consider a CRM.
Today, a sales manager might need to:
- Open a customer record
- Review recent interactions
- Check quotations
- Review outstanding tasks
- Identify high priority leads
- Create follow up tasks
- Send emails
An agentic CRM could allow the manager to say:
"Prepare today's follow ups for my highest value leads."
The agent could gather the relevant information, recommend actions, and present those actions through the application's UI.
The manager could review them and approve specific actions.
The AI is not simply writing a response.
It is participating in the workflow.
Human Approval Is Critical
Giving an AI agent access to business systems introduces an important question:
Should the agent be allowed to do everything automatically?
In most business applications, the answer should be no.
Some actions are low risk:
Read customer information → Automatic
Generate a report → Automatic
Analyze expenses → Automatic
Create a draft quotation → Automatic
Send quotation → Approval
Change financial data → Approval
Issue refund → Approval
Delete records → Approval
AG UI supports human in the loop scenarios where an agent can request approval before continuing. Microsoft Learn
This is an important principle for enterprise AI:
Automation should increase productivity without removing human control over consequential decisions.
Shared State Changes the Experience
Another important capability is shared state.
The user, application, and agent may all need to see the same changing information.
For example:
User selects project
↓
Agent analyzes project
↓
Agent updates analysis state
↓
UI displays results
↓
User changes a parameter
↓
Agent continues with new state
AG UI includes mechanisms for synchronizing state between the client and agent. Microsoft Learn
This allows AI interactions to feel more like part of the application rather than a separate conversation window.
One Agent, Multiple Interfaces
Another advantage of a standardized protocol is that the same agent endpoint can support different clients.
For example:
.NET Agent
↓
AG UI
↙ ↓ ↘
Web Mobile Teams
Microsoft notes that an AG UI endpoint can serve different surfaces because the client decides how to render the events. Microsoft for Developers
This could be particularly valuable for businesses that already have multiple applications consuming the same backend services.
What Does This Mean for .NET Developers?
For developers working with:
- ASP.NET Core
- Blazor
- C#
- Microsoft Agent Framework
- Microsoft.Extensions.AI
- Azure services
- Enterprise APIs
the ecosystem for building agentic applications is becoming more complete.
Developers can now build an architecture where:
The AI handles reasoning and tools.
AG UI handles agent to application communication.
Blazor or another frontend handles the user experience.
The existing backend remains responsible for business rules and data.
That separation can make agentic applications easier to design and evolve.
Does This Mean Traditional UI Is Going Away?
Not at all.
This is probably one of the biggest misconceptions around agentic applications.
Businesses will still need dashboards, tables, forms, navigation, reports and conventional workflows.
AI should complement those interfaces.
A financial application, for example, may still need a detailed transaction table.
But instead of manually filtering thousands of transactions, a user could ask:
"Show me unusual transactions from this month."
The agent could perform the analysis and then present the results using the application's existing UI.
The future is likely to be traditional UI plus agentic interaction, rather than AI replacing every button and form.
What Businesses Could Build With Agentic UI
The possibilities extend well beyond chatbots.
CRM
Agents can analyze leads, prepare follow ups and assist sales teams.
ERP
Agents can analyze expenses, identify anomalies and summarize business performance.
Project Management
Agents can identify overdue tasks, summarize project status and recommend priorities.
Customer Support
Agents can investigate customer issues, retrieve account information and prepare resolutions.
Finance
Agents can analyze transactions, prepare reports and flag unusual activity.
Internal Business Applications
Employees could interact with complex systems using natural language while still using the application's existing interface.
There Is Still a Catch
The new Blazor AI components are currently experimental. Microsoft for Developers
That means businesses shouldn't immediately rebuild production applications around them.
There are also bigger engineering challenges to solve:
- Agent reliability
- Security and permissions
- Data privacy
- Observability
- AI costs
- Tool authorization
- Error handling
- Human approval
- Prompt and model management
An agent that can perform actions is fundamentally different from an AI that only generates text.
The more authority an agent receives, the more carefully the surrounding system needs to be designed.
The Bigger Shift
For decades, software has primarily been built around:
Menus → Forms → Buttons → Dashboards
Then conversational AI introduced:
Chat → Natural Language → Answers
Agentic applications are moving toward:
Natural Language → Reasoning → Tools → Actions → Human Approval
AG UI and Microsoft's latest .NET work are part of this transition.
The goal isn't simply to put an AI chatbot inside every application.
The bigger opportunity is to build software where users and AI agents can work together within the same business environment.
Final Takeaway
AI agents are moving beyond generating text.
They can now participate in application workflows, interact with tools, synchronize state and request human approval when necessary.
With the new AG UI .NET SDK and experimental Blazor AI components, Microsoft is giving .NET developers a clearer path toward building these experiences. Microsoft for Developers
For businesses building custom software, this could change how applications are designed.
The future application may not simply ask:
"Which button do you want to click?"
It may understand:
"What are you trying to accomplish?"
And then help you get there.