Agenti AI: cosa sono e come funzionano davvero

Cosa distingue un agente da una chiamata API

Un agente di intelligenza artificiale è un modello linguistico messo dentro un ciclo, con la possibilità di usare strumenti esterni e con un criterio per capire quando ha finito. La definizione sta tutta qui, e ogni pezzo pesa. Il modello da solo produce testo e basta; il ciclo gli permette di lavorare per passaggi successivi; gli strumenti gli permettono di agire fuori dal testo (cercare, leggere file, chiamare API); il criterio di terminazione gli impedisce di girare per sempre.

La confusione nasce perché sotto l'etichetta "agente" il mercato vende tre architetture diverse. Si distinguono con una sola domanda: chi decide i passaggi?

• Chiamata singola. Un prompt entra, un testo esce. Nessun passaggio intermedio: decide tutto chi ha scritto il prompt.
• Catena fissa. Più chiamate in sequenza, con l'ordine cablato nel codice. Il modello esegue ogni anello, ma la strada l'ha decisa lo sviluppatore in anticipo. È l'architettura giusta più spesso di quanto si ammetta.
• Agente. I passaggi li decide il modello, a ogni giro del ciclo. Lo sviluppatore fissa l'obiettivo, gli strumenti disponibili e i limiti; la strada per arrivarci no.

"Agentic AI", il termine inglese che domina il marketing, indica esattamente la terza architettura: sistemi in cui la strategia è delegata al modello. Non è una tecnologia diversa dagli agenti AI, è lo stesso meccanismo con un nome più vendibile.

risposta = modello.completa(
    prompt="Riassumi questo contratto in cinque punti."
)
print(risposta)   # un passaggio solo, deciso da chi scrive il codice

Il ciclo di base: osservare, ragionare, agire

Il funzionamento di un agente si riduce a un ciclo con quattro momenti, uguale in tutti i framework.

1. Osservazione. Il modello riceve l'obiettivo e tutto il contesto accumulato fino a quel punto: le azioni già compiute e i loro esiti.
2. Ragionamento. Sulla base di quel contesto decide il passo successivo: usare uno strumento, oppure dichiarare concluso il lavoro.
3. Azione. Se ha scelto uno strumento, il codice che circonda il modello lo esegue davvero: lancia la ricerca, legge il file, chiama l'API.
4. Osservazione del risultato. L'esito dell'azione viene aggiunto al contesto, e il giro ricomincia dal punto uno.

Il ciclo si chiude quando il criterio di terminazione è soddisfatto: il modello dichiara di aver finito e produce la risposta, oppure una verifica esterna convalida il risultato, oppure scatta il limite massimo di passaggi. Senza uno di questi tre eventi, il ciclo continua.

L'idea ha un'origine precisa: il paper ReAct: Synergizing Reasoning and Acting in Language Models, pubblicato in preprint nell'ottobre 2022, che ha mostrato come alternare ragionamento esplicito e azioni produce risultati migliori del solo ragionare o del solo agire. Quasi tutti i framework di agenti in circolazione discendono da quello schema, con variazioni sul formato del ragionamento e sul modo di invocare gli strumenti.

contesto = [obiettivo]                     # tutto ciò che l'agente ha visto

for passo in range(MAX_PASSI):             # senza tetto, può non finire
    decisione = modello.ragiona(contesto)  # osserva e sceglie il passo

    if decisione.finito:                   # criterio di terminazione
        break

    esito = strumenti.esegui(decisione.azione)
    contesto += [decisione.azione, esito]  # osserva il risultato

risultato = decisione.risposta

I componenti reali di un agente

Spogliato dei nomi commerciali, un agente ha cinque componenti. Trascurarne uno si paga sempre, di solito in produzione.

• Il modello. Determina la qualità del ragionamento e l'affidabilità nelle chiamate agli strumenti. È anche l'unico componente con un costo variabile: ogni giro del ciclo è una chiamata che consuma token.
• Gli strumenti. Funzioni descritte al modello con nome, parametri e scopo. Il modello non le esegue: chiede di eseguirle, e il codice attorno le esegue per lui, restituendogli l'esito. Un agente senza strumenti è solo un generatore di testo dentro un ciclo.
• La memoria. Nel caso minimo è il contesto accumulato durante l'esecuzione. Nei sistemi più evoluti si aggiunge una memoria che sopravvive fra un'esecuzione e l'altra. La finestra di contesto è finita: decidere cosa tenere e cosa scartare è uno dei problemi pratici più sottovalutati.
• Il criterio di stop. La condizione che chiude il ciclo. Più è verificabile (un test che passa, uno schema dati rispettato), più l'agente è affidabile. Se coincide con "il modello dice di aver finito", la qualità dipende dall'autovalutazione del modello, che tende a essere generosa.
• I limiti operativi. Numero massimo di iterazioni, budget di token o di spesa, timeout. Non sono rifiniture: sono la differenza fra un sistema con un costo massimo noto e uno senza.

Sistemi multi agente: cosa si guadagna e cosa si perde

Un singolo agente con troppi strumenti e un obiettivo largo peggiora in modo misurabile: il contesto si affolla, le istruzioni si contraddicono, la scelta dello strumento giusto diventa essa stessa una fonte di errore. La risposta più diffusa è dividere il lavoro fra più agenti con ruoli stretti. Il guadagno è triplice.

• Contesto pulito. Ogni agente vede solo le istruzioni e i dati del proprio ruolo. Meno rumore nel prompt significa meno errori.
• Specializzazione. Ogni ruolo può usare un modello diverso (uno economico per lo smistamento, uno capace per l'analisi), strumenti diversi e istruzioni scritte per un compito solo.
• Verifica incrociata. Un agente può controllare l'output di un altro con occhi non contaminati dal processo che lo ha prodotto. Non elimina gli errori, ne intercetta una parte.

Il prezzo è altrettanto concreto. Ogni passaggio di contesto fra agenti è almeno una chiamata al modello in più, quindi più token e più latenza. E l'imprevedibilità si compone: l'errore di un agente diventa l'input pulito del successivo, che lo tratta come un fatto.

I framework esistono per organizzare questo coordinamento senza riscriverlo ogni volta. CrewAI è uno dei modi di farlo: descrivi la squadra come ruoli e compiti espliciti, e il framework si occupa di prompt, passaggi di contesto e processo. Altri strumenti fanno scelte diverse, dal grafo di stati al passaggio di mano fra agenti: il confronto fra i framework li mette in fila.

Cosa fanno bene oggi, e cosa no

La regola empirica più affidabile: gli agenti funzionano dove l'esito si può verificare automaticamente e un errore è tollerabile; falliscono dove serve esattezza deterministica o dove la responsabilità non è delegabile.

Fanno bene:

• compiti il cui risultato si controlla con un test: codice che compila e passa la suite, dati estratti che rispettano uno schema, risposte confrontabili con una fonte;
• compiti dove una bozza imperfetta ha già valore, perché la revisione umana costa meno della produzione da zero;
• volumi che nessuno coprirebbe a mano: cento richieste smistate con il 95% di accuratezza valgono più di venti smistate alla perfezione.

Fanno male:

• processi che richiedono lo stesso output a parità di input, sempre: contabilità, calcolo fiscale, qualunque cosa con la parola "quadratura" dentro;
• decisioni con conseguenze legali dirette sulle persone: diagnosi, pareri legali, selezione del personale, concessione di credito. Qui il vincolo non è solo tecnico, è anche normativo;
• compiti dove verificare l'output costa quanto produrlo: se per fidarti della sintesi devi rileggere i documenti, l'agente non ti ha fatto risparmiare nulla.

Un agente sbaglia per costruzione, non per sfortuna: a ogni passo campiona da una distribuzione di probabilità. L'errore si contiene con limiti, verifiche e revisione; non si elimina. Chi promette il contrario sta vendendo qualcosa.

Esempi concreti, con il livello di difficoltà

Quattro casi realistici, in ordine di difficoltà crescente di messa in produzione. Per ciascuno, la parte che i tutorial omettono: cosa serve perché funzioni davvero.

Triage di richieste in arrivo (difficoltà bassa)

Leggere email o ticket, classificarli e smistarli alla coda giusta, con un primo abbozzo di risposta. Funziona perché un errore di smistamento si corregge dopo e costa poco. Perché funzioni davvero servono categorie definite e distinguibili, una categoria "non so" con una soglia di confidenza che manda i casi dubbi a un umano, e la misura dell'accuratezza su un campione etichettato a mano prima di andare in produzione.

Ricerca e sintesi documentale (difficoltà media)

Raccogliere informazioni da più fonti e produrre una sintesi con riferimenti. Il rischio non è il testo brutto: è la sintesi plausibile e sbagliata. Servono accesso alle fonti giuste (documenti interni indicizzati, non solo web aperto), l'obbligo per l'agente di citare la fonte di ogni affermazione, e un flusso in cui il lettore risale alla fonte in un clic. La revisione umana resta nel giro: l'agente accorcia la ricerca, non la sostituisce.

Estrazione dati da documenti non strutturati (difficoltà media)

Fatture, contratti, PDF eterogenei trasformati in campi strutturati. È il caso con la verifica automatica migliore: uno schema rigido convalida ogni campo estratto. Servono regole di validazione severe (formati, intervalli, totali che devono quadrare), una soglia sotto la quale il documento passa a un operatore, e un campione di riferimento per misurare l'accuratezza campo per campo, non solo complessiva.

Primo abbozzo di codice (difficoltà medio-alta)

Generare la prima versione di una funzione, di un test, di una migrazione. Funziona bene proprio dove esiste la verifica perfetta: la suite di test. Servono test automatici che definiscono cosa vuol dire "funziona" prima che l'agente scriva, un progetto con convenzioni chiare che il modello possa leggere, e una revisione umana che tratta l'output come la bozza di un collega alle prime armi: utile, mai accettata sulla parola. Senza test, il codice generato è debito tecnico consegnato a domicilio.

Il costo vero: token, latenza, variabilità

Il conto economico di un agente ha una proprietà che sorprende chi arriva dal software tradizionale: il costo per esecuzione non è fisso. Il numero di passaggi lo decide il modello a ogni esecuzione, quindi due richieste identiche in apparenza possono costare una il triplo dell'altra.

E il costo cresce più che linearmente con i passaggi: a ogni giro del ciclo il contesto accumulato viene rimandato al modello per intero, e il decimo passaggio porta con sé i nove precedenti. Un compito da dieci passaggi non costa dieci volte uno da un passaggio: costa di più.

La latenza segue la stessa curva. Ogni passaggio è una chiamata al modello più l'esecuzione di uno strumento: un agente che lavora sul serio impiega minuti, non secondi. Per un processo notturno è irrilevante; per una risposta in tempo reale è spesso squalificante.

Come capire se un agente serve davvero

Prima di aprire l'editor, sei domande. Se le risposte non convincono, la soluzione giusta è quasi sempre più semplice di un agente.

• Il compito ha un criterio di successo verificabile? Se non sai descrivere come si riconosce un risultato giusto, non puoi delegarlo a un sistema che sbaglia in silenzio.
• Quanto costa un errore? Centesimi e reversibile: buon candidato. Un cliente perso o una sanzione: serve un umano nel mezzo, o non serve un agente.
• C'è un umano che controlla, e dove?"Lo controlleremo a campione" detto prima di partire diventa "non lo controlla nessuno" dopo un mese. Il punto di controllo va disegnato dentro il flusso.
• I passaggi sono davvero imprevedibili? Se ogni esecuzione segue gli stessi passi, una catena fissa costa meno, corre più veloce e sbaglia meno. L'agente si paga solo dove la strada cambia da caso a caso.
• Il volume giustifica il sistema? Dieci casi al giorno li gestisce una persona con un buon prompt e mezz'ora. L'infrastruttura di un agente si ripaga sul volume.
• Puoi permetterti la variabilità del costo? Se il budget per esecuzione deve essere prevedibile al centesimo, la risposta è già no.

Il quadro normativo, in breve

Gli agenti messi in produzione in Europa ricadono nel campo di applicazione dell'AI Act, il regolamento (UE) 2024/1689, in vigore dal 1 agosto 2024 con obblighi che si applicano a scaglioni fra il 2025 e il 2027. Per chi usa agenti contano tre cose sopra le altre: capire se il caso d'uso rientra fra quelli ad alto rischio (molte decisioni sulle persone lo sono), gli obblighi di trasparenza verso chi interagisce con un sistema automatico, e la ripartizione delle responsabilità fra chi fornisce il modello e chi lo mette in servizio. La pagina su AI Act e agenti tratta il tema per esteso, obbligo per obbligo.