Orchestrazione di agenti AI: pattern, framework e un esempio in ASP.NET Core

🎼 Dall'agente singolo all'orchestra

L'orchestrazione di agenti AI è il livello che coordina più agenti specializzati per portare a termine compiti che nessun agente singolo gestisce da solo. È il direttore d'orchestra: ogni agente suona il suo strumento, l'orchestrazione fa in modo che suonino insieme. Non è teoria — le richieste sui sistemi multi-agente sono cresciute del 1.445% nel 2025 e il 57% delle organizzazioni ha già workflow multi-step in produzione.

Il motivo è pratico. Le sessioni degli agenti di coding sono passate da 4 a 23 minuti di media, con il 78% che tocca più file. Un solo agente su questa complessità perde il filo; dividere le responsabilità tra agenti con confini chiari è ciò che rende il risultato robusto. Non a caso si parla di un 90% di ingegneri che stanno spostando il baricentro dallo scrivere codice al dirigere, rivedere e ottimizzare agenti.

🧩 I 4 pattern di orchestrazione

Non tutti i sistemi multi-agente sono uguali: l'architettura dipende dal caso d'uso. Nel 2026 dominano quattro pattern, e riconoscerli è il primo passo per non montare un castello dove basterebbe una pipeline.

La regola pratica che seguo: parti dal gerarchico (delega ordinata) e aggiungi complessità solo quando serve. Il collaborativo brilla sui problemi creativi, il competitivo quando vuoi il migliore tra più tentativi, l'ibrido è ciò che finisce in produzione perché mescola i tre a seconda del sotto-task.

• Gerarchico: un planner scompone il task e delega a worker specializzati (code, test, review). È il più comune nello sviluppo software.
• Collaborativo: agenti pari che condividono stato e si migliorano a vicenda, come una design review tra backend, frontend e DevOps.
• Competitivo: più agenti tentano lo stesso task e un valutatore sceglie il risultato migliore per performance, leggibilità o sicurezza.
• Ibrido: i sistemi reali combinano i pattern — un planner gerarchico che delega a team collaborativi con valutazione competitiva sugli output critici.

Gerarchico per la delega, collaborativo per la creatività, competitivo per l'ottimizzazione, ibrido per la produzione.

🛠️ I framework che contano nel 2026

Il panorama si è consolidato. Nel mondo Python comandano LangGraph (grafi di stato, lo standard di fatto per i workflow complessi, in produzione da Klarna a Cisco), CrewAI (agenti a ruoli, curva di apprendimento dolce) e AutoGen (l'approccio conversazionale nato in Microsoft Research). Per chi lavora su piattaforma .NET, invece, il riferimento è il Microsoft Agent Framework.

Il Microsoft Agent Framework è la sintesi ufficiale di AutoGen e Semantic Kernel: ne eredita le astrazioni semplici e le feature enterprise (stato di sessione, type safety, telemetria) e aggiunge workflow a grafo per l'orchestrazione esplicita. È arrivato alla 1.0 (GA) il 3 aprile 2026, quindi è la scelta naturale se il tuo stack è C# e ASP.NET Core.

🗺️ Un metodo in 6 passi

Prima del codice, il metodo. Le squadre che portano davvero l'orchestrazione in produzione seguono sei mosse ripetibili, indipendenti dal framework. Saltarne una è il modo più comune per restare bloccati in un proof of concept che non scala.

Il cuore sono i passi 5 e 6: senza error recovery e senza observability hai un prototipo, non un sistema. È la differenza tra una demo che stupisce e qualcosa che regge il traffico reale.

🧰 Preparare il progetto ASP.NET Core

Passiamo alla pratica con il Microsoft Agent Framework. Creo una Web API minimal e aggiungo tre pacchetti: il framework degli agenti, le sue estensioni di hosting per ASP.NET Core e un provider per il modello. Le librerie di hosting registrano gli agenti nel container di dependency injection, così li risolvo come qualunque altro servizio.

Le astrazioni di Microsoft.Extensions.AI (IChatClient) tengono il codice indipendente dal provider: oggi OpenAI, domani Azure OpenAI o un modello locale via Ollama, cambiando una riga. I pacchetti dell'Agent Framework sono in preview, quindi li aggiungo con --prerelease.

# nuova Web API minimal
dotnet new web -n DevCrew.Orchestration && cd DevCrew.Orchestration

# Agent Framework + hosting ASP.NET Core + provider del modello
dotnet add package Microsoft.Agents.AI --prerelease
dotnet add package Microsoft.Agents.AI.Hosting --prerelease
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease

🧑‍🚀 Registrare gli agenti e il workflow

Ora il cuore dell'orchestrazione. Registro un IChatClient condiviso come keyed singleton, poi quattro agenti specializzati con AddAIAgent: architect, coder, tester, reviewer. Ognuno ha istruzioni mirate e riusa lo stesso modello tramite chatClientServiceKey.

Con AddWorkflow li compongo in una pipeline sequenziale — il pattern gerarchico nella sua forma più diretta: l'output di ogni agente diventa l'input del successivo. La chiamata AddAsAIAgent() espone l'intero workflow come se fosse un singolo agente, pronto da risolvere via DI.

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using OpenAI;

var builder = WebApplication.CreateBuilder(args);

// 1) Modello condiviso da tutti gli agenti: un IChatClient keyed.
var apiKey = builder.Configuration["OpenAI:ApiKey"]!;
IChatClient chat = new OpenAIClient(apiKey)
    .GetChatClient("gpt-4o-mini")
    .AsIChatClient();
builder.Services.AddKeyedSingleton<IChatClient>("chat-model", chat);

// 2) Quattro agenti specializzati, uno per responsabilita'.
builder.AddAIAgent("architect",
    instructions: "Analizzi la codebase e proponi il piano.", chatClientServiceKey: "chat-model");
builder.AddAIAgent("coder",
    instructions: "Implementi il piano scrivendo il codice.", chatClientServiceKey: "chat-model");
builder.AddAIAgent("tester",
    instructions: "Scrivi ed esegui i test sul codice.", chatClientServiceKey: "chat-model");
builder.AddAIAgent("reviewer",
    instructions: "Rivedi qualita' e sicurezza, restituisci la versione finale.", chatClientServiceKey: "chat-model");

// 3) Workflow gerarchico: pipeline sequenziale dei quattro agenti.
builder.AddWorkflow("dev-crew", (sp, key) =>
{
    var architect = sp.GetRequiredKeyedService<AIAgent>("architect");
    var coder = sp.GetRequiredKeyedService<AIAgent>("coder");
    var tester = sp.GetRequiredKeyedService<AIAgent>("tester");
    var reviewer = sp.GetRequiredKeyedService<AIAgent>("reviewer");
    return AgentWorkflowBuilder.BuildSequential(key, [architect, coder, tester, reviewer]);
}).AddAsAIAgent();

🔌 Esporre l'orchestrazione con un endpoint

Il workflow è un AIAgent registrato con la chiave dev-crew: lo espongo con un endpoint Minimal API risolvendolo dal container con FromKeyedServices. Nessun controller, nessuna cerimonia — una POST, un task, la risposta orchestrata.

In pratica il client manda l'obiettivo (“aggiungi l'endpoint di login con test”) e sotto al cofano architect, coder, tester e reviewer si passano il lavoro in sequenza. Il chiamante vede un solo risultato finale.

using Microsoft.Agents.AI;
using Microsoft.Extensions.DependencyInjection;

var app = builder.Build();

// L'orchestrazione e' un AIAgent keyed: la risolvo e la eseguo.
app.MapPost("/orchestrate", async (
    OrchestrationRequest body,
    [FromKeyedServices("dev-crew")] AIAgent crew) =>
{
    var run = await crew.RunAsync(body.Task);
    return Results.Ok(new { output = run.Text });
});

app.Run();

record OrchestrationRequest(string Task);

🔀 Concurrent e handoff: gli altri due pattern

Cambiare pattern costa una riga. Con BuildConcurrent gli stessi input vanno a più agenti in parallelo e i risultati si aggregano: è il pattern competitivo/collaborativo, utile per brainstorming o per confrontare più implementazioni.

Con CreateHandoffBuilderWith costruisci invece il pattern handoff: un agente di triage instrada la richiesta allo specialista giusto, che può restituire il controllo. È il modello tipico del supporto clienti o dei sistemi esperti, dove la delega è dinamica e dipende dal contenuto.

// Concorrente: stessi input a piu' agenti in parallelo, risultati aggregati.
var concurrent = AgentWorkflowBuilder.BuildConcurrent(
    [architect, coder, tester]);

// Handoff: un triage instrada, gli specialisti possono tornare al triage.
var handoff = AgentWorkflowBuilder.CreateHandoffBuilderWith(triage)
    .WithHandoffs(triage, [backendAgent, frontendAgent])
    .WithHandoffs([backendAgent, frontendAgent], triage)
    .Build();

🏭 Dalla demo alla produzione

Qui si separa il giocattolo dal sistema. Il primo tema è il costo: gli strumenti agentici possono valere 200-2.000 dollari al mese per ingegnere in token, e il multi-agente moltiplica la spesa perché cinque agenti su un task consumano cinque volte. Servono budget per workflow, tracciamento e contesti ottimizzati; il ROI c'è (2,5-3,5x in media, fino a 4-6x per i migliori) ma solo con i controlli giusti.

Il secondo è la sicurezza: il codice generato dall'AI ha 2,74 volte più vulnerabilità di quello umano, e nei sistemi multi-agente i difetti si compongono mentre gli agenti costruiscono l'uno sull'output dell'altro. Scanning nel pipeline, review umana sui cambiamenti critici, ambienti sandbox. E infine gli MCP server: sono lo strato di capacità (database, API, ricerca) che gli agenti usano senza sapere come funziona ogni tool — con oltre 5.000 server disponibili, sono diventati fondamentali.

✅ In sintesi

L'orchestrazione di agenti AI non è un concetto futuro: è il modo in cui si costruisce software complesso nel 2026. Scegli il pattern in base al task, dai a ogni agente un confine chiaro, e investi in observability dal primo giorno. In .NET il Microsoft Agent Framework rende tutto questo poche righe dentro la tua Web API.

Il resto è ingegneria di sempre: misura, limita il blast radius di ogni agente, tieni l'umano in cabina di regia sulle decisioni critiche. Meno magia, più metodo.