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.

Altri articoli del blog