Agent Framework | The .NET Blog

CodeAct al Agent Framework: Com Reduir la Latència del teu Agent a la Meitat

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Aquest post ha estat traduït automàticament. Per a la versió original, fes clic aquí.

Hi ha un moment en tot projecte d’agents en què mires el trace i penses: “per què tarda tant això?” El model està bé. Les eines funcionen. Però hi ha set round trips per obtenir un resultat que es podria calcular d’una sola vegada.

Exactament aquest és el problema que resol CodeAct — i l’equip d’Agent Framework acaba de publicar suport alpha a través del nou paquet agent-framework-hyperlight.

Què és CodeAct?

El patró CodeAct és elegantment simple: en lloc de donar al model una llista d’eines i deixar-lo cridar-les una per una, li dones una única eina execute_code i li permets expressar el pla complet com un programa Python curt. L’agent escriu el codi una vegada, el sandbox l’executa, i tornes a rebre un únic resultat consolidat.

Un pla de cinc passos que abans requeria cinc torns del model ara es converteix en un torn execute_code que conté un script Python que crida les teves eines via call_tool(...).

El benchmark del repositori ho fa concret. Vuit usuaris, dotzenes de comandes, cinc eines. Mateix model, mateixes eines, mateix prompt — només cablejat diferent:

Cablejat	Temps	Tokens
Tradicional	27.81s	6.890
CodeAct	13.23s	2.489
Millora	52,4%	63,9%

La peça de seguretat: micro-VMs de Hyperlight

El paquet agent-framework-hyperlight utilitza micro-VMs de Hyperlight. Cada crida execute_code obté la seva pròpia micro-VM recentment creada — amb la seva pròpia memòria, sense accés al sistema de fitxers del host més enllà del que muntes explícitament. L’arrencada es mesura en mil·lisegons.

Les teves eines segueixen executant-se al host. El codi de pegament generat pel model s’executa en el sandbox. Aquesta és la divisió correcta.

Com connectar-ho

from agent_framework import Agent, tool
from agent_framework_hyperlight import HyperlightCodeActProvider

@tool
def get_weather(city: str) -> dict[str, float | str]:
 """Return the current weather for a city."""
 return {"city": city, "temperature_c": 21.5, "conditions": "partly cloudy"}

codeact = HyperlightCodeActProvider(
 tools=[get_weather],
 approval_mode="never_require",
)

agent = Agent(
 client=client,
 name="CodeActAgent",
 instructions="You are a helpful assistant.",
 context_providers=[codeact],
)

Quan fer servir CodeAct (i quan no)

Fes servir CodeAct quan:

La tasca encadena moltes crides petites a eines (consultes, joins, càlculs, formatació)
Et preocupa la latència i el cost de tokens
Vols aïllament fort per crida en codi generat pel model

Queda’t amb el tool-calling tradicional quan:

L’agent només fa una o dues crides a eines per torn
Cada crida té efectes secundaris que vols aprovar individualment
Les descripcions d’eines són escasses o ambigües

Prova-ho ara

pip install agent-framework-hyperlight --pre

Consulta el post complet al blog d’Agent Framework per a cobertura més profunda.

GPT-5.5 Ja És Aquí a Azure Foundry — El que els Desenvolupadors .NET Han de Saber

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Aquest post ha estat traduït automàticament. Per a la versió original, fes clic aquí.

Microsoft acaba d’anunciar que GPT-5.5 ja és disponible a Microsoft Foundry. Si has estat construint agents a Azure, aquesta és l’actualització que esperaves.

La progressió de GPT-5

GPT-5: va unificar raonament i velocitat en un sol sistema
GPT-5.4: raonament multi-pas més robust, capacitats agèntiques per a empreses
GPT-5.5: raonament de llarg context més profund, execució agèntica més fiable, millor eficiència de tokens

Què ha canviat realment

Millor codificació agèntica: GPT-5.5 manté el context a través de grans bases de codi, diagnostica fallades arquitectòniques i anticipa requisits de proves.

Eficiència de tokens: Sortides de major qualitat amb menys tokens i menys reintents. Menys cost i latència en producció.

Anàlisi de llarg context: Gestiona documents extensos i historials multi-sessió sense perdre el fil.

Preus

Model	Entrada ($/M tokens)	Entrada en memòria cau	Sortida ($/M tokens)
GPT-5.5	$5.00	$0.50	$30.00
GPT-5.5 Pro	$30.00	$3.00	$180.00

Foundry Agent Service

Defineix agents en YAML o connecta’ls amb Microsoft Agent Framework, GitHub Copilot SDK, LangGraph o l’SDK d’OpenAI Agents — i executa’ls com a agents allotjats aïllats amb sistema de fitxers persistent, identitat de Microsoft Entra i preus d’escala a zero.

AIAgent agent = aiProjectClient
 .AsAIAgent("gpt-5.5", instructions: "Ets un assistent útil.", name: "ElMeuAgent");

Consulta l’anunci complet.

On Recorda les Coses el teu Agent? Guia Pràctica sobre l'Emmagatzematge de l'Historial de Xat

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Aquest post ha estat traduït automàticament. Per a la versió original, fes clic aquí.

Quan construeixes un agent IA, dediques la major part de la teva energia al model, les eines i els prompts. La pregunta de on viu l’historial de conversa sembla un detall d’implementació — però és una de les decisions arquitectòniques més importants que prendràs.

Determina si els usuaris poden bifurcar converses, desfer respostes, reprendre sessions després d’un reinici, i si les teves dades surten mai de la teva infraestructura. L’equip d’Agent Framework ha publicat una anàlisi en profunditat.

Dos patrons fonamentals

Gestionat pel servei: el servei d’IA emmagatzema l’estat de la conversa. La teva app manté una referència i el servei inclou automàticament l’historial rellevant en cada sol·licitud.

Gestionat pel client: la teva app manté l’historial complet i envia missatges rellevants amb cada sol·licitud. El servei no té estat. Controles tot.

Com Agent Framework abstreu això

// C# — funciona igual independentment del proveïdor
AgentSession session = await agent.CreateSessionAsync();
var first = await agent.RunAsync("Em dic Alice.", session);
var second = await agent.RunAsync("Quin és el meu nom?", session);

# Python
session = agent.create_session()
first = await agent.run("Em dic Alice.", session=session)
second = await agent.run("Quin és el meu nom?", session=session)

Referència ràpida de proveïdors

Proveïdor	Emmagatzematge	Model	Compactació
OpenAI/Azure Chat Completions	Client	N/A	Tu
Foundry Agent Service	Servei	Lineal	Servei
Responses API (per defecte)	Servei	Bifurcació	Servei
Anthropic Claude, Ollama	Client	N/A	Tu

Llegeix el post complet per a l’arbre de decisions complet.

Les habilitats d'agent a.NET s'acaben de ser molt flexibles

Emiliano Montesdeoca — Tue, 14 Apr 2026 00:00:00 +0000

Si heu estat creant agents amb Microsoft Agent Framework, coneixeu l’exercici: definiu les habilitats, les connecteu a un proveïdor i deixeu que l’agent esbringui quina invocar. El que és nou és com autors d’aquestes habilitats, i el salt de flexibilitat és important.

L’última actualització introdueix tres patrons de creació personalitzats per a les habilitats d’agent: basat en fitxers, basat en classes i definit en codi en línia. Els tres es connecten a un únic AgentSkillsProviderBuilder, el que significa que podeu barrejar i combinar sense cap lògica d’encaminament ni codi de cola especial. Permeteu-me que us acompanyi a través de cadascuna i quan ho aconseguiu.

Habilitats basades en fitxers: el punt de partida

Les habilitats basades en fitxers són exactament el que sonen: un directori al disc amb un fitxer SKILL.md, scripts opcionals i documents de referència. Penseu en això com la manera més senzilla de donar noves capacitats al vostre agent:

skills/
└── onboarding-guide/
├── SKILL.md
├── scripts/
│ └── check-provisioning.py
└── references/
└── onboarding-checklist.md

El frontmatter SKILL.md declara el nom i la descripció de l’habilitat, i la secció d’instruccions indica a l’agent com utilitzar els scripts i les referències:

---
name: onboarding-guide
description: >-
 Walk new hires through their first-week setup checklist.
---

## Instructions

1. Ask for the employee's name and start date.
2. Run `scripts/check-provisioning.py` to verify accounts.
3. Walk through `references/onboarding-checklist.md`.
4. Follow up on incomplete items.

A continuació, connecteu-lo amb SubprocessScriptRunner.RunAsync per a l’execució de l’script:

var skillsProvider = new AgentSkillsProvider(
 Path.Combine(AppContext.BaseDirectory, "skills"),
 SubprocessScriptRunner.RunAsync);

AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
 .GetResponsesClient()
 .AsAIAgent(new ChatClientAgentOptions
 {
 Name = "HRAgent",
 ChatOptions = new() { Instructions = "You are a helpful HR assistant." },
 AIContextProviders = [skillsProvider],
 },
 model: deploymentName);

L’agent descobreix l’habilitat automàticament i invoca l’script de subministrament quan necessita comprovar l’estat del compte. Net i senzill.

Habilitats basades en classe: enviament mitjançant NuGet

Aquí és on es posa interessant per als equips. Les habilitats basades en classe es deriven de AgentClassSkill<T> i utilitzen atributs com [AgentSkillResource] i [AgentSkillScript] perquè el marc ho descobreixi tot mitjançant la reflexió:

public sealed class BenefitsEnrollmentSkill : AgentClassSkill<BenefitsEnrollmentSkill>
{
 public override AgentSkillFrontmatter Frontmatter { get; } = new(
 "benefits-enrollment",
 "Enroll an employee in health, dental, or vision plans.");

 protected override string Instructions => """
 1. Read the available-plans resource.
 2. Confirm the plan the employee wants.
 3. Use the enroll script to complete enrollment.
 """;

 [AgentSkillResource("available-plans")]
 [Description("Plan options with monthly pricing.")]
 public string AvailablePlans => """
 ## Available Plans (2026)
 - Health: Basic HMO ($0/month), Premium PPO ($45/month)
 - Dental: Standard ($12/month), Enhanced ($25/month)
 - Vision: Basic ($8/month)
 """;

 [AgentSkillScript("enroll")]
 [Description("Enrolls employee in the specified benefit plan.")]
 private static string Enroll(string employeeId, string planCode)
 {
 bool success = HrClient.EnrollInPlan(employeeId, planCode);
 return JsonSerializer.Serialize(new { success, employeeId, planCode });
 }
}

La bellesa aquí és que un equip pot empaquetar-ho com a paquet NuGet. L’afegiu al vostre projecte, el deixeu anar al constructor i funciona juntament amb les vostres habilitats basades en fitxers amb una coordinació zero:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .Build();

Les dues habilitats es mostren a l’indicador del sistema de l’agent. L’agent decideix quin utilitzar en funció de la conversa, no cal cap codi d’encaminament.

Habilitats en línia: el pont ràpid

Coneixeu aquell moment en què un altre equip està construint exactament l’habilitat que necessiteu, però no s’enviarà per a un sprint? AgentInlineSkill és el teu pont:

var timeOffSkill = new AgentInlineSkill(
 name: "time-off-balance",
 description: "Calculate remaining vacation and sick days.",
 instructions: """
 1. Ask for the employee ID if not provided.
 2. Use calculate-balance to get the remaining balance.
 3. Present used and remaining days clearly.
 """)
 .AddScript("calculate-balance", (string employeeId, string leaveType) =>
 {
 int totalDays = HrDatabase.GetAnnualAllowance(employeeId, leaveType);
 int daysUsed = HrDatabase.GetDaysUsed(employeeId, leaveType);
 int remaining = totalDays - daysUsed;
 return JsonSerializer.Serialize(new { employeeId, leaveType, totalDays, daysUsed, remaining });
 });

Afegiu-lo al constructor igual que els altres:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseSkill(timeOffSkill)
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .Build();

Quan finalment s’envia el paquet NuGet, canvieu l’habilitat en línia per la basada en classe. L’agent no sap la diferència.

Però les habilitats en línia no són només per als ponts. També són l’opció correcta quan necessiteu generar habilitats de manera dinàmica en temps d’execució (penseu en una habilitat per unitat de negoci carregada des de la configuració) o quan un script s’ha de tancar a l’estat local que no pertany a un contenidor DI.

Aprovació de l’script: human-in-the-loop

Per als desenvolupadors de.NET que creem agents de producció, aquesta és la part que realment desbloqueja les converses de desplegament. Alguns scripts tenen conseqüències reals: inscriure algú als beneficis, consultar la producció infra. Gireu UseScriptApproval i l’agent s’aturarà abans d’executar qualsevol script:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseSkill(timeOffSkill)
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .UseScriptApproval(true)
 .Build();

Quan l’agent vol executar un script, torna una sol·licitud d’aprovació. La vostra aplicació recull la decisió (aprovar o rebutjar) i l’agent continua en conseqüència. En entorns regulats, aquesta és la diferència entre “podem desplegar això” i “legal diu que no”.

Per què és important aquesta combinació

El poder real no és cap patró d’autor, sinó la composició. Pots:

Comença petit amb una habilitat basada en fitxers, itera les instruccions i envia’l sense escriure C#
Envia habilitats reutilitzables com a paquets NuGet que altres equips poden afegir amb una línia
Rebre els buits amb habilitats en línia quan necessiteu alguna cosa ara
Filtreu els directoris d’habilitats compartits amb predicats perquè el vostre agent només carregui el que hauria de fer
Afegiu supervisió humana per als scripts que toquen els sistemes de producció

Tots ells es componen mitjançant AgentSkillsProviderBuilder. Sense encaminament especial, sense lògica condicional, sense comprovacions de tipus d’habilitat.

Tancant

Les habilitats d’agent a.NET ara tenen un model d’autoria realment flexible. Tant si sou un desenvolupador en solitari que dibuixa un prototip amb habilitats basades en fitxers com si un equip empresarial envia capacitats empaquetades mitjançant NuGet, els patrons s’ajusten. I el mecanisme d’aprovació de l’script fa que estigui llest per a la producció per a entorns on necessiteu aquest punt de control humà.

Consulteu l’anunci original per a la guia completa, la documentació d’habilitats de l’agent a Microsoft Learn i les mostres.NET a GitHub per fer-ho pràctica.

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.

Respostes de fons a Microsoft Agent Framework: no hi ha més ansietat de temps d'espera

Emiliano Montesdeoca — Thu, 26 Mar 2026 00:00:00 +0000

Si heu creat alguna cosa amb models de raonament com l’o3 o el GPT-5.2, coneixeu el dolor. El vostre agent comença a pensar en una tasca complexa, el client s’asseu allà esperant i en algun lloc entre “això està bé” i “s’ha estavellat?” la vostra connexió s’esgota. Tota aquesta feina? Desaparegut.

Microsoft Agent Framework acaba d’enviar respostes de fons i, sincerament, aquesta és una d’aquestes característiques que haurien d’haver existit des del primer dia.

El problema amb el bloqueig de trucades

En un patró de sol·licitud-resposta tradicional, el vostre client es bloqueja fins que l’agent acabi. Això funciona bé per a tasques ràpides. Però quan demaneu a un model de raonament que faci una investigació profunda, una anàlisi en diversos passos o que generi un informe de 20 pàgines? Esteu mirant els minuts del rellotge de paret. Durant aquesta finestra:

Les connexions HTTP es poden esgotar
Els blips de xarxa maten tota l’operació
El vostre usuari mira un spinner preguntant-se si està passant alguna cosa

Les respostes de fons donen la volta a això.

Com funcionen les fitxes de continuació

En lloc de bloquejar, inicieu la tasca de l’agent i recupereu un token de continuació. Penseu-ho com un bitllet de reclamació en un taller de reparacions: no us quedeu al taulell esperant, torneu quan estigui llest.

El flux és senzill:

Envieu la vostra sol·licitud amb AllowBackgroundResponses = true
Si l’agent admet el processament en segon pla, obtindreu un testimoni de continuació
Enquesta sobre el teu horari fins que el testimoni torni null; això vol dir que el resultat està preparat

Aquí teniu la versió de.NET:

AIAgent agent = new AzureOpenAIClient(
 new Uri("https://<myresource>.openai.azure.com"),
 new DefaultAzureCredential())
 .GetResponsesClient("<deployment-name>")
 .AsAIAgent();

AgentRunOptions options = new()
{
 AllowBackgroundResponses = true
};

AgentSession session = await agent.CreateSessionAsync();

AgentResponse response = await agent.RunAsync(
 "Write a detailed market analysis for the Q4 product launch.", session, options);

// Poll until complete
while (response.ContinuationToken is not null)
{
 await Task.Delay(TimeSpan.FromSeconds(2));
 options.ContinuationToken = response.ContinuationToken;
 response = await agent.RunAsync(session, options);
}

Console.WriteLine(response.Text);

Si l’agent completa immediatament (tasques senzilles, models que no necessiten processament en segon pla), no es retorna cap testimoni de continuació. El vostre codi només funciona, no cal cap manipulació especial.

Transmissió amb currículum: la veritable màgia

Les enquestes estan bé per als escenaris de foc i oblit, però què passa quan voleu progrés en temps real? Les respostes en segon pla també admeten la transmissió amb la represa integrada.

Cada actualització en streaming porta el seu propi testimoni de continuació. Si la vostra connexió cau a la meitat del flux, repreneu exactament on ho vau deixar:

AgentRunOptions options = new()
{
 AllowBackgroundResponses = true
};

AgentSession session = await agent.CreateSessionAsync();
AgentResponseUpdate? latestUpdate = null;

await foreach (var update in agent.RunStreamingAsync(
 "Write a detailed market analysis for the Q4 product launch.", session, options))
{
 Console.Write(update.Text);
 latestUpdate = update;
 break; // Simulate a network interruption
}

// Resume from exactly where we left off
options.ContinuationToken = latestUpdate?.ContinuationToken;
await foreach (var update in agent.RunStreamingAsync(session, options))
{
 Console.Write(update.Text);
}

L’agent continua processant el costat del servidor independentment del que passi amb el vostre client. Això és una tolerància a fallades integrada sense que escriviu la lògica de reintent o els interruptors.

Quan s’ha d’utilitzar realment

No totes les trucades d’agent necessiten respostes en segon pla. Per completar-les ràpidament, esteu afegint complexitat sense cap motiu. Però aquí és on brillen:

Tasques de raonament complexes: anàlisi en diversos passos, investigació profunda, qualsevol cosa que faci pensar realment a un model de raonament
Generació llarga de contingut: informes detallats, documents de diverses parts, anàlisis exhaustives
Xarxes poc fiables: clients mòbils, desplegaments perifèrics, VPN corporatives descabellades
Patrons UX asíncrons: envieu una tasca, aneu a fer una altra cosa, torneu per obtenir resultats

Per als desenvolupadors de.NET que creem aplicacions empresarials, aquesta última és especialment interessant. Penseu en una aplicació Blazor en què un usuari sol·licita un informe complex: desactiveu la tasca de l’agent, els mostreu un indicador de progrés i deixeu que continuï treballant. Sense gimnàstica WebSocket, sense infraestructura de cua personalitzada, només un testimoni i un bucle d’enquesta.

Tancant

Les respostes de fons estan disponibles ara tant a.NET com a Python mitjançant Microsoft Agent Framework. Si esteu creant agents que fan alguna cosa més complexa que les simples preguntes i respostes, val la pena afegir-ho al vostre conjunt d’eines. El patró de testimoni de continuació manté les coses senzilles alhora que resol un problema de producció molt real.

Consulteu la documentació completa per obtenir la referència completa de l’API i més exemples.