Multi-Agent | The .NET Blog

Creació d'interfícies d'usuari multiagent en temps real que no semblin com una caixa negra

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

Això és el que passa amb els sistemes multiagent: tenen un aspecte increïble a les demostracions. Tres agents que passen treballant, resolent problemes, prenent decisions. Aleshores intentes posar-ho davant dels usuaris reals i… silenci. Un indicador de gir. No hi ha idea de quin agent està fent què o per què el sistema està en pausa. Això no és un producte, és un problema de confiança.

L’equip de Microsoft Agent Framework acaba de publicar una revisió fantàstica sobre la combinació de fluxos de treball MAF amb AG-UI, un protocol obert per a esdeveniments d’execució d’agents de transmissió a una interfície sobre esdeveniments enviats pel servidor. I sincerament? Aquest és el tipus de pont que hem trobat a faltar.

Per què això és important per als desenvolupadors de.NET

Si esteu creant aplicacions basades en intel·ligència artificial, probablement heu tocat aquest mur. La vostra orquestració de fons funciona molt bé: els agents s’entreguen, les eines es disparen i es prenen decisions. Però la interfície no té ni idea del que passa darrere de les escenes. AG-UI ho soluciona mitjançant la definició d’un protocol estàndard per als esdeveniments de l’agent de transmissió (penseu a RUN_STARTED, STEP_STARTED, TOOL_CALL_*, TEXT_MESSAGE_*) directament a la vostra capa d’IU a través de SSE.

La demostració que van crear és un flux de treball d’atenció al client amb tres agents: un agent de triatge que encamina les sol·licituds, un agent de reemborsament que gestiona els diners i un agent de comandes que gestiona les substitucions. Cada agent té les seves pròpies eines i la topologia de traspàs es defineix explícitament: no hi ha vibracions de “esbrinar-ho a partir del missatge”.

La topologia de traspàs és la veritable estrella

El que em va cridar l’atenció és com HandoffBuilder us permet declarar un gràfic d’encaminament dirigit entre agents:

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.")
)

Cada add_handoff crea una vora dirigida amb una descripció en llenguatge natural. El marc genera eines de transferència per a cada agent basant-se en aquesta topologia. Per tant, les decisions d’encaminament es basen en la vostra estructura d’orquestració, no només en el que el LLM vulgui fer. Això és un gran negoci per a la fiabilitat de la producció.

Human-in-the-loop que realment funciona

La demostració mostra dos patrons d’interrupció que necessita qualsevol aplicació d’agent del món real:

L’aprovació de l’eina s’interromp: quan un agent truca a una eina marcada amb approval_mode="always_require", el flux de treball s’atura i emet un esdeveniment. La interfície representa un modal d’aprovació amb el nom de l’eina i els arguments. No hi ha bucles de reintent de gravació de testimonis, només un flux net de pausa, aprovació i reinici.

La sol·licitud d’informació s’interromp: quan un agent necessita més context de l’usuari (com ara un identificador de comanda), s’atura i pregunta. La interfície mostra la pregunta, l’usuari respon i l’execució es reprèn exactament des d’on es va aturar.

Tots dos patrons es transmeten com a esdeveniments AG-UI estàndard, de manera que la vostra interfície no necessita lògica personalitzada per agent; només representa qualsevol esdeveniment que passi a través de la connexió SSE.

El cablejat és sorprenentment senzill

La integració entre MAF i AG-UI és una única trucada de funció:

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",
)

El workflow_factory crea un flux de treball nou per fil, de manera que cada conversa té un estat aïllat. El punt final gestiona tota la fontaneria SSE automàticament. Si ja esteu utilitzant FastAPI (o podeu afegir-lo com a capa lleugera), això és gairebé zero fricció.

La meva opinió

Per als desenvolupadors de.NET, la pregunta immediata és: “Puc fer això en C#?” L’Agent Framework està disponible tant per a.NET com per a Python, i el protocol AG-UI és independent de l’idioma (només és SSE). Així, mentre que aquesta demostració específica utilitza Python i FastAPI, el patró es tradueix directament. Podeu connectar una API mínima ASP.NET Core amb punts finals SSE seguint el mateix esquema d’esdeveniments AG-UI.

El més important és que les interfícies d’usuari multiagent s’estan convertint en una preocupació de primera classe, no en una idea posterior. Si esteu creant qualsevol cosa on els agents interactuen amb humans (atenció al client, fluxos de treball d’aprovació, processament de documents), aquesta combinació d’orquestració MAF i transparència AG-UI és el patró a seguir.

Tancant

AG-UI + Microsoft Agent Framework us ofereix el millor dels dos mons: una robusta orquestració multiagent al backend i visibilitat en temps real al frontend. No més interaccions d’agent de caixa negra.

Fes una ullada a la revisió completa i al repositori del protocol AG-UI per aprofundir.

Microsoft Agent Framework Hits 1.0: això és el que realment importa per als desenvolupadors de.NET

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

Si heu estat seguint el viatge de l’Agent Framework des dels primers dies del nucli semàntic i de l’AutoGen, aquest és significatiu. Microsoft Agent Framework només accedir a la versió 1.0: API estables, preparades per a la producció, compromís de suport a llarg termini. Està disponible tant per a.NET com per a Python, i està realment preparat per a càrregues de treball reals.

Permeteu-me reduir el soroll de l’anunci i centrar-me en allò que importa si esteu creant aplicacions basades en IA amb.NET.

La versió curta

Agent Framework 1.0 unifica el que abans era Semantic Kernel i AutoGen en un únic SDK de codi obert. Abstracció d’un agent. Un motor d’orquestració. Diversos proveïdors d’IA. Si heu estat rebotant entre el nucli semàntic per a patrons empresarials i AutoGen per a fluxos de treball multiagent de grau de recerca, podeu aturar-vos. Aquest és l’SDK ara.

Començar és gairebé injustament senzill

Aquí hi ha un agent que treballa a.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."));

Això és tot. Un grapat de línies i teniu un agent d’IA que s’executa contra Azure Foundry. L’equivalent de Python és igualment concís. Afegiu eines de funció, converses de diversos torns i transmissió a mesura que avanceu: la superfície de l’API augmenta sense ser estrany.

Orquestració multiagent: aquest és el veritable negoci

Els agents únics estan bé per a les demostracions, però els escenaris de producció solen necessitar coordinació. Agent Framework 1.0 s’envia amb patrons d’orquestració provats en batalla directament de Microsoft Research i AutoGen:

Seqüencial: els agents processen per ordre (escriptor → revisor → editor)
Simultània: es distribueix a diversos agents en paral·lel, convergeix els resultats
Handoff: un agent delega a un altre segons la intenció
Xat de grup: diversos agents discuteixen i convergeixen en una solució
Magentic-One: el patró multiagent de grau de recerca de MSR

Tots admeten la transmissió en temps real, els punts de control, les aprovacions humanes en el bucle i la pausa/reprèn. La part del punt de control és crucial: els fluxos de treball de llarga durada sobreviuen als reinicis del procés. Per als desenvolupadors de.NET que hem creat fluxos de treball duradors amb Azure Functions, això ens sembla familiar.

Les característiques que més importen

Aquí teniu la meva llista del que val la pena saber:

Enganxs de middleware. Saps com ASP.NET Core té canalitzacions de middleware? Mateix concepte, però per a l’execució de l’agent. Intercepteu totes les etapes (afegiu seguretat de contingut, registre, polítiques de compliment) sense tocar les indicacions de l’agent. Així és com podeu preparar els agents per a l’empresa.

Memòria connectable. Historial de conversa, estat clau-valor persistent, recuperació basada en vectors. Trieu el vostre backend: Foundry Agent Service, Mem0, Redis, Neo4j o enrotlleu el vostre. La memòria és el que converteix una trucada LLM sense estat en un agent que realment recorda el context.

Agents YAML declaratius. Definiu les instruccions, les eines, la memòria i la topologia d’orquestració del vostre agent en fitxers YAML controlats per versions. Carregueu i executeu amb una única trucada a l’API. Això és un canvi de joc per als equips que volen repetir el comportament de l’agent sense tornar a desplegar el codi.

Compatibilitat amb A2A i MCP. MCP (Model Context Protocol) permet als agents descobrir i invocar eines externes de manera dinàmica. A2A (protocol d’agent a agent) permet la col·laboració entre temps d’execució: els vostres agents.NET poden coordinar-se amb els agents que s’executen en altres marcs. El suport A2A 1.0 arribarà aviat.

Les funcions de previsualització val la pena veure-les

Algunes funcions s’envien com a previsualització a la versió 1.0: funcionals, però les API poden evolucionar:

DevUI: un depurador local basat en navegador per visualitzar l’execució de l’agent, els fluxos de missatges i les trucades d’eines en temps real. Penseu en Application Insights, però per al raonament dels agents.
GitHub Copilot SDK i Claude Code SDK: utilitzeu Copilot o Claude com a arnès d’agent directament des del vostre codi d’orquestració. Escriu un agent capaç de codificar juntament amb els altres agents en el mateix flux de treball.
Agent Harness: un temps d’execució local personalitzable que ofereix als agents accés a l’intèrpret d’ordres, al sistema de fitxers i als bucles de missatgeria. Penseu en agents de codificació i patrons d’automatització.
Habilitats: paquets de capacitats de domini reutilitzables que ofereixen als agents capacitats estructurades de manera immediata.

Migració des del nucli semàntic o AutoGen

Si teniu codi Semàntic Kernel o AutoGen, hi ha assistents de migració dedicats que analitzen el vostre codi i generen plans de migració pas a pas. La guia de migració del nucli semàntic i la guia de migració d’AutoGen us acompanyen tot.

Si heu estat als paquets RC, l’actualització a la 1.0 és només un augment de la versió.

Tancant

Agent Framework 1.0 és la fita de producció que els equips empresarials estaven esperant. API estables, suport per a diversos proveïdors, patrons d’orquestració que funcionen realment a escala i rutes de migració tant del nucli semàntic com d’AutoGen.

El marc és totalment de codi obert a GitHub, i podeu començar avui mateix amb dotnet add package Microsoft.Agents.AI. Consulteu la guia d’inici ràpid i les mostres per embrutar-vos les mans.

Si heu estat esperant el senyal “Segur per utilitzar en producció”, això és tot.