Come funziona un agente IA: un modello linguistico in un ciclo con strumenti

Il ciclo ragionamento – chiamata a strumento – risultato su un compito reale con gli articoli di questo sito, tre approcci e il loro costo in token, perché il contesto cresce, piano e memoria, l’affidabilità dei compiti lunghi con e senza verifica, e perché un agente ha bisogno di approvazione.

11 minuti Matěj Žalmánek 2026-10-16

Serie Basi di IA Parte 50 di 52

1. Mappa dell’intelligenza artificiale: che cos’è ciascuna cosa e come si incastra tutto
2. Breve storia dell’intelligenza artificiale: da Turing ai modelli linguistici
3. Dati, modello, addestramento, inferenza: i concetti di base su un unico esempio
4. Come leggere la notazione matematica: simboli, indici, sommatorie e quantificatori
5. Insiemi e relazioni: i mattoncini con cui si costruiscono le definizioni nell’IA
6. Funzioni e applicazioni: perché ogni modello di IA è una funzione
7. Logica e dimostrazioni: le regole con cui si ragiona nell’IA
8. Grafi e alberi: la struttura su cui poggiano la ricerca e le reti neurali
9. Algebra lineare per l’apprendimento automatico: vettori, matrici e perché l’IA soprattutto moltiplica
10. Derivate, gradiente e regola della catena: come un modello capisce in quale direzione imparare
11. Discesa del gradiente: come impara un modello
12. Che cos’è la probabilità: dal lancio di un dado agli assiomi di Kolmogorov
13. Probabilità condizionata e teorema di Bayes: come cambiare una stima quando scopri qualcosa di nuovo
14. Variabile aleatoria e funzione di ripartizione: una sola funzione che dice tutto sulla distribuzione
15. Funzione di densità e funzione di massa: perché una variabile continua ha probabilità zero in un punto
16. Valore atteso, varianza e covarianza: dove si trova una distribuzione, quanto è larga e che cosa è legato a che cosa
17. Panoramica delle distribuzioni di probabilità: Bernoulli, binomiale, Poisson, uniforme, normale ed esponenziale
18. Legge dei grandi numeri e teorema del limite centrale: perché le medie si comportano in modo così prevedibile
19. Statistica e stima dei parametri: massima verosimiglianza, MAP e intervalli di confidenza
20. Teoria dell’informazione: entropia, entropia incrociata e divergenza KL — da dove vengono le funzioni di perdita
21. Ricerca nello spazio degli stati: BFS, DFS, UCS e A* con animazioni
22. Giochi e avversari: minimax, potatura alfa-beta e Monte Carlo tree search
23. Soddisfacimento di vincoli: backtracking, propagazione dei vincoli e AC-3 su un sudoku e una mappa delle regioni ceche
24. Logica e sistemi basati sulla conoscenza: concatenazione in avanti e all’indietro, risoluzione e sistemi esperti
25. Pianificazione: STRIPS, il mondo dei blocchi, euristiche dal rilassamento e pianificazione negli agenti IA
26. Ricerca locale e ricottura simulata: un commesso viaggiatore tra i capoluoghi di regione cechi
27. Algoritmi genetici: popolazione, incrocio, mutazione e selezione su uno zaino per l’escursione
28. Strategie evolutive e programmazione genetica: dalla regola di un quinto alla legge di Keplero
29. Ottimizzazione con colonie di formiche: come una traccia di feromone trova un percorso breve
30. Ottimizzazione a sciame di particelle: inerzia, esperienza propria ed esperienza dello sciame
31. Neuroevoluzione: evoluzione dei pesi e della forma delle reti neurali e l’algoritmo NEAT
32. Insiemi fuzzy e funzioni di appartenenza: come scrivere «un po’ caldo»
33. Logica fuzzy e probabilità: perché «un po’ caldo» non significa «probabilmente caldo»
34. Logica fuzzy: t-norme, implicazioni e regole SE–ALLORA
35. Controllo fuzzy: Mamdani e Sugeno, dal ventilatore al pendolo inverso su un carrello
36. Clustering fuzzy: l’algoritmo fuzzy c-means e i punti tra i cluster
37. Sistemi neuro-fuzzy (ANFIS): regole fuzzy che imparano dai dati
38. Catene di Markov: matrice di transizione, distribuzione stazionaria e PageRank
39. Modelli di Markov nascosti: l’algoritmo di Viterbi e il casinò disonesto
40. Reti bayesiane: perché l’erba è bagnata e che cosa significa per l’irrigatore
41. Filtro di Kalman: come stimare da misure imprecise dove si trova un’auto e a che velocità va
42. Tipi di apprendimento automatico: supervisionato, non supervisionato, semi-supervisionato e altri
43. Prompt, contesto e RAG: come dare a un modello le informazioni giuste
44. Autoencoder variazionali (VAE): immagini nuove da uno spazio latente continuo
45. Reti generative avversarie (GAN): il falsario contro il detective
46. Modelli di diffusione: come il rumore puro diventa un’immagine
47. Processi decisionali di Markov: stati, azioni, ricompense ed equazioni di Bellman
48. Q-learning e DQN: imparare il valore delle azioni, dalla tabella alla rete neurale
49. Policy gradient e PPO: imparare direttamente la politica
50. Come funziona un agente IA: un modello linguistico in un ciclo con strumenti
51. Programmare con agenti IA: incarico, test e controllo
52. Valutazione e sicurezza dei sistemi di IA: come misurare e come sorvegliare

Programma completo della serie 52 di 83 argomenti pubblicati

Un modello linguistico, da solo, si limita a rispondere: riceve testo e restituisce testo. Un agente è un modello a cui diamo delle mani — strumenti con cui può scoprire o fare qualcosa — e che lasciamo lavorare in un ciclo finché non porta a termine il compito. Così funzionano gli agenti di programmazione, che da soli leggono il codice, eseguono i test e correggono gli errori, e gli assistenti che cercano sul web. E così funziona anche l’agente che controlli dal telefono con coden. In questa parte smontiamo il ciclo su un compito reale e calcoliamo quanto costa e dove si rompe.

Si collega alle parti Prompt, contesto e RAG, Tokenizzazione e Processi decisionali di Markov.

1. Un modello in un ciclo

Definizione — agente IA

Un agente è un programma in cui un modello linguistico ripetutamente (1) riceve il compito e quanto è successo finora, (2) decide cosa fare dopo — chiamare uno strumento o rispondere, (3) il programma ospite esegue davvero lo strumento e aggiunge il risultato al contesto. Il ciclo termina quando il modello scrive una risposta finale o si esaurisce il budget di passi. L’alternanza di ragionamento e azione è stata descritta da Shunyu Yao e coll. (2022) con il nome ReAct (reason + act).

v_k = M(c_k),   c_k+1 = c_k ⊕ v_k ⊕ N(v_k)

c_k

il contesto prima della k-esima chiamata al modello: il prompt di sistema, il compito e tutto ciò che è successo finora. È l’intero «stato» dell’agente — il modello non ricorda nient’altro

M

il modello linguistico; dal contesto scrive il passo successivo. L’unica parte che «pensa», e l’unica di cui non ci si può fidare del tutto

v_k

il passo del modello: ragionamento e chiamata a uno strumento, oppure la risposta finale (allora il ciclo termina)

N(v_k)

il risultato dello strumento, calcolato dal programma ospite; aggiunge al contesto ciò che il modello da solo non può sapere (il contenuto di un file, l’output dei test)

kontext = [prompt di sistema, descrizione degli strumenti, compito]
for k = 1 … K_max:                       # budget di passi
    krok = model(kontext)                # legge TUTTO il contesto
    kontext += krok
    if krok è la risposta finale: return la risposta
    if lo strumento richiede un consenso e la persona non l’ha dato:
        kontext += "rifiutato"; continue
    výsledek = proveď(krok.nástroj, krok.parametry)   # programma ospite
    kontext += výsledek
return "budget di passi esaurito"

2. Strumenti

Definizione — chiamata a strumenti (tool use, function calling)

Nel prompt si inserisce una descrizione degli strumenti: il nome, a cosa servono e quali parametri hanno (tipicamente come schema JSON). Il modello è perfezionato in modo da saper restituire, invece di testo normale, una chiamata strutturata, per esempio {"nastroj": "hledej", "text": "KL divergence"}. Il programma ospite verifica la chiamata, la esegue e restituisce il risultato come un ulteriore messaggio. Il modello da solo non avvia nulla — scrive soltanto cosa va avviato.

Il nostro agente lavora sui testi di 21 articoli meno recenti di questo sito (gli stessi delle parti sulla tokenizzazione e sul RAG; sono in ceco, quindi anche l’agente lavora in ceco) e ha tre strumenti. Il suo intero prompt di sistema conta 157 token:

Jsi agent, který odpovídá na otázky podle článků webu. Máš nástroje:
- seznam(): Vypíše články a jejich délku ve znacích.
- hledej(text, max): Najde výskyty textu ve všech článcích; vrátí článek, pozici a okolí.
- cti(clanek, od, do): Vrátí úsek článku od pozice do pozice (znaky).
V každém kroku napiš krátkou úvahu a zavolej jeden nástroj, nebo napiš konečnou odpověď s odkazem na článek. Když něco nenajdeš, zkus jiný dotaz.

Gli strumenti reali degli agenti di programmazione sono simili: cercare nei file, leggere una parte di un file, modificarlo, eseguire un comando nel terminale. Dal 2024 gli strumenti si possono collegare anche tramite il protocollo comune MCP (Model Context Protocol), così lo stesso strumento — un database, un calendario, un browser — può usarlo qualsiasi agente.

3. Una domanda, tre approcci

La domanda: «Perché la divergenza KL non è una distanza? Fai un esempio tratto dagli articoli.» (nell’originale: «Proč KL divergence není vzdálenost? Uveď příklad z článků.»). La risposta è nell’articolo sulla teoria dell’informazione: la divergenza KL non è simmetrica, D_KL(0,7 ‖ 0,5) = 0,119, ma D_KL(0,5 ‖ 0,7) = 0,126. I passi dell’agente li abbiamo scritti a mano — al posto del modello abbiamo scritto i ragionamenti e le chiamate. Gli strumenti, i loro risultati e i token sono però reali.

Esempio — perché D_KL(0,7 ‖ 0,5) ≠ D_KL(0,5 ‖ 0,7)

Per due distribuzioni sì/no (pioggia con probabilità p, il modello dice q) si ha D_KL(p ‖ q) = p log₂(p/q) + (1 − p) log₂((1 − p)/(1 − q)) bit.

D_KL(0,7 ‖ 0,5) = 0,7 · log₂ 1,4 + 0,3 · log₂ 0,6 = 0,340 − 0,221 = 0,119.

D_KL(0,5 ‖ 0,7) = 0,5 · log₂(5/7) + 0,5 · log₂(5/3) = −0,243 + 0,368 = 0,126.

Ogni volta si fa la media secondo una distribuzione diversa (secondo quella che è la realtà), perciò scambiare gli argomenti dà un altro numero — e una distanza (una metrica) deve essere simmetrica. Questa è la risposta che l’agente cerca.

1. Cerco esattamente le parole della domanda.

   hledej(text: "KL divergence není metrika")

   nic nenalezeno

   +34 token, contesto 209

2. Niente. Provo solo con il nome del concetto.

   hledej(text: "KL divergence")

   5 výskytů:
   informace:3258: … minimum je tam, kde model říká pravdu. KL divergence Definice — Kullbackova–Leiblerova diver…
   informace:3656: …,222 bitu. Podle Gibbsovy nerovnosti je KL divergence vždy nezáporná a nulová jen pro q = p .…
   informace:3717: …záporná  … (altri 310 caratteri)

   +205 token, contesto 414

3. È nell’articolo informace. Leggo il contesto attorno.

   cti(clanek: "informace", od: 3660, do: 3960)

   ivergence vždy nezáporná a nulová jen pro q = p . Pozor, KL divergence není vzdálenost: není symetrická. D KL (0,7 ‖ 0,5) = 0,119, ale D KL (0,5 ‖ 0,7) = 0,126. Záleží na tom, co je skutečnost a co model. Informační zisk Definice — podmíněná entropie H ( Y | X … (altri 40 caratteri)

   +146 token, contesto 560

Tre chiamate a strumenti, e la quarta chiamata al modello scrive la risposta. La prima ricerca non trova nulla — le parole della domanda non sono nel testo. L’agente lo vede e prova una query più generale; è il vantaggio del ciclo rispetto a un recupero una tantum. Alla fine il contesto conta 560 token.

1. Non so dove sia. Scorro gli articoli uno dopo l’altro.

   cti(clanek: "co-je-pravdepodobnost")

   Jazykový model nevybírá další slovo, ale pravděpodobnosti všech slov. Klasifikátor neříká „je to kočka“, ale „s pravděpodobností 0,93 je to kočka“. Celé strojov … (altri 7 175 caratteri)

   +1 933 token, contesto 2 108

2. Qui non c’è, articolo successivo.

   cti(clanek: "csp")

   Rozvrh hodin, ve kterém žádný učitel neučí dvě třídy naráz. Sudoku. Rozmístění součástek na desce, směny v nemocnici, přidělení letadel k branám. Všechny tyhle  … (altri 11 914 caratteri)

   +3 148 token, contesto 5 256
3. … altri 8 passi dello stesso tipo (contesto alla fine: 24 927 token)

Senza cercare, l’agente scorre gli articoli in ordine alfabetico. Si imbatte nella risposta solo al 10º articolo, e nel frattempo il contesto cresce fino a 24 927 token.

E il terzo approccio, il RAG una tantum della parte precedente: recuperare i tre frammenti più simili e inserirli nel prompt. Tutti e tre i frammenti vengono dall’articolo giusto (informace, informace, informace), ma nessuno contiene l’esempio con i numeri 0,119 e 0,126 — la risposta sarebbe senza esempio. Un agente in un ciclo può dirsi «non basta, continuo a leggere». Un recupero una tantum no.

4. Il contesto costa caro

Definizione — il costo del ciclo

Il modello non ha memoria tra una chiamata e l’altra; a ogni passo rilegge tutto il contesto — il prompt di sistema, il compito e tutti i passi e i risultati degli strumenti finora. Se c_k è la lunghezza del contesto prima della k-esima chiamata, il modello elabora in totale ∑_k c_k token. Poiché il contesto cresce a ogni passo, il costo totale cresce all’incirca con il quadrato del numero di passi.

L’approccio «leggi tutto» costa 141 820 token elaborati, «cerca e leggi un estratto» solo 1 358 — 104 volte meno, per la stessa risposta. Per questo i buoni agenti di programmazione prima cercano (grep) e leggono solo pezzi di file. E per questo una sessione lunga viene di tanto in tanto compattata: la parte più vecchia della conversazione viene sostituita da un riassunto, perché il contesto ci stia e il modello non ci si perda. Aiuta anche salvare l’inizio del prompt in cache (prompt caching), grazie a cui rileggere lo stesso inizio costa meno.

Z = ∑_k=1^K c_k,   c_k = c₁ + ∑_j<k (v_j + o_j)

Z

i token elaborati in totale — ciò che si paga e ciò che si aspetta

K

il numero di chiamate al modello (passi con strumento + risposta finale); ogni chiamata rilegge il contesto dall’inizio

c₁

il prompt di sistema e il compito; sono nel contesto dalla prima chiamata, quindi si pagano K volte — per questo conviene tenerli brevi e salvarli in cache

v_j + o_j

i token aggiunti dal passo j: la chiamata e il risultato dello strumento. Il passo j viene letto in tutte le chiamate successive, per questo un risultato lungo di uno strumento si paga molte volte

Teorema — il costo cresce con il quadrato del numero di passi

Se ogni passo aggiunge lo stesso numero d di token, allora c_k = c₁ + (k − 1) d e

Z = K c₁ + d · K(K − 1) / 2.

Dimostrazione: ∑_k=1^K (k − 1) = 0 + 1 + … + (K − 1) = K(K − 1) / 2. ∎ Per K grande prevale il secondo termine ≈ d K² / 2: una sessione lunga il doppio costa circa quattro volte tanto.

Esempio — ricalcolo dei due approcci

Cerca e leggi un estratto. Il prompt di sistema conta 157 token, la domanda 18, quindi c₁ = 175. Dopo i tre passi il contesto conta 209, 414, 560 token. Le quattro chiamate al modello leggono Z = 175 + 209 + 414 + 560 = 1 358 token.

Leggi tutto. K = 11 chiamate, il contesto cresce da 175 a 24 927 token, in media di d = (24 927 − 175) / 10 ≈ 2 475 per passo. Secondo il teorema Z ≈ 11 · 175 + 2 475 · 11 · 10 / 2 = 138 050; in realtà sono 141 820 (gli articoli hanno lunghezze diverse, quindi i passi non aggiungono esattamente la stessa quantità). Il prompt di sistema con la domanda ne rappresenta solo 1 925 token — quasi tutto il resto è rilettura degli articoli.

5. Piano e memoria

Definizione — pianificazione e memoria dell’agente

Un piano è un elenco di passi che l’agente scrive all’inizio nel contesto e poi spunta e aggiusta strada facendo. La memoria di lavoro è il contesto di una singola sessione. La memoria a lungo termine sono file o database fuori dal modello — note che l’agente scrive e rilegge nella sessione successiva. I sottoagenti ricevono un contesto separato per un sottocompito e restituiscono solo il risultato, così non riempiono di dettagli il contesto principale.

Negli agenti di programmazione la memoria a lungo termine è di solito un semplice file di testo nel progetto (regole, comandi, cose a cui fare attenzione) che l’agente legge all’inizio di ogni sessione. È la memoria più semplice e più trasparente: una persona può leggerla e anche correggerla.

6. Compiti lunghi e verifica

Un agente che fa il passo giusto nel 90 % dei casi sembra affidabile. Solo che un compito è fatto di molti passi, e un errore in uno qualsiasi di essi lo rovina. Se un passo riesce con probabilità p, l’intero compito di n passi riesce con probabilità pⁿ — a patto che l’agente non riconosca gli errori.

Definizione — ciclo chiuso con retroazione

Dopo un passo l’agente verifica il risultato (esegue i test, legge l’output di un comando, lo confronta con quanto atteso). Se riconosce un errore con probabilità d e può ripetere un passo fino a r volte, il tasso di successo di un passo è q = p ∑_k=0^r ((1 − p) d)^k e quello dell’intero compito qⁿ.

q = p ∑_k=0^r ((1 − p) d)^k = p + p (1 − p) d + p ((1 − p) d)² + …

p

il tentativo riesce; ogni addendo termina con esattamente un tentativo riuscito

1 − p

il tentativo fallisce; ogni fallimento prima del successo costa un fattore del genere

d

la verifica riconosce il fallimento; solo allora l’agente ripete il passo — un errore non riconosciuto passa oltre e rovina il compito

∑_k=0^r, k

k = quanti tentativi sono falliti prima che uno riuscisse; al massimo r ripetizioni, perché l’agente non ci provi all’infinito

Con p = 0,9 e venti passi, senza verifica riesce solo il 12 % dei compiti, con verifica il 79 %. Una simulazione di 20 000 compiti dà il 12 % e il 79 %: la formula torna. Anche un passo molto buono (p = 0,99) su cento passi senza verifica fallisce più spesso di quanto riesca (37 %); con verifica riesce nel 90 %. È questo il motivo principale per cui gli agenti di programmazione funzionano così bene: il codice si può eseguire e testare, quindi quasi ogni passo ha un riscontro. L’organizzazione METR (2025) misura che la lunghezza dei compiti che gli agenti portano a termine nella metà dei casi raddoppia all’incirca ogni sette mesi.

Esempio — p = 0,9, d = 0,9, r = 2, venti passi

Tasso di successo di un passo: q = 0,9 + 0,9 · 0,1 · 0,9 + 0,9 · (0,1 · 0,9)² = 0,9 + 0,081 + 0,00729 = 0,98829.

L’intero compito: senza verifica 0,9²⁰ = 0,122, con verifica 0,98829²⁰ = 0,790. Il passo è migliorato solo dal 90 % al 98,8 %, ma il compito dal 12 % al 79 % — la potenza n gonfia le piccole differenze nel passo.

Definizione — la lunghezza del compito che un agente porta a termine nella metà dei casi

È il più grande n per cui qⁿ ≥ 1/2, cioè n_½ = ln 0,5 / ln q ≈ 0,69 / (1 − q) per q vicino a 1.

Nel nostro modello: p = 0,9 senza verifica 6,6 passi, con verifica 58,8; p = 0,99 senza verifica 69,0, con verifica 686. Il compito che un agente porta a termine una volta su due si allunga all’incirca in proporzione a quante volte scende il tasso di errore di un passo 1 − q.

La stessa grandezza (la lunghezza del compito che un agente porta a termine nel 50 % dei casi) la misura METR — solo non in passi, ma nel tempo che il compito richiederebbe a una persona (Thomas Kwa e coll., Measuring AI Ability to Complete Long Tasks, 2025). La nostra formula è un modello semplificato con passi indipendenti, non il loro metodo.

7. Permessi e supervisione

Un agente che può eseguire comandi può anche fare danni — per errore (cancella la cartella sbagliata) o seguendo un’istruzione letta in un testo altrui (prompt injection). La difesa non si basa sul modello, ma sul programma ospite: strumenti con permessi limitati, esecuzione in un ambiente isolato e soprattutto l’approvazione — i passi pericolosi o irreversibili vengono eseguiti solo dopo il consenso di una persona. Su questo si basa anche coden: l’agente lavora sul tuo computer e tu approvi i suoi passi dal telefono.

8. Riepilogo

• Agente = un modello linguistico in un ciclo: ragionamento, chiamata a uno strumento, risultato nel contesto, da capo.
• Il modello descrive gli strumenti solo con una chiamata strutturata; li esegue il programma ospite, che può imporre delle regole.
• Un ciclo sa rimediare a una ricerca fallita — il RAG una tantum no.
• Ogni chiamata rilegge tutto il contesto: «leggi tutto» è costato 141 820 token, «cerca e leggi un estratto» 1 358.
• Un piano, note nei file e sottoagenti mantengono il contesto piccolo e ordinato.
• Senza verifica il tasso di successo cala con la lunghezza del compito come pⁿ; test e verifiche cambiano le cose (20 passi con p = 0,9: 12 % → 79 %).

Vuoi provarlo con mano? Chiedi a un agente IA di descriverti ogni chiamata a strumento che fa durante un compito e, alla fine, di stimare quanti token gli è costato il compito. Poi dagli lo stesso compito con l’istruzione «prima cerca, leggi solo estratti».

La vedi diversamente? Scrivi a support@coden-app.com.