How Microsoft Agent Framework + AG-UI Enable Agentic UX & Generative UI
TL;DR
Microsoft Agent Framework (MAF) and AG-UI combine to create interactive agents with clean UI and streaming responses. MAF handles reasoning and workflows, while AG-UI standardizes agent-frontend communication for seamless user experiences.
Key Takeaways
- •MAF provides agents with tools, workflows, and state management for multi-step processes.
- •AG-UI standardizes communication between agents and UIs, enabling streaming, state updates, and tool invocations.
- •The integration allows agents to be UI-ready without custom wiring, supporting multiple frontends like Blazor and CopilotKit.
- •It enhances user trust with visible state, tool use, and intermediate workflow steps for debugging and collaboration.
Tags
Building with the Microsoft Agent Framework + AG-UI
Microsoft’s Agent Framework (MAF) is an open-source agent framework that has recently emerged, offering exceptional ways to build agents and multi-step workflows in .NET or Python. Paired with AG-UI, the frontend/runtime layer that enables those agents to appear in your app with a clean UI, streaming responses, and shared state, etc., delivers a seamless agentic experience.
The integration between the two is simple but powerful: MAF handles the reasoning and tool-use, and AG-UI bridges the interactions between the agent and the users.
Microsoft Agent Framework (MAF) and AG-UI together offer a clean separation:
- MAF handles the agent’s intelligence, workflows, memory, and tool use.
- AG-UI is the open protocol that standardizes how agents communicate with user interfaces.
Once an agent speaks AG-UI, it becomes immediately compatible with any AG-UI-aware frontend, including Microsoft’s own Blazor client and CopilotKit.
This combination is what turns MAF agents from “backend processes” into interactive, stateful, user-facing agents.
What the Microsoft Agent Framework Provides
MAF provides the core building blocks:
- Agents that call models, use tools, and keep state across turns.
- Workflows for multi-step or multi-agent processes.
- Model and memory providers so your agents can store data or thread context.
It’s practical if you want to move past “chat completion” and give the model structure, state, and the ability to act.
What AG-UI Adds to the Picture
AG-UI is the open protocol that defines how an agent communicates with a user interface.
It standardizes things like:
- Streaming messages
- State updates
- Tool invocations
- UI events
- Multi-agent routing
- Interruptions / tool-progress events
- Frontend → agent actions
This removes the need to design your own transport, your own formatting, your own event system, or your own UI message schema.
Instead of every framework inventing its own UI contract, AG-UI is the shared layer they converge on.
Microsoft Agent Framework + AG-UI
1. MAF agents become UI-ready out of the box
- No additional custom wiring.
- No custom WebSockets.
- No bespoke JSON formats.
The agent speaks AG-UI, which removes any additional complexities.
2. Multi-step workflows can surface naturally in UI
Because AG-UI supports state sync and streaming, a MAF workflow can show:
- intermediate states
- partial outputs
- tool progress
- agent-to-agent handoffs
- moments where the agent needs user input
This is critical for user trust and usability.
3. Typed state becomes visible to the user
MAF agents often maintain a structured state (objects, lists, workflow context).
AG-UI transports this state to the frontend, where it can drive live UI components.
4. Use of tools
AG-UI can show:
- When a tool was invoked
- What parameters were used
- What the tool returned
This is a major improvement over hidden function-calling flows.
5. Use any AG-UI-compatible frontend
Once your MAF agent speaks AG-UI, you can plug it into:
- CopilotKit
- Microsoft Blazor
- Terminal Client
- Kotlin SDK (mobile, JVM)
This gives the agent a portable, future-proof interface layer.
Why This Matters for Developers
A complete agent loop
Agent → protocol → frontend → user → agent
No custom engineering required.
A more interpretable agent
With streaming, intermediate states, and exposed tool use, you can debug and trust the agent in a way plain chat completions don’t allow.
This allows a path to build real applications
- SaaS copilots
- Co-creation copilots
- automation agents
All while retaining clear structure and maintainability.
Additionally, the developer doesn't need to reinvent the wheel.
--> MAF handles reasoning + tools.
--> AG-UI handles communication + events.
--> The user is now able to collaborate with the agent in real time.
The stack is clean.
Summary
Microsoft Agent Framework gives you an agent with: tools, workflows, state, orchestration, and model thinking.
AG-UI gives that agent a standardized way to interact with the user, whether on mobile or desktop.
Together, they let you build agents that aren’t constrained to the backend, but usable, visible, and connected to real applications.
To stay up to date, please follow CopilotKit on Twitter and join the Discord community.