Multi-Agent | The .NET Blog

Real-Time Multi-Agent UI's Bouwen Die Niet Aanvoelen als een Black Box

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Voor het origineel, klik hier.

Dit is de werkelijkheid over multi-agent systemen: ze zien er geweldig uit in demo’s. Drie agents die werk aan elkaar doorgeven, problemen oplossen, beslissingen nemen. Dan probeer je het aan echte gebruikers te tonen en… stilte. Een draaiende indicator. Geen idee welke agent wat doet of waarom het systeem gepauzeerd is. Dat is geen product — dat is een vertrouwensprobleem.

Het Microsoft Agent Framework-team heeft zojuist een fantastisch overzicht gepubliceerd over het koppelen van MAF-workflows aan AG-UI, een open protocol voor het streamen van agent-uitvoeringsgebeurtenissen naar een frontend via Server-Sent Events. En eerlijk gezegd? Dit is precies de brug die we misten.

Waarom dit belangrijk is voor .NET-ontwikkelaars

Als je AI-aangedreven apps bouwt, ben je waarschijnlijk al tegen deze muur opgelopen. Je backend-orkestratie werkt prima — agents geven werk aan elkaar door, tools worden uitgevoerd, beslissingen worden genomen. Maar de frontend heeft geen idee wat er achter de schermen gebeurt. AG-UI lost dit op door een standaardprotocol te definiëren voor het streamen van agentgebeurtenissen (RUN_STARTED, STEP_STARTED, TOOL_CALL_*, TEXT_MESSAGE_*) rechtstreeks naar je UI-laag via SSE.

De demo die ze bouwden is een klantenserviceworkflow met drie agents: een triageagent die verzoeken routeert, een terugbetalingsagent die financiële zaken afhandelt, en een orderagent die vervangingen beheert. Elke agent heeft zijn eigen tools, en de handoff-topologie is expliciet gedefinieerd — geen “bedenk het maar uit de prompt”-sfeer.

De handoff-topologie is de echte ster

Wat mij opviel is hoe HandoffBuilder je in staat stelt een gerichte routeringsgraf tussen agents te declareren:

builder = HandoffBuilder(
 name="ag_ui_handoff_workflow_demo",
 participants=[triage, refund, order],
 termination_condition=termination_condition,
)

(
 builder
 .add_handoff(triage, [refund], description="Refunds, damaged-item claims...")
 .add_handoff(triage, [order], description="Replacement, exchange...")
 .add_handoff(refund, [order], description="Replacement logistics needed after refund.")
 .add_handoff(order, [triage], description="After replacement/shipping tasks complete.")
)

Elke add_handoff maakt een gerichte koppeling met een beschrijving in natuurlijke taal. Het framework genereert handoff-tools voor elke agent op basis van deze topologie. Routeringsbeslissingen zijn daardoor gegrond in jouw orkestratiestucture, niet in wat het LLM toevallig wil doen. Dat is enorm belangrijk voor betrouwbaarheid in productie.

Human-in-the-loop die echt werkt

De demo toont twee onderbrekingspatronen die elke echte agentapp nodig heeft:

Tool-goedkeuringsonderbrekingen — wanneer een agent een tool aanroept die is gemarkeerd met approval_mode="always_require", pauzeert de workflow en stuurt een gebeurtenis. De frontend toont een goedkeuringsmodal met de toolnaam en argumenten. Geen token-verspillende herhalingsloops — gewoon een nette pauze-goedkeur-hervat-stroom.

Informatieverzoekonderbrekingen — wanneer een agent meer context van de gebruiker nodig heeft (zoals een order-ID), pauzeert het en vraagt. De frontend toont de vraag, de gebruiker antwoordt, en de uitvoering gaat verder precies waar het gestopt was.

Beide patronen worden gestreamd als standaard AG-UI-gebeurtenissen, zodat je frontend geen aangepaste logica per agent nodig heeft — het rendert gewoon wat er via de SSE-verbinding binnenkomt.

Het aansluiten is verrassend eenvoudig

De integratie tussen MAF en AG-UI is één functieaanroep:

from agent_framework.ag_ui import (
 AgentFrameworkWorkflow,
 add_agent_framework_fastapi_endpoint,
)

app = FastAPI()

demo_workflow = AgentFrameworkWorkflow(
 workflow_factory=lambda _thread_id: create_handoff_workflow(),
 name="ag_ui_handoff_workflow_demo",
)

add_agent_framework_fastapi_endpoint(
 app=app, agent=demo_workflow, path="/handoff_demo",
)

De workflow_factory maakt een nieuwe workflow per thread, zodat elke conversatie geïsoleerde toestand heeft. Het endpoint regelt alle SSE-infrastructuur automatisch. Als je FastAPI al gebruikt (of het als lichte laag kunt toevoegen), is dit vrijwel nul wrijving.

Mijn kijk

Voor ons als .NET-ontwikkelaars is de directe vraag: “Kan ik dit in C# doen?” Agent Framework is beschikbaar voor zowel .NET als Python, en het AG-UI-protocol is taalonafhankelijk (het is gewoon SSE). Dus hoewel deze specifieke demo Python en FastAPI gebruikt, is het patroon direct overdraagbaar. Je kunt een ASP.NET Core minimal API aansluiten met SSE-endpoints die hetzelfde AG-UI-gebeurtenisschema volgen.

De grotere les is dat multi-agent UI’s een prioriteit worden, geen bijzaak. Als je iets bouwt waarbij agents met mensen interageren — klantenservice, goedkeuringsworkflows, documentverwerking — is deze combinatie van MAF-orkestratie en AG-UI-transparantie het te volgen patroon.

Samenvatting

AG-UI + Microsoft Agent Framework geeft je het beste van beide werelden: robuuste multi-agent orkestratie op de backend en real-time zichtbaarheid op de frontend. Geen black-box agentinteracties meer.

Bekijk de volledige walkthrough en de AG-UI protocol repository om dieper te gaan.

Microsoft Agent Framework Bereikt 1.0 — Dit Is Wat Er Echt Toe Doet voor .NET-Ontwikkelaars

Emiliano Montesdeoca — Fri, 03 Apr 2026 00:00:00 +0000

Dit bericht is automatisch vertaald. Voor het origineel, klik hier.

Als je de Agent Framework-reis hebt gevolgd vanaf de vroege dagen van Semantic Kernel en AutoGen, dan is dit significant. Microsoft Agent Framework heeft zojuist versie 1.0 bereikt — productieklaar, stabiele API’s, toezegging voor langetermijnondersteuning. Beschikbaar voor .NET en Python, en echt klaar voor echte workloads.

Laten we door het aankondigingslawaai heen snijden en ons richten op wat ertoe doet als je AI-aangedreven apps bouwt met .NET.

De korte versie

Agent Framework 1.0 verenigt wat vroeger Semantic Kernel en AutoGen was in één open-source SDK. Één agent-abstractie. Één orkestratieengine. Meerdere AI-providers. Als je heen en weer ging tussen Semantic Kernel voor enterprise-patronen en AutoGen voor research-grade multi-agent workflows, kun je stoppen. Dit is nu de ene SDK.

Beginnen is bijna oneerlijk eenvoudig

Hier is een werkende agent in .NET:

// dotnet add package Microsoft.Agents.AI.OpenAI --prerelease
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
using Azure.Identity;

var agent = new AIProjectClient(endpoint: "https://your-project.services.ai.azure.com")
 .GetResponsesClient("gpt-5.3")
 .AsAIAgent(
 name: "HaikuBot",
 instructions: "You are an upbeat assistant that writes beautifully."
 );

Console.WriteLine(await agent.RunAsync("Write a haiku about shipping 1.0."));

Dat is het. Een handvol regels en je hebt een AI-agent die op Azure Foundry draait. Het Python-equivalent is even beknopt. Voeg functietools, meerturnsgesprekken en streaming toe naarmate je verder gaat — het API-oppervlak schaalt op zonder vreemd te worden.

Multi-agent-orkestratie — dit is het echte werk

Enkele agents zijn prima voor demo’s, maar productiescenario’s vereisen meestal coördinatie. Agent Framework 1.0 wordt geleverd met in de strijd geteste orkestratiepatronen rechtstreeks uit Microsoft Research en AutoGen:

Sequential — agents verwerken op volgorde (schrijver → reviewer → editor)
Concurrent — fan out naar meerdere agents in parallel, resultaten samenvoegen
Handoff — één agent delegeert naar een andere op basis van intentie
Group chat — meerdere agents bespreken en convergeren naar een oplossing
Magentic-One — het research-grade multi-agent patroon van MSR

Ze ondersteunen allemaal streaming, checkpointing, human-in-the-loop goedkeuringen en pauzeren/hervatten. Het checkpointing-deel is cruciaal — langlopende workflows overleven procesrestarts.

De meest belangrijke functies

Middleware-hooks. Ken je de middleware-pipelines in ASP.NET Core? Hetzelfde concept, maar voor agentuitvoering. Onderschep elke fase — voeg inhoudsbeveiliging, logging, nalevingsbeleid toe — zonder agentvragen aan te raken.

Pluggable geheugen. Gespreksgeschiedenis, persistente sleutel-waardestatus, vectorgebaseerd ophalen. Kies je backend: Foundry Agent Service, Mem0, Redis, Neo4j of eigen implementatie.

Declaratieve YAML-agents. Definieer de instructies, tools, geheugen en orkestratietopologie van je agent in versiegecontroleerde YAML-bestanden. Laad en voer uit met één API-aanroep.

A2A- en MCP-ondersteuning. MCP (Model Context Protocol) stelt agents in staat externe tools dynamisch te ontdekken en aan te roepen. A2A (Agent-to-Agent protocol) maakt samenwerking tussen runtimes mogelijk.

Preview-functies die de moeite waard zijn

DevUI — een op browser gebaseerde lokale debugger voor het visualiseren van agentuitvoering, berichtstromen en toolaanroepen in real-time.
GitHub Copilot SDK en Claude Code SDK — gebruik Copilot of Claude als agentharnas rechtstreeks vanuit je orkestatiecode.
Agent Harness — aanpasbare lokale runtime die agents toegang geeft tot shell, bestandssysteem en berichtlussen.
Skills — herbruikbare domeinvermogenspakketten.

Migreren van Semantic Kernel of AutoGen

Als je bestaande Semantic Kernel- of AutoGen-code hebt, zijn er speciale migratieassistenten die je code analyseren en stap-voor-stap migratieplannen genereren.

Samenvatting

Agent Framework 1.0 is de productiemijlpaal waar enterprise-teams op hebben gewacht. Stabiele API’s, multi-providerondersteuning en orkestratiepatronen die echt op schaal werken.

Het framework is volledig open source op GitHub. Als je wachtte op het “veilig om in productie te gebruiken”-signaal — dit is het.