If you've been exploring the Microsoft Agent Framework, you've probably seen the Python DevUI example showcased prominently in the docs. DevUI is a fantastic inner-loop tool — it lets you visually inspect your agents: their messages, reasoning steps, tool calls, and conversation state, all in a browser dashboard while you develop locally. Think of it as Swagger UI, but for AI agents.
The problem? When I went looking for a .NET / C# equivalent, I couldn't find one. The official Microsoft Learn page for DevUI samples simply said: "DevUI samples for C# are coming soon." — Not great when you're trying to ship.
So I built one. This post walks through a complete, working .NET Core example using Microsoft Agent Framework 1.0, with DevUI wired up and ready to go.
What is DevUI?
DevUI is a lightweight developer dashboard shipped as part of the Microsoft Agent Framework. It is not intended for production — it's a local dev tool, similar in spirit to what Redux DevTools does for React or what Aspire's dashboard does for distributed .NET apps.
When you run your agent app with DevUI enabled, you get a browser UI that shows:
- The agent profile — name, instructions, registered tools
- The invocation request — what was sent to the agent
- The reasoning trail — intermediate steps and internal messages
- Tool calls — which functions were invoked and with what arguments
- OpenTelemetry traces — if you have tracing enabled
Remark: The DevUI functionality turns out not be fully functional yet. I encountered a lot of use cases where it refused to work. So feel free to give it a try but there will be dragons...
How DevUI Works in .NET
For .NET, DevUI is exposed through the Microsoft.Agents.AI.DevUI NuGet package. It integrates directly into ASP.NET Core's middleware pipeline via a single method call:
app.MapDevUI()
Internally, it hooks into the same OpenAI-compatible Responses and Conversations APIs that the agent runtime exposes, so every agent message flows through it automatically — no extra instrumentation code required.
Once running, navigate to /devui in your browser, and you'll see all registered agents listed in the left sidebar. Click one, send a message, and watch the chain-of-thought unfold in real time.
Prerequisites
Before writing any code, make sure you have:
- .NET 10 SDK or later (the example targets net10.0)
irm https://ollama.com/install.ps1 | iex
Project setup
Step 1: Create the project
Create a new minimal ASP.NET Core web application. This is the host that DevUI will attach to.
dotnet new web -n AgentFramework.DevUI.Example
cd AgentFramework.DevUI.Example
Step 2: Install NuGet packages
You need four packages in total: the Agent Framework hosting layer, DevUI itself, the hosting OpenAI connector, and the OpenAI client SDK.
dotnet add package Microsoft.Agents.AI.Hosting --prerelease
dotnet add package Microsoft.Agents.AI.DevUI --prerelease
dotnet add package OllamaSharp
Step 3: The code
Here is the complete Program.cs for this example. It registers a chat client backed by Foundry Local, defines two agents with different personas, enables the OpenAI-compatible response endpoints (required by DevUI), and maps the DevUI dashboard.
What each step does:
Step 1 — Chat client: We create an IChatClient backed by GitHub Models using the OpenAI client SDK. The AsIChatClient() extension bridges the OpenAI SDK to Microsoft.Extensions.AI's provider-agnostic interface. Swapping to Azure OpenAI or any other supported provider is a one-line change.
Step 2 — Agents: builder.AddAIAgent() registers a named agent with a system prompt (instructions). You can register as many agents as you like. Each will appear as a separate entry in the DevUI sidebar.
Step 3 & 4 — Responses + Conversations APIs: These are the OpenAI-compatible API endpoints that Agent Framework exposes. DevUI hooks into these to intercept all agent traffic. They must be registered before calling MapDevUI().
Step 5 — DevUI: app.MapDevUI() mounts the dashboard at /devui. The IsDevelopment() guard ensures it is never available in staging or production.
Step 4: Running the app
Launch the app in Development mode (the default when using dotnet run):
dotnet run
# Output:
# Now listening on: https://localhost:5001
# Now listening on: http://localhost:5000
Then open https://localhost:5001/devui in your browser. You should see the Weather bot agent listed in the dropdown at the top:
You can now interact with the agent:

Click WeatherBot, type "What's the weather in Brussels?" in the input box and hit Send.
The right panel will show the full execution trace: the user message, response parts and the final response:
Extending the example
Adding tools
Tools are where agents get genuinely useful. You register them with AIFunctionFactory and pass them during agent registration. DevUI will show every tool call with its arguments and return value in the reasoning trail.
Exploring tools
Tool call tracing is one of DevUI's most valuable features during development. You can see exactly which tool was called, what arguments were passed, and what was returned — all without adding a single log statement.
Troubleshooting
404 at /devui
Make sure you have called both app.MapOpenAIResponses() and app.MapOpenAIConversations() before app.MapDevUI(). All three are required.
Also verify you are running in Development mode (ASPNETCORE_ENVIRONMENT=Development). In Production, the IsDevelopment() guard prevents DevUI from mounting.
Package not found
The Agent Framework packages are currently prerelease. Make sure you're passing --prerelease to dotnet add package or explicitly specify the version string in your .csproj.
Conclusion
Microsoft Agent Framework 1.0 shipped in April 2026 with stable APIs and first-class .NET support, but the C# DevUI story was underdocumented. This post fills that gap with a working end-to-end example.
The setup comes down to 3 packages, five lines of registration code, and one route mapping. From there, you get a functional local debugging dashboard that dramatically shortens the write-run-fix loop for agent development in .NET. However, it is not yet fully supported in .NET so expect some issues and unsupported scenarios.
The code for this example is straightforward to extend. Have fun!
More information
microsoft/agent-framework: A framework for building, orchestrating and deploying AI agents and multi-agent workflows with support for Python and .NET.
Ollama
Agent Framework documentation | Microsoft Learn
DevUI Overview | Microsoft Learn
wullemsb/DevUIExample: C# example for using DevUI in Agent Framework