From Problems to Patterns

You can't design a screen for an answer you haven't seen yet.

For sixty years, a human authored the interface in advance. A language model breaks that assumption three ways at once: it decides the shape of the answer at runtime, it streams that answer over seconds, and it produces content you must render but can never fully trust. You cannot pre-design your way out of any of them.

Agentic UI in .NET turns those three problems into a working architecture. Across one running example-Atlas, a travel-planning assistant-you build an agent-driven interface from first principles on ASP.NET Core and React, over the open AG-UI (Agent-User Interaction) protocol.

You start by diagnosing why the obvious design fails, then rebuild the interface as a reduction over a stream of events. You learn the AG-UI protocol exhaustively-messages, shared state, tools, human-in-the-loop interrupts, and reasoning-by hand-building its core. Only then do you adopt Prism, an open .NET + React framework, recognising each part as the hardened version of something you already wrote.

What you'll build

• A hardened AG-UI streaming endpoint in ASP.NET Core-first meaningful token in under 500 ms.
• Typed React components the agent renders at runtime, behind a server allow-list, with progressive-streaming props.
• A client that reduces a live event stream into UI, mirroring the server exactly.
• Human-in-the-loop approval that gates irreversible actions-a booking, a charge-behind a recorded human "yes".
• A swappable model provider behind a one-method adapter (OpenAI, Azure, or the latest Claude models).
• Multi-tenant persistence where a cross-tenant leak is structurally impossible.
• Production hardening: OpenTelemetry observability, a real threat model, a deterministic test suite, and a containerised deployment that streams through the proxy layer.

Inside the book

Part I - The Problems: how an agent breaks sixty years of UI, and the event stream that answers it.
Part II - The AG-UI Protocol: the full event vocabulary-messages, state, tools, interrupts, reasoning-built by hand.
Part III - Building on Prism: Atlas from a ten-line setup to a multi-tenant generative-UI app.
Part IV - To Production: observability, security, testing, and deployment for streaming agents.
Part V - Inside the Framework: extend Prism at its seams; patterns, anti-patterns, and the road ahead.

Who this book is for

Senior and mid-level engineers, full-stack developers, and architects who build with C#, ASP.NET Core, and React and are putting an agent in front of real users-and who want patterns they can defend, not framework magic. No machine-learning background is required; the model is treated throughout as a streaming, non-deterministic component behind an interface.

One discipline runs through every chapter: the model proposes, the server disposes. Every component, tool, and tenant claim is validated server-side before it takes effect-so a non-deterministic model is safe to put in front of real users. And the book closes honestly, including when not to build generative UI at all: if a fixed screen serves the problem better, you'll know, and you'll build the fixed screen.

Agentic UI in .NET is Book 3 in the From Problems to Patterns series by Najaf A. Shaikh, following Generative AI in .NET and Domain-Driven Design and Event Sourcing in .NET.