Building with the Microsoft Agent Framework + CopilotKit

Microsoft’s Agent Framework (MAF) is an open source agent framework that has just come on the scene, and offers exceptional ways to build agents and multi-step workflows in .NET or Python. AG-UI is a frontend/runtime layer that lets those agents show up in your app with a clean UI, streaming responses, and shared state, etc.

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.

Check out MAF GitHub ⭐️

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.

Check out AG-UI's GitHub ⭐️

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 just speaks AG-UI.

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.

A path to real applications

You can build:

• SaaS copilots
• Co-creation copilots
• automation agents

All while retaining clear structure and maintainability.

Less reinventing the wheel

You don’t build:

• custom protocol layers
• custom WebSocket handlers
• custom state sync
• custom component libraries

MAF handles reasoning + tools.

AG-UI handles communication + events.

Your frontend handles experience.

The stack is clean.

Summary

Microsoft Agent Framework gives you the internal machinery of an agent: tools, workflows, state, orchestration, and model thinking.

AG-UI gives that agent a standardized way to interact with the outside world.

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.

‍