Come funzionano gli LLM: dai Transformer del 2017 ai modelli 2026

Dietro a ogni singola risposta di ChatGPT lavorano centinaia di miliardi di parametri, organizzati in una struttura matematica nata in un paper pubblicato il 12 giugno 2017 da quindici ricercatori di Google. Tutti usiamo gli LLM ogni giorno, ma pochissimi sanno cosa accade davvero tra il momento in cui premi invio e la comparsa della risposta. In questa guida ti porto dentro il motore.

Partiamo dal mondo pre-Transformer, entriamo nell’anatomia del paper Attention is All You Need, arriviamo ai modelli di frontiera del 2026 e finiamo con quello che tutto questo significa concretamente se lavori nella search. Il testo principale è scritto perché lo possa leggere chiunque abbia curiosità: uno studente di liceo, un marketer, un developer.

I box Approfondimento tecnico sono colorati e contengono formule, pseudo-codice e dimensioni dei tensori — lì dentro scendo al livello universitario, e se vuoi saltarli la guida resta comunque completa. Ti anticipo una cosa: capire come pensano gli LLM nel 2026 non è più un lusso per chi lavora nella SEO. È diventato il fondamento.

---

Cos’è davvero un Large Language Model

Partiamo dalla definizione più onesta che posso darti: un Large Language Model è un predittore di token. Tutto qui. Gli dai un testo in input, e lui calcola quale sarà il pezzetto di testo successivo più probabile. Poi ripete. Poi ripete ancora. Un token alla volta, finché non produce un segnale speciale di “ho finito” oppure raggiunge il limite che gli hai imposto. Non c’è pensiero cosciente, non c’è ragionamento nel senso in cui lo intendi tu quando risolvi un problema. C’è una funzione matematica gigantesca che prende una sequenza di numeri e ne restituisce un’altra.

Ti sembra poco? Aspetta, perché il “Large” non è decorativo. Indica modelli con decine o centinaia di miliardi di parametri — i pesi delle connessioni tra i neuroni artificiali — addestrati su trilioni di token di testo provenienti da libri, codice sorgente, articoli scientifici, forum, enciclopedie. La scala conta, e conta tantissimo: come vedremo quando parleremo di scaling laws, la qualità delle risposte cresce con il numero di parametri e con la quantità di dati di addestramento seguendo leggi matematiche prevedibili. Scoperta scientifica, non magia.

C’è una distinzione che voglio farti subito, perché la confusione su questo punto rovina metà delle conversazioni sull’AI: un LLM non è un chatbot. L’LLM è il modello, ovvero la rete neurale con i suoi pesi fissi. Il chatbot è l’applicazione che lo avvolge: interfaccia utente, gestione della conversazione, filtri di sicurezza, eventuale collegamento a strumenti esterni come ricerca web o esecuzione di codice. ChatGPT è il chatbot; GPT-4o è il modello. Claude è il chatbot di Anthropic; Claude Sonnet 4.6 è uno dei modelli che lo alimentano. Tienilo a mente, perché quando parleremo di RAG, grounding e agenti questa distinzione farà tutta la differenza.

Un’altra cosa che ti farà piacere sapere: il legame con la tradizione dell’information retrieval è molto più profondo di quanto sembri. I primi modelli statistici del linguaggio, dagli n-gram degli anni ’80 al modello neurale di Bengio del 2003, risolvevano già lo stesso problema esatto: stimare la probabilità di una parola dato il contesto precedente. Gli LLM moderni sono gli eredi diretti di quella linea di ricerca. Le differenze fondamentali sono due: il meccanismo di attention, che permette di modellare dipendenze a lungo raggio che gli n-gram non potevano nemmeno sognarsi, e la scala, che trasforma un modello statistico in qualcosa che a tratti sembra davvero ragionare.

Token, parametri, pesi: il vocabolario minimo

Prima di andare avanti ti servono tre definizioni, e ci tengo che siano chiare.

• Un token è l’unità minima che il modello elabora. Non è una parola, non è un carattere: è qualcosa a metà. La parola “intelligenza” potrebbe essere un singolo token oppure spezzata in “intel” + “ligenza” a seconda del tokenizer che il modello usa.
• Un parametro è un numero in virgola mobile che rappresenta un peso della rete neurale: GPT-3 ne ha 175 miliardi, Llama 3.1 nella versione più grande ne ha 405 miliardi.
• I pesi sono i parametri addestrati: durante il training vengono continuamente aggiornati per minimizzare l’errore di predizione, poi, una volta finito il training, vengono “congelati” e rimangono fissi mentre tu usi il modello. Ogni volta che parli con ChatGPT, i pesi del modello non cambiano di una virgola.

Approfondimento tecnico — Il language modeling come probabilità condizionale

Formalmente, un modello di linguaggio stima la probabilità di una sequenza di token fattorizzandola come prodotto di probabilità condizionali, secondo la regola della catena della probabilità. L’obiettivo del training è massimizzare la log-verosimiglianza dei dati osservati, il che equivale a minimizzare la cross-entropy tra la distribuzione predetta dal modello e la distribuzione reale dei token nel dataset.

P(w_1, w_2, ..., w_T) = prod_{t=1}^{T} P(w_t | w_1, w_2, ..., w_{t-1})
Loss = - sum_{t=1}^{T} log P(w_t | w_1, ..., w_{t-1}; theta)

Dove theta è l’insieme di tutti i parametri del modello. In inferenza, a ogni passo il modello calcola la distribuzione P(w_t | contesto), applica un softmax sull’intero vocabolario per trasformarla in probabilità normalizzate, e poi campiona o seleziona il token successivo. Parametri come temperature, top-k e top-p — quelli che ti ritrovi nelle API di OpenAI o Anthropic — servono proprio a controllare quanto quel campionamento sia deterministico (risposte sempre uguali) o creativo (risposte diverse ogni volta).

---

Prima del 2017: RNN, LSTM e il muro della sequenzialità

Per capire davvero perché il Transformer è stata una rivoluzione devi ricordare com’era il natural language processing prima del giugno 2017. Per oltre vent’anni il paradigma dominante nei modelli neurali del linguaggio era stato quello delle reti ricorrenti: architetture che processano la frase un token alla volta, mantenendo uno stato interno che si aggiorna a ogni passo. Concettualmente elegante, praticamente limitata da due problemi strutturali che nessuna ottimizzazione riusciva a risolvere davvero. Te li racconto entrambi perché capendo cosa bloccava il campo, capirai perché l’idea di Vaswani e colleghi è sembrata un fulmine.

Il primo problema era la sequenzialità obbligata. Una rete ricorrente deve per forza calcolare lo stato al tempo t prima di poter calcolare quello al tempo t+1. Non c’è verso di saltarlo: il secondo passo dipende aritmeticamente dal primo. Questo significava che addestrare un modello su una frase di 100 token richiedeva 100 passi seriali, impossibili da parallelizzare sulla GPU e non poter sfruttare il parallelismo era un collo di bottiglia intollerabile. Stavi lasciando sul tavolo il 90% della potenza della tua macchina.

Il secondo problema era il vanishing gradient, e qui la cosa diventa seria. Durante il training con backpropagation through time, il gradiente dell’errore deve tornare indietro attraverso tutti i passi temporali. A ogni moltiplicazione, se i valori sono minori di uno, il gradiente si rimpicciolisce esponenzialmente. Dopo venti o trenta passi è già numericamente indistinguibile da zero. Risultato pratico: il modello imparava benissimo le dipendenze a breve raggio — l’accordo tra soggetto e verbo adiacente, ad esempio — ma sudava come un dannato con le dipendenze a lungo raggio, tipo collegare il pronome “quello” al sostantivo menzionato venti parole prima nella frase. Se hai mai provato Google Translate nel 2015, ti ricorderai certamente che le traduzioni lunghe perdevano il filo.

Word embeddings: word2vec e GloVe, la prima rivoluzione semantica

Nel 2013 Tomáš Mikolov e colleghi di Google pubblicano word2vec, un metodo per imparare rappresentazioni vettoriali dense delle parole. L’idea è tanto semplice quanto geniale: prendi una piccola rete neurale, addestrala a predire una parola dato il suo contesto (architettura CBOW) oppure il contesto data una parola (skip-gram), e poi usa i pesi della rete come vettori delle parole. Il risultato è quasi miracoloso: parole semanticamente simili finiscono vicine nello spazio vettoriale, al punto che operazioni aritmetiche come king - man + woman ≈ queen producono risultati sensati. La prima volta che l’ho visto funzionare ho pensato che fosse un trucco. Non lo era.

L’anno dopo, nel 2014, Stanford risponde con GloVe, che usa un approccio matriciale basato su statistiche di co-occorrenza globali invece che sul training predittivo locale. Entrambi i metodi però producono embedding statici: ogni parola ha un unico vettore, indipendentemente dal contesto in cui appare. Ed è qui che emerge il loro limite strutturale. La parola “mouse” ha lo stesso identico vettore sia quando parli di hardware sia quando parli di roditori. Non c’è modo di distinguere. Risolvere questa ambiguità contestuale — assegnare un vettore diverso alla stessa parola a seconda di cosa ci sta intorno — sarà uno dei meriti principali dei Transformer. Ma ci arriviamo tra poco.

Seq2seq e i primi meccanismi di attention

Sempre nel 2014, Sutskever, Vinyals e Le di Google pubblicano il paper seminale su sequence-to-sequence learning: un’architettura encoder-decoder basata su LSTM che mappa una sequenza di input in una sequenza di output, applicabile alla traduzione automatica, al riassunto, alla risposta a domande. Il design è pulito: l’encoder comprime l’intera frase sorgente in un singolo vettore di contesto di dimensione fissa; il decoder parte da quel vettore e genera la frase target un token alla volta. Funziona, intendiamoci. Ma il vincolo del vettore di contesto unico è brutale: comprimere una frase di cinquanta parole in 512 numeri significa inevitabilmente buttare via informazione. E più lunga è la frase, più buchi fa il modello.

Nello stesso 2014 Bahdanau, Cho e Bengio propongono una soluzione elegantissima al problema: il meccanismo di attention. Invece di forzare l’encoder a comprimere tutto in un singolo vettore, permettono al decoder di “guardare indietro” a tutti gli stati dell’encoder, a ogni passo di generazione, assegnando pesi di attenzione dinamici. In pratica il decoder impara da solo quali parti della frase sorgente sono rilevanti per predire il prossimo token target. Nel 2015 Luong et al. raffinano l’idea con varianti più efficienti. Ma attenzione a una cosa importante: nel 2014 l’attention nasce come aggiunta alle architetture ricorrenti, come una pezza per risolvere il collo di bottiglia del vettore unico. Nessuno, neanche Bahdanau stesso, immagina ancora che quella pezza possa bastare da sola, senza RNN, senza convoluzioni, senza niente altro. Quell’intuizione arriverà tre anni dopo, e cambierà tutto.

Approfondimento tecnico — Dentro una cella LSTM

Una cella LSTM, introdotta da Hochreiter e Schmidhuber nel 1997, mitiga il vanishing gradient attraverso un sistema di “gate” — porte — che controllano il flusso di informazione. Il cell state c_t è la “memoria a lungo termine” che può attraversare molti passi senza degradarsi troppo, perché la sua evoluzione è una combinazione additiva controllata dai gate, non una moltiplicazione come negli RNN vanilla. Lo pseudo-codice di un passo forward è concettualmente il seguente:

# Input: x_t (token corrente), h_{t-1} (hidden precedente), c_{t-1} (cell state)
f_t = sigmoid(W_f @ [h_{t-1}, x_t] + b_f)   # forget gate: cosa dimentico?
i_t = sigmoid(W_i @ [h_{t-1}, x_t] + b_i)   # input gate: cosa scrivo di nuovo?
o_t = sigmoid(W_o @ [h_{t-1}, x_t] + b_o)   # output gate: cosa lascio uscire?
g_t = tanh(W_g @ [h_{t-1}, x_t] + b_g)      # candidate cell: il contenuto candidato

c_t = f_t * c_{t-1} + i_t * g_t             # nuovo cell state
h_t = o_t * tanh(c_t)                       # nuovo hidden state

Funziona decisamente meglio degli RNN vanilla, e per oltre quindici anni è stato lo stato dell’arte. Ma il problema della sequenzialità rimane intatto: ogni passo dipende dal precedente, e la parallelizzazione resta impossibile. È questo il muro architetturale che il Transformer supererà nel 2017.

---

2017: Attention is all you need, il paper che ha cambiato tutto

12 giugno 2017. Otto ricercatori di Google Brain insieme a colleghi di Google Research e dell’Università di Toronto caricano su arXiv un paper con un titolo provocatorio come pochi: Attention is All You Need. Gli autori — Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, Illia Polosukhin — propongono una cosa che suona quasi eretica: buttare via completamente ricorrenza e convoluzioni, tenendo solo il meccanismo di attention. L’architettura che ne esce si chiama Transformer.

Ti rendi conto di quanto fosse radicale la tesi? Andava contro vent’anni di saggezza convenzionale. Le reti ricorrenti erano considerate la scelta naturale per il testo, le CNN una valida alternativa per la parallelizzazione. Dire che nessuna delle due serve, che basta un meccanismo concepito tre anni prima come semplice patch per le seq2seq, sembrava quasi una provocazione da conferenza. I risultati sperimentali però hanno zittito i dubbi nel giro di poche settimane: sul task di traduzione WMT 2014 inglese-tedesco il Transformer raggiunge 28.4 BLEU, superando lo stato dell’arte precedente di oltre due punti. Sul task inglese-francese arriva a 41.8 BLEU. E lo fa addestrandosi in una frazione del tempo richiesto dalle architetture concorrenti, grazie al parallelismo totale che l’architettura permette.

We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train.

Vaswani et al., Attention is All You Need, 2017

A otto anni di distanza, il paper ha superato le 150.000 citazioni su Google Scholar, diventando uno dei lavori più influenti nella storia del machine learning. Ogni LLM moderno — GPT, BERT, T5, Llama, Claude, Gemini, DeepSeek, Mistral — è un discendente diretto di quella architettura. Alcuni dei coautori hanno fondato aziende che oggi valgono miliardi: Noam Shazeer ha creato Character.AI (poi tornato in Google), Aidan Gomez ha co-fondato Cohere, Illia Polosukhin ha lanciato NEAR Protocol. Il paper originale è disponibile su arXiv con l’identificativo 1706.03762 ed è ancora oggi una lettura accessibile: se puoi, prenditi mezz’ora e leggilo almeno una volta nella vita. Te lo dico davvero: vale la pena.

Ma cosa porta davvero di nuovo il Transformer? Tre cose, e te le elenco perché sono il cuore di tutto quello che viene dopo.

1. La self-attention, un meccanismo che permette a ogni token della sequenza di “guardare” simultaneamente tutti gli altri token, calcolando relazioni dirette senza dover attraversare passi ricorrenti. Zero sequenzialità, zero vanishing gradient.
2. La parallelizzazione totale del training, perché tutte le operazioni su una sequenza possono essere calcolate in parallelo come prodotti matriciali, sfruttando appieno le GPU e, in seguito, le TPU. Finalmente quella potenza che stava ferma sul tavolo viene utilizzata.
3. Una scalabilità prevedibile, perché l’architettura modulare — blocchi identici impilati uno sopra l’altro — rende banale aumentare il numero di layer, la dimensione dei vettori e il numero di teste di attenzione senza dover ridisegnare niente. Questi tre ingredienti, presi insieme, hanno reso possibile tutto quello che è venuto dopo: da BERT e GPT del 2018 ai sistemi multimodali con trilioni di parametri del 2026. Nella prossima sezione apriamo il motore e guardiamo ogni componente da vicino, strato per strato.

---

Anatomia del Transformer, strato per strato

Ora apriamo il motore e guardiamo dentro l’architettura del Transformer, seguendo esattamente il percorso che un token fa dal momento in cui entra nel modello al momento in cui diventa una probabilità di output. Questa è la sezione più densa della guida, quindi prenditi il tempo che ti serve. I concetti non sono difficili in sé, ma sono tanti e si incastrano tra loro come ingranaggi.

Tokenizer: da testo a numeri

Il primo passo, prima ancora che il Transformer veda il tuo testo, è la tokenizzazione. Il computer non capisce le parole, capisce i numeri. Serve quindi un pezzo di software che prenda una stringa e la spezzi in unità discrete, ciascuna associata a un ID numerico nel vocabolario del modello. I tokenizer moderni usano algoritmi subword come Byte Pair Encoding (BPE, introdotto da Sennrich et al. 2016), WordPiece (usato da BERT) e SentencePiece (usato da T5 e Llama). OpenAI usa una variante di BPE chiamata tiktoken per i suoi modelli GPT.

Perché subword e non parole intere? Semplice: un vocabolario di parole intere dovrebbe contenere milioni di voci per coprire tutte le lingue, e comunque mancherebbe sempre qualcosa (nomi propri, neologismi, refusi). Un vocabolario subword tipico contiene 30.000-100.000 token e può rappresentare qualsiasi stringa spezzandola in pezzi familiari. La parola “intelligenza” diventa magari “intel” + “ligenza”, “tokenizzazione” diventa “token” + “izza” + “zione”. Un carattere raro come “🦄” viene rappresentato come sequenza di byte. Niente è fuori dal vocabolario, e questo è fondamentale per la robustezza del sistema. Il tema della tokenizzazione è molto più rilevante di quanto sembri anche dal lato contenuti: è il motivo per cui il content chunking nei sistemi RAG è un’arte, non una scienza esatta.

Embedding layer: trasformare token in vettori densi

Una volta che il testo è una sequenza di ID interi (tipo [1523, 891, 45, 7821, ...]), serve il passaggio successivo: trasformare ogni ID in un vettore denso di numeri reali. Questo compito spetta all’embedding layer, che è semplicemente una matrice di dimensione (V, d_model) dove V è la dimensione del vocabolario e d_model è la dimensione dei vettori (512 nel Transformer originale, 4096 o più nei modelli moderni). Prendere l’embedding di un token significa fare una lookup: vai alla riga corrispondente all’ID del token, ed estrai il vettore.

Questi vettori non sono fissi come quelli di word2vec: vengono addestrati insieme al resto del modello, e si evolvono durante il training fino a catturare sfumature semantiche fini. Alla fine del training, parole semanticamente correlate si trovano in regioni vicine dello spazio a 4096 dimensioni, ma con una differenza cruciale rispetto a word2vec: i vettori dell’embedding layer sono solo il punto di partenza. Saranno poi trasformati dai layer successivi in rappresentazioni contestuali che tengono conto del contesto in cui la parola appare. Lo stesso token “banca” riceverà un vettore finale diverso a seconda che il contesto parli di finanza o di fiumi. Questo è il superamento definitivo del limite degli embedding statici.

Positional encoding: dare un senso dell’ordine

Qui c’è un problema concettuale che devi cogliere bene, perché è elegante e rivelatore. Il meccanismo di self-attention tratta la sequenza di token come un insieme non ordinato, non come una sequenza. Se non intervenissi in qualche modo, il Transformer vedrebbe “Marco ama Giulia” e “Giulia ama Marco” come frasi identiche, perché ha gli stessi token. Evidentemente non va bene. Serve un modo per iniettare l’informazione di posizione dentro i vettori di input.

La soluzione proposta nel paper originale è bellissima: si genera un positional encoding, ovvero un vettore della stessa dimensione dell’embedding, che dipende solo dalla posizione del token nella sequenza, e lo si somma all’embedding prima di entrare nel primo layer Transformer. Il positional encoding originale usa funzioni sinusoidali a frequenze diverse, così il modello può imparare a riconoscere pattern di posizione relativa (tipo “questo token viene tre posizioni dopo quell’altro”). I modelli moderni usano varianti più sofisticate come rotary position embedding (RoPE, Su et al. 2021) e ALiBi (Press et al. 2021), ma il principio di base resta lo stesso: l’informazione di posizione va iniettata, altrimenti il modello è semanticamente cieco all’ordine.

Approfondimento tecnico — La formula sinusoidale del positional encoding

Nel paper originale, il positional encoding PE per la posizione pos e la dimensione i è definito usando seni e coseni a frequenze geometricamente decrescenti. L’intuizione è che ogni dimensione del vettore oscilla a una frequenza diversa, creando una “firma” unica per ogni posizione che il modello può leggere.

PE(pos, 2i)   = sin(pos / 10000^(2i / d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i / d_model))

# dove:
# pos     = posizione del token nella sequenza (0, 1, 2, ...)
# i       = indice della dimensione nell'embedding (0, 1, ..., d_model/2 - 1)
# d_model = dimensione dell'embedding (512 nel paper originale)

La proprietà matematica interessante è che PE(pos + k) può essere espresso come una trasformazione lineare di PE(pos), il che facilita al modello l’apprendimento delle posizioni relative. È un trucco elegante: usa le proprietà trigonometriche per codificare l’ordine in un modo che sia sia differenziabile (per il training) sia semanticamente utile.

Self-attention: il cuore del Transformer (Q, K, V)

Arriviamo al pezzo centrale, quello che dà il nome al paper. Il meccanismo di self-attention permette a ogni token di “guardare” tutti gli altri token della sequenza e decidere quanto pesare ciascuno nel costruire la propria nuova rappresentazione. Ti faccio un’analogia concreta: immagina di leggere la frase “Il cane ha rincorso il gatto finché esso non è scappato sull’albero”. A chi si riferisce “esso”? A “gatto”, ovviamente — lo capisci dal contesto. Per risolvere questo pronome, il tuo cervello “presta attenzione” selettivamente alle parole giuste. Il Transformer fa esattamente la stessa cosa, ma in modo algoritmico e parallelo su tutta la frase contemporaneamente.

Il meccanismo è basato su tre vettori per ogni token: Query (Q), Key (K) e Value (V). Li ottieni moltiplicando l’embedding del token per tre matrici di pesi addestrate (W_Q, W_K, W_V). Poi, per ogni coppia di token, calcoli un punteggio di attenzione come prodotto scalare tra la Query di uno e la Key dell’altro: questo punteggio rappresenta “quanto il token i è rilevante per il token j“. I punteggi vengono normalizzati con un softmax per diventare pesi che sommano a 1, e infine si usano questi pesi per fare una media pesata dei vettori Value. Il risultato è la nuova rappresentazione del token, che ora “sa” quali altri token della frase sono rilevanti per il suo significato contestuale.

Approfondimento tecnico — Scaled dot-product attention

La formula del meccanismo di attention, nella sua forma “scaled dot-product” così come appare nel paper originale, è sorprendentemente compatta. Tre matrici di input (Q, K, V), un softmax, un fattore di scala, una moltiplicazione finale. Ecco come si scrive matematicamente:

Attention(Q, K, V) = softmax(Q @ K^T / sqrt(d_k)) @ V

# dimensioni tensori (Transformer base, Vaswani 2017):
# Q: (seq_len, d_k)   con d_k = 64
# K: (seq_len, d_k)   con d_k = 64
# V: (seq_len, d_v)   con d_v = 64
# d_model = 512, numero teste h = 8, d_k = d_v = d_model/h = 64

# il fattore sqrt(d_k) serve a stabilizzare i gradienti:
# senza di esso, i prodotti scalari crescerebbero in magnitudine
# man mano che d_k aumenta, spingendo il softmax in regioni
# di gradiente quasi nullo (saturazione)

La complessità computazionale è O(n² · d) dove n è la lunghezza della sequenza e d la dimensione dei vettori. Il termine quadratico in n è il motivo per cui processare contesti lunghi è costoso: raddoppiare la lunghezza del contesto quadruplica il compute necessario. È anche il motivo per cui tecniche come Flash Attention (Dao et al. 2022) e le varianti di attention sparsa sono diventate così importanti nel 2023-2026.

Multi-head attention: guardare la frase da più angolazioni

Un singolo meccanismo di attention cattura un tipo specifico di relazione tra i token. Ma in una frase ci sono molte relazioni diverse che si sovrappongono: sintattiche (chi è il soggetto?), semantiche (qual è il tema?), di coreferenza (a cosa si riferisce questo pronome?), di polarità (questa parola è positiva o negativa nel contesto?). Costringere un solo meccanismo di attention a catturarle tutte insieme è chiedergli troppo. La soluzione del paper è la multi-head attention: invece di un solo meccanismo di attention, ne esegui h in parallelo (8 nel Transformer base), ciascuno con proprie matrici W_Q, W_K, W_V addestrate indipendentemente. Ogni “testa” può specializzarsi in un tipo diverso di relazione. I risultati delle teste vengono poi concatenati e proiettati nuovamente nella dimensione d_model.

L’effetto pratico è come avere otto analisti che leggono la stessa frase contemporaneamente, ciascuno con il proprio focus. Uno guarda la struttura sintattica, un altro cerca coreferenze, un altro ancora valuta la semantica globale. Alla fine mettono insieme i risultati e ne tirano fuori una rappresentazione molto più ricca di quanto un singolo analista potrebbe produrre da solo. Analisi empiriche sui Transformer addestrati confermano che effettivamente teste diverse tendono a specializzarsi in pattern diversi, anche se l’interpretabilità fine di quello che ogni testa “vede” resta un problema di ricerca aperto.

Feed-forward, layer normalization e connessioni residue

Un blocco Transformer completo non è fatto solo di attention. Dopo il sotto-layer di multi-head attention, c’è un secondo sotto-layer chiamato feed-forward network (FFN): una piccola rete completamente connessa a due strati, applicata indipendentemente a ogni posizione. Nel Transformer originale, l’FFN espande il vettore da 512 a 2048 dimensioni, applica una non-linearità (originariamente ReLU, oggi più spesso GeLU, SwiGLU o altre varianti), e poi proietta di nuovo a 512. Questa espansione intermedia è dove avviene buona parte della “computazione” del modello: si stima che circa i due terzi dei parametri di un LLM moderno siano nei feed-forward, non nell’attention.

Intorno a ogni sotto-layer (sia attention che FFN) ci sono due meccanismi fondamentali per la stabilità del training: le connessioni residue (residual connections, introdotte da He et al. 2016 con ResNet) che sommano l’input del sotto-layer al suo output, creando “autostrade” per il gradiente durante la backpropagation; e la layer normalization (Ba et al. 2016) che normalizza le attivazioni per stabilizzare la distribuzione dei valori durante il training. Senza questi due ingredienti, addestrare reti profonde a 12, 24, 96 o più layer sarebbe praticamente impossibile. Nel Transformer originale la LayerNorm era post-norm (dopo il sotto-layer e la somma residua); nei modelli moderni è quasi sempre pre-norm (prima del sotto-layer), perché risulta più stabile ad altezze estreme di layer.

Approfondimento tecnico — Forward pass di un blocco Transformer

Mettendo insieme tutti i pezzi, il forward pass di un singolo blocco Transformer (stile pre-norm, quello usato dai modelli moderni) si può scrivere in pochissime righe di pseudo-codice. Questo è il cuore pulsante di GPT, Claude, Llama, Gemini e di ogni altro LLM che stai usando oggi.

# x ha shape (batch_size, seq_len, d_model)

def transformer_block(x):
    # sotto-layer 1: multi-head self-attention con residuo
    h = layer_norm(x)
    h = multi_head_attention(h, h, h)  # Q=K=V=h (self-attention)
    x = x + h                           # residual connection

    # sotto-layer 2: feed-forward con residuo
    h = layer_norm(x)
    h = linear_2(activation(linear_1(h)))  # FFN: d_model -> 4*d_model -> d_model
    x = x + h                               # residual connection

    return x

# un LLM moderno impila N di questi blocchi in sequenza:
# GPT-3: 96 blocchi
# Llama 3.1 405B: 126 blocchi
# ogni blocco raffina la rappresentazione un po' di piu

Ed è tutto qui. Non c’è nient’altro di nascosto. Un LLM è una pila di blocchi identici come questo, ciascuno con i propri pesi, con in cima un layer finale (detto “language modeling head”) che proietta l’ultima rappresentazione nello spazio del vocabolario per produrre le probabilità dei token successivi. Quando vedi numeri tipo “405 miliardi di parametri”, quasi tutti quei parametri vivono dentro le matrici W_Q, W_K, W_V dell’attention e le due matrici lineari del feed-forward di ciascun blocco, moltiplicate per il numero di layer.

---

Encoder, decoder o entrambi: BERT, GPT, T5

Il Transformer originale del 2017 era un’architettura encoder-decoder: progettato per la traduzione automatica, aveva un encoder che leggeva la frase in inglese e un decoder che generava la frase in tedesco. Ma la comunità si è rapidamente resa conto che i due pezzi — encoder e decoder — possono vivere benissimo da soli, e servono per cose diverse. Nel giro di un anno dal paper originale sono emerse tre famiglie architetturali distinte, ognuna ottimizzata per compiti diversi. Capire le differenze è fondamentale per orientarsi nel panorama dei modelli moderni.

BERT (encoder-only): comprensione bidirezionale

Nel 2018 Devlin et al. di Google pubblicano BERT (Bidirectional Encoder Representations from Transformers). L’idea è prendere solo la parte encoder del Transformer e addestrarla su un obiettivo nuovo chiamato masked language modeling: nascondi il 15% dei token in una frase con un token speciale [MASK] e chiedi al modello di indovinare quelli mancanti usando il contesto sia a sinistra sia a destra. Questa bidirezionalità è il suo punto di forza: ogni rappresentazione contestualizzata “vede” tutta la frase, non solo il passato. Risultato: BERT è formidabile per task di comprensione — classificazione, named entity recognition, question answering estrattiva, similarità semantica — dove ti serve capire il significato di un testo già completo. Non è progettato per generare testo fluido, e infatti non viene usato per quello.

GPT (decoder-only): generazione autoregressiva

Nello stesso 2018 OpenAI pubblica GPT-1 (Generative Pre-trained Transformer), che prende la strada opposta: solo la parte decoder del Transformer, addestrata in modo autoregressivo a predire il prossimo token dato tutto il contesto precedente. Il decoder usa la cosiddetta masked self-attention: ogni token può guardare solo ai token precedenti, mai a quelli successivi. Questo lo rende perfetto per la generazione di testo, perché al momento dell’inferenza generi davvero un token alla volta e non puoi vedere il futuro. GPT-2 (2019, 1.5B parametri), GPT-3 (2020, 175B parametri), GPT-4 (2023) e GPT-4o (2024) sono tutti discendenti diretti di questa architettura decoder-only. Nel 2026 la maggior parte dei modelli di frontiera — Claude, Llama, Gemini, Mistral, DeepSeek — è decoder-only, perché è l’architettura che scala meglio e che dimostra le capacità emergenti più interessanti alle dimensioni estreme.

T5 e BART (encoder-decoder): il paradigma text-to-text

La terza famiglia mantiene l’architettura originale encoder-decoder, ma la reinquadra in un paradigma unificato: ogni task NLP viene riformulato come “prendi del testo, produci del testo”. Nel 2019 Google pubblica T5 (Text-to-Text Transfer Transformer) e Facebook AI pubblica BART, che esplorano entrambi questa strada. Per fare classificazione non produci una label, produci direttamente la stringa della classe. Per fare traduzione metti davanti all’input un prefisso tipo translate English to German:. Il modello impara un vocabolario unificato di task, e lo stesso insieme di pesi può fare centinaia di cose diverse. Oggi l’architettura encoder-decoder è meno popolare nei modelli di frontiera generalisti, ma resta fortissima in task specifici come traduzione automatica e riassunto, dove il vincolo strutturale input → output è esplicito e utile.

Famiglia	Anno	Addestramento	Task tipici	Esempi
Encoder-only	2018	Masked LM (MLM)	Classificazione, NER, QA estrattiva, similarità	BERT, RoBERTa, DeBERTa
Decoder-only	2018	Next-token prediction	Generazione, chat, reasoning, code	GPT-4o, Claude, Llama, Gemini, DeepSeek
Encoder-decoder	2017/2019	Span corruption / seq2seq	Traduzione, riassunto, summarization	T5, BART, mT5, FLAN-T5

---

Come si addestra un LLM: pretraining, fine-tuning, RLHF, DPO

Abbiamo visto l’architettura. Ma un Transformer appena inizializzato con pesi casuali non sa fare niente: produce rumore. Come si passa dal rumore a ChatGPT? Attraverso un processo di addestramento in più fasi, ciascuna con obiettivi diversi, che trasformano progressivamente il modello da predittore statistico grezzo a assistente conversazionale utile e allineato. Te lo racconto fase per fase, perché ognuna di queste tappe ha implicazioni pratiche che dovresti conoscere.

Pretraining: trilioni di token e next-token prediction

La prima fase è il pretraining, ed è dove il modello impara il linguaggio in sé — grammatica, sintassi, fatti del mondo, stili di scrittura, logica di base. Il compito è semplice in teoria: dato un enorme corpus di testo (trilioni di token raschiati dal web, libri, codice, Wikipedia, paper scientifici, forum, conversazioni), il modello viene addestrato a predire il token successivo data la sequenza precedente. Si fa scorrere ogni sequenza attraverso il modello, si calcola la loss cross-entropy tra distribuzione predetta e token reale, e si aggiornano i pesi con backpropagation e ottimizzatori come Adam o AdamW. Ripeti per settimane o mesi su migliaia di GPU in parallelo. Alla fine hai un modello che ha “digerito” una quantità di testo equivalente a migliaia di vite umane di lettura.

Qui i numeri diventano vertiginosi. GPT-3 è stato addestrato su circa 300 miliardi di token. GPT-4, secondo le stime pubbliche, su diversi trilioni. Llama 3.1 su 15 trilioni di token. I costi stimati del training di un modello di frontiera nel 2025 oscillano tra 50 e 500 milioni di dollari in sole spese di compute e energia, senza contare stipendi dei ricercatori e infrastruttura. È per questo che solo poche organizzazioni al mondo possono permettersi di addestrare un LLM da zero. Il risultato del pretraining è un base model (o foundation model): potente ma “crudo”, non sa rispondere educatamente a domande, tende a continuare il testo piuttosto che conversare, può produrre contenuto inappropriato. Serve una seconda fase.

Supervised fine-tuning (SFT)

La seconda fase è il supervised fine-tuning, dove il modello impara a seguire istruzioni. Si parte dal base model e lo si addestra ulteriormente, con lo stesso obiettivo di next-token prediction, ma su un dataset molto più piccolo (decine o centinaia di migliaia di esempi) composto da coppie istruzione → risposta ideale scritte da annotatori umani esperti. Il dataset insegna al modello il formato di una conversazione: l’utente pone una domanda, l’assistente risponde in modo utile, strutturato, educato. Il modello di base conosce già la lingua; la SFT gli insegna come comportarsi. Al termine della SFT hai un instruction-tuned model, utilizzabile come assistente — ma ancora con molti problemi sottili: può essere troppo verboso o troppo sbrigativo, può fare il moralista dove non serve, può allucinare con disinvoltura. Serve ancora altro allineamento.

Reinforcement Learning from Human Feedback (RLHF)

La terza fase, introdotta da OpenAI con il paper InstructGPT (Ouyang et al. 2022), è il Reinforcement Learning from Human Feedback. L’idea è geniale e articolata: invece di scrivere risposte ideali (costoso), chiedi agli annotatori umani di confrontare coppie di risposte generate dal modello e dire quale preferiscono. Con questi dati di preferenza, addestri un secondo modello — il reward model — che prende una risposta e la valuta numericamente. Poi, con un algoritmo di reinforcement learning chiamato PPO (Proximal Policy Optimization), addestri il modello principale a massimizzare il reward, usando le valutazioni del reward model come segnale. Il risultato è un modello molto meglio allineato alle preferenze umane: più utile, più onesto, meno incline a produrre contenuto problematico. RLHF è il trucco che ha trasformato GPT-3 in ChatGPT nel novembre 2022, ed è quello che ha fatto esplodere il mercato consumer dell’AI.

Direct Preference Optimization (DPO): la semplificazione del 2023

RLHF funziona ma è complicato da implementare: devi addestrare due modelli (reward + policy), gestire la stabilità del reinforcement learning (noto per essere instabile), bilanciare l’esplorazione. Nel 2023 Rafailov et al. pubblicano Direct Preference Optimization (DPO), che semplifica drasticamente il processo: dimostrano matematicamente che puoi ottenere un risultato equivalente a RLHF saltando completamente il reward model e il PPO, usando una singola loss supervisionata direttamente sui dati di preferenza. In pratica: la stessa qualità di RLHF, un decimo della complessità implementativa. Nel 2024-2026 molti modelli open source (e probabilmente diversi modelli closed-source) usano DPO o varianti come IPO, KTO, SimPO. Se stai lavorando nella data science applicata, DPO è uno degli strumenti più importanti da conoscere, perché rende l’alignment accessibile anche a team senza infrastrutture di RL.

Approfondimento tecnico — Cross-entropy loss e gradiente

Durante il pretraining e il SFT, la funzione di loss usata è la cross-entropy tra la distribuzione di probabilità predetta dal modello e la distribuzione reale (che è un vettore one-hot, con 1 sul token giusto e 0 altrove). Minimizzare la cross-entropy equivale a massimizzare la log-verosimiglianza del token corretto.

# Per un singolo token di target y e logits z del modello:
p = softmax(z)              # distribuzione predetta sul vocabolario
loss = -log(p[y])           # cross-entropy = -log della probabilita' del token giusto

# Gradiente rispetto ai logits (questa e' la parte bella):
d_loss / d_z = p - onehot(y)

# Significato: spingi verso l'alto la probabilita' del token giusto,
# spingi verso il basso quella di tutti gli altri, in proporzione
# alla loro probabilita' attuale. Semplice, stabile, efficace.

La perplexity, una metrica comune per valutare i modelli di linguaggio, è semplicemente exp(loss): rappresenta intuitivamente “quante scelte equivalenti stava considerando il modello” quando ha fatto la predizione. Una perplexity di 20 significa che il modello era incerto come se stesse scegliendo uniformemente tra 20 token. Più bassa è la perplexity, più il modello è sicuro delle sue predizioni sul test set.

---

Scaling laws: perché più grande significa più intelligente

C’è una cosa che ha sconvolto la comunità del ML nel 2020, e che probabilmente spiega l’intero arco che ci ha portati da GPT-2 a GPT-4o. Si chiamano scaling laws, leggi di scala, e dicono una cosa apparentemente banale ma rivelatrice: la performance di un LLM, misurata come loss sul test set, diminuisce in modo prevedibile secondo una legge di potenza in funzione di tre variabili — numero di parametri N, numero di token di training D, quantità di compute C. Non migliora “a volte” o “dipende dal caso”. Migliora in modo sistematico, prevedibile, matematico. Se raddoppi i parametri e raddoppi i dati, sai in anticipo di quanto calerà la loss. Questa scoperta, pubblicata da Kaplan et al. di OpenAI nel 2020, ha cambiato il gioco: improvvisamente scalare non è più una scommessa, è una strategia razionale con ROI calcolabile. E così sono partiti gli investimenti da miliardi.

Nel 2022 DeepMind ha rivisto il quadro con il paper Chinchilla (Hoffmann et al.), che ha corretto un errore importante nelle leggi di Kaplan. Kaplan diceva in sostanza: dato un budget di compute, conviene fare modelli molto grandi con relativamente pochi dati. Chinchilla ha dimostrato che era sbagliato: dato un budget di compute, la scelta ottimale è bilanciare i parametri e i dati in modo più uguale di quanto si pensasse. La regola empirica di Chinchilla — circa 20 token di training per parametro del modello — ha ribaltato il trend. Dopo Chinchilla, la nuova generazione di modelli (Llama 2, Llama 3, Mistral, Qwen) è diventata “più piccola e addestrata su più dati” invece di “più grande e affamata di dati”. Llama 3 8B con 15 trilioni di token di training batte Llama 2 13B con meno token: meno parametri ma più dati vince al pareggio di compute.

Approfondimento tecnico — La formula delle scaling laws

La forma funzionale delle scaling laws di Chinchilla è una legge di potenza additiva in N e D, con un termine irriducibile E che rappresenta l’entropia intrinseca del linguaggio. I coefficienti sono stimati empiricamente addestrando centinaia di modelli a dimensioni diverse.

L(N, D) = E + A / N^alpha + B / D^beta

# valori empirici stimati da Hoffmann et al. 2022:
# E     = 1.69   (entropia irriducibile del linguaggio naturale)
# A     = 406.4
# B     = 410.7
# alpha = 0.34
# beta  = 0.28

# N = numero di parametri del modello
# D = numero di token di training
# L = loss (cross-entropy) sul test set

Ottimizzando L(N, D) sotto il vincolo di budget di compute C ≈ 6 · N · D (approssimazione standard per il compute di training di un Transformer), si ottiene la celebre regola “token ottimali ≈ 20 × parametri”. Nel 2023-2026 molti team hanno iniziato ad allenare “oltre Chinchilla”, usando molti più token del valore ottimale per ridurre i costi di inferenza futuri: un modello più piccolo ma sovra-addestrato costa meno a servire in produzione, e il costo aggiuntivo una tantum del training è ampiamente compensato dal risparmio sull’inferenza quotidiana.

Un caveat importante, perché il 2024-2026 ha portato segnali ambigui sul fronte dello scaling: diversi leak e dichiarazioni pubbliche di figure come Ilya Sutskever suggeriscono che il pretraining scaling puro potrebbe essere vicino a un plateau. I guadagni da “rendiamolo ancora più grande” si stanno assottigliando. Questo non significa affatto che gli LLM abbiano raggiunto il limite — significa che il prossimo asse di scaling si sta spostando altrove: al test-time compute, cioè quanto il modello “pensa” durante l’inferenza invece di quanto è grande. Ne parliamo tra poche sezioni con i reasoning models.

---

Context window, KV cache e i limiti del ricordare

Il context window è uno dei concetti più importanti da capire se vuoi usare bene gli LLM. È semplicemente la quantità massima di token che il modello può “vedere” in input in una singola chiamata — prompt, conversazione precedente, documenti allegati, tutto insieme. Quando lo superi, il testo più vecchio viene troncato. Il Transformer originale del 2017 aveva un context window di 512 token, GPT-2 ne aveva 1024, GPT-3 è salito a 2048 e poi 4096, GPT-4 è arrivato a 8k e poi 32k, Claude 2 ha lanciato i 100k nel 2023, Gemini 1.5 Pro nel 2024 ha spinto la barra a 1 milione (e in test fino a 10 milioni), Claude 3.5 Sonnet e oltre sono arrivati a 200k stabili con varianti a 1M. In meno di quattro anni siamo passati da “poche migliaia di parole” a “un’intera enciclopedia” entro un singolo prompt. Per superare il limite del context window servono canali di memoria esterni alla sessione: un esempio concreto è il sistema di memoria persistente di Claude Code, che combina file CLAUDE.md e auto-memory.

Perché il contesto lungo costa così tanto

Abbiamo già accennato al problema nella sezione sull’attention: il costo computazionale della self-attention è quadratico nella lunghezza della sequenza. Raddoppiare il contesto significa quadruplicare il lavoro di attention. Un prompt da 100k token richiede 100 volte più compute sull’attention di un prompt da 10k token — non 10 volte. Questo è il motivo per cui i context window giganti non sono “gratis”: anche quando i modelli li supportano, processarli è costoso sia in tempo sia in denaro. Nel 2026, leggere un intero libro in contesto con Claude o Gemini resta un’operazione che costa dollari, non centesimi. E questo spiega perché il content chunking e il RAG restano rilevanti anche con context window enormi: è spesso molto più economico recuperare i pezzi giusti di contesto on-demand che caricarli tutti ogni volta.

KV cache: il trucco per rendere veloce l’inferenza

C’è un’ottimizzazione fondamentale che ogni LLM moderno usa in inferenza, e si chiama KV cache. Durante la generazione autoregressiva, a ogni passo il modello deve calcolare nuovi Query, Key e Value per ogni token. Ma osserviamo una cosa: i Key e Value dei token già generati non cambiano tra un passo e l’altro. Sarebbe uno spreco ricalcolarli. Invece, il modello li mantiene in una cache in memoria GPU e riusa quelli vecchi, calcolando solo Q, K e V per il nuovo token. Questo trasforma il costo di generazione per token da quadratico a (approssimativamente) lineare nella lunghezza del contesto già visto. Senza KV cache, la generazione di 1000 token richiederebbe calcoli nell’ordine di un miliardo di operazioni extra; con KV cache, ne richiede una frazione. Il prezzo da pagare è la memoria: la cache KV cresce linearmente con la lunghezza del contesto, e per contesti molto lunghi può occupare decine o centinaia di GB di VRAM. È uno dei principali colli di bottiglia pratici dell’inferenza LLM a lunga distanza.

Approfondimento tecnico — Flash Attention e oltre

Il vero breakthrough pratico per il context window lungo è arrivato con Flash Attention (Dao et al. 2022) e la sua versione 2 (2023) e 3 (2024). Il trucco non tocca l’algoritmo matematico dell’attention — il risultato è identico bit-per-bit — ma riorganizza l’ordine delle operazioni per sfruttare meglio la gerarchia di memoria delle GPU (HBM, SRAM, registri). La complessità computazionale teorica resta O(n²·d), ma il wall-clock time e soprattutto la memoria effettiva diventano molto più gestibili. Flash Attention 2 e 3 riducono del 2-4x il tempo di training e inferenza a parità di hardware, e permettono context window che erano impensabili pochi anni prima. Se stai servendo LLM in produzione nel 2026, stai usando Flash Attention (o un suo fork tipo xFormers) anche senza saperlo.

Oltre a Flash Attention esistono varianti di attention sparsa (come Longformer, BigBird, ring attention) e architetture alternative come Mamba e i modelli state space, che promettono complessità lineare nella lunghezza della sequenza. Nel 2025 sono emersi i primi modelli ibridi Transformer + Mamba (Jamba, Zamba) che cercano il meglio dei due mondi. È uno dei filoni di ricerca più attivi e il 2026 probabilmente vedrà modelli di frontiera con architetture non puramente Transformer.

---

In-context learning, chain-of-thought e abilità emergenti

Qui entriamo in uno dei territori più affascinanti degli LLM, quello che ancora oggi nessuno ha spiegato del tutto. Quando GPT-3 è uscito nel 2020, ha mostrato una capacità sorprendente e non anticipata: il modello poteva imparare task nuovi semplicemente vedendone esempi nel prompt, senza alcun fine-tuning. Gli mostravi tre esempi di “traduci inglese → francese” direttamente nel testo di input, poi gli ponevi una quarta frase, e lui traduceva. Questo fenomeno si chiama in-context learning, ed è una delle capacità più sconcertanti degli LLM moderni. Nessuno l’aveva programmata esplicitamente, è emersa da sola dallo scaling.

Zero-shot, one-shot, few-shot

Il paper di GPT-3 (Brown et al. 2020, titolo geniale: Language Models are Few-Shot Learners) introduce una tassonomia che è ancora lo standard.

• Zero-shot: poni direttamente la domanda al modello senza esempi, e lui risponde.
• One-shot: prima di fare la domanda, gli dai un singolo esempio di input-output come demo.
• Few-shot: gli dai una manciata di esempi (tipicamente 3-10).

La performance cresce con il numero di esempi, ma la cosa davvero sorprendente è che il modello non aggiorna i suoi pesi — impara “al volo” solo leggendo il prompt. È come se l’architettura Transformer, addestrata su abbastanza testo, avesse sviluppato una meta-capacità di riconoscere pattern e applicarli a contesti nuovi. Questa è la base di tutto il prompt engineering moderno: costruire prompt efficaci significa sfruttare bene questa capacità di in-context learning.

Chain-of-thought: il reasoning passo per passo

Nel 2022 Wei et al. di Google pubblicano un paper che scopre un altro fenomeno inatteso: se chiedi al modello di “pensare passo per passo” prima di dare la risposta finale — tecnica chiamata chain-of-thought prompting (CoT) — la performance su task di ragionamento matematico e logico migliora drasticamente, a volte di 20-30 punti percentuali. Il trucco è semplicissimo: invece di chiedere “qual è la risposta?”, chiedi “pensa passo per passo e poi dammi la risposta”. Il modello produce una catena di ragionamento intermedio, e alla fine arriva alla conclusione corretta molto più spesso che se avesse risposto direttamente.

Perché funziona? Ci sono diverse teorie, ma quella più accettata è che generando token intermedi il modello sta di fatto allocando più compute al problema: ogni token è un forward pass aggiuntivo in cui il modello può raffinare la sua rappresentazione del problema prima di committarsi a una risposta. In un certo senso, CoT è un precursore diretto dei reasoning models che vedremo tra poco: dà al modello spazio per “pensare” prima di rispondere. Nello stesso 2022 sono emerse varianti come self-consistency (campionare più catene di ragionamento e prendere la risposta di maggioranza), che migliorano ulteriormente la qualità. La lezione pratica per chi scrive prompt è chiara: quando il problema è complesso, non chiedere mai la risposta secca. Chiedi sempre al modello di esplicitare il ragionamento. Funziona. Il file llms.txt va nella stessa direzione: dare agli LLM istruzioni esplicite e strutturate invece che affidarsi al loro intuito.

Abilità emergenti: realtà o miraggio?

Nel 2022 Wei et al. pubblicano un altro paper importante: Emergent Abilities of Large Language Models. Sostengono che esistono capacità — come il ragionamento aritmetico multi-step, la risoluzione di task complessi, l’uso di strumenti — che non migliorano gradualmente con la scala, ma appaiono “di colpo” oltre una certa soglia di parametri. Sotto la soglia, il modello sembra incapace; sopra la soglia, improvvisamente riesce. Questa idea di “capacità emergenti” ha fatto molto rumore perché suggeriva che scalare ulteriormente avrebbe potuto sbloccare capacità completamente nuove, imprevedibili.

Nel 2023 però Schaeffer et al. di Stanford hanno pubblicato un paper-controreplica intitolato Are Emergent Abilities of Large Language Models a Mirage?, sostenendo che molte di queste “capacità emergenti” sono in realtà artefatti delle metriche di valutazione: se usi metriche discrete (tipo “accuratezza esatta della risposta”), vedi salti netti; se usi metriche continue (tipo “probabilità assegnata al token corretto”), vedi miglioramenti graduali e prevedibili. Non c’è nessuna soglia magica, c’è solo una soglia di visibilità. Il dibattito non è ancora chiuso. La verità pratica probabilmente sta nel mezzo: lo scaling produce miglioramenti graduali continui, ma alcune capacità diventano “utilizzabili” solo oltre certe soglie di affidabilità. Nel 2026, con modelli da centinaia di miliardi di parametri, stiamo ancora scoprendo cose che non sapevamo fossero possibili.

---

Il panorama 2025/2026: GPT-4o, Claude 4, Gemini 2, Llama, MoE e reasoning models

Arriviamo al presente. Il panorama degli LLM nel 2026 è molto più articolato di quanto fosse anche solo due anni fa. Non è più una gara tra “chi ha il modello più grande”, è una mappa con diversi assi di innovazione che si intrecciano: efficienza architetturale, capacità di ragionamento, modalità multiple, apertura del codice. Ti racconto le quattro direzioni principali che stanno definendo questo momento.

Mixture of Experts (MoE): scalare senza far esplodere l’inferenza

Un modello “dense” tradizionale usa tutti i suoi parametri per ogni singolo token. Un Llama 70B usa tutti e 70 miliardi di parametri per processare ogni token che vede. I Mixture of Experts (MoE) rompono questo vincolo: il modello è composto da molti “esperti” (tipicamente 8, 16, 64 o più feed-forward network specializzati), e un componente chiamato router decide dinamicamente, per ogni token, quali pochi esperti attivare. Il risultato è un modello che può avere centinaia di miliardi di parametri totali ma che attiva solo una frazione di essi per ogni token, riducendo drasticamente il costo di inferenza. Mixtral 8x7B (Mistral, fine 2023) è stato il modello open source che ha reso popolare l’approccio: 47B parametri totali, solo circa 13B attivi per token, prestazioni paragonabili a Llama 2 70B a un terzo del costo. Nel 2024 DeepSeek V3 ha spinto l’idea all’estremo: 671B parametri totali, solo 37B attivi per token, batte molti modelli dense molto più grandi. GPT-4 è con ogni probabilità un MoE (mai confermato ufficialmente ma ampiamente dedotto dai leak), Gemini 1.5 Pro lo è esplicitamente, Claude probabilmente anche. Nel 2026 MoE è lo standard di fatto per i modelli di frontiera.

Reasoning models: il nuovo asse di scaling

Nel settembre 2024 OpenAI lancia o1, il primo modello della famiglia “reasoning”. La differenza rispetto a GPT-4o è strutturale: o1 non risponde subito, “pensa” prima — genera una lunga catena di ragionamento interno (chain-of-thought estesa, non visibile all’utente) prima di produrre la risposta finale. Questo pensiero può durare secondi o minuti, consumando migliaia o decine di migliaia di token. Il risultato pratico è un salto di performance enorme su task che richiedono ragionamento matematico, logico, scientifico, di programmazione: o1 risolve problemi di olimpiadi matematiche, dimostra teoremi, supera i migliori competitive programmer umani su Codeforces. A dicembre 2024 OpenAI annuncia o3, che spinge ancora oltre.

Nel gennaio 2025 DeepSeek pubblica DeepSeek-R1, un reasoning model open source con performance vicine a o1, addestrato con RL a pochissimo costo rispetto ai concorrenti occidentali. Il loro paper tecnico è uno dei documenti più studiati dell’anno perché rivela dettagli inediti sul training di reasoning models. Anthropic risponde con la modalità extended thinking di Claude 3.7 (febbraio 2025) e Claude 4/4.5/4.6 (2025-2026), che permette al modello di “pensare” prima di rispondere quando il task lo richiede. Google introduce Gemini 2.0 Flash Thinking. Il concetto chiave che emerge da tutto questo è il test-time compute scaling: oltre a scalare i parametri (training-time), ora scali anche quanto il modello “pensa” a inferenza. È il nuovo asse su cui si sta giocando la partita della frontiera, e promette di continuare a produrre miglioramenti anche se il pretraining scaling puro rallentasse.

Multimodalità nativa: testo, immagini, audio, video

I modelli più recenti non processano solo testo. GPT-4o (“omni”, maggio 2024) è stato il primo grande modello pubblico a essere addestrato nativamente su testo, immagini e audio: non è un modello testo con un encoder immagini bolt-on, è un singolo modello unificato che tratta pixel e audio come token accanto al testo. Claude 3.5 Sonnet (e successivi) ha capacità visive avanzate. Gemini 1.5 e 2 processano video nativamente. Nel 2025-2026 la multimodalità è diventata la norma per i modelli di frontiera, non l’eccezione. L’implicazione pratica è significativa: un modello che “vede” il tuo screenshot, “sente” il tuo audio e “legge” il tuo testo nello stesso contesto può fare cose che prima richiedevano pipeline multiple composte. Il paradigma si sta spostando verso agenti multimodali end-to-end.

Open vs closed: Llama, Mistral, Qwen, DeepSeek

Una delle dinamiche più interessanti del 2024-2026 è la rimonta dei modelli open source. Nel 2023 sembrava che i modelli proprietari (GPT-4, Claude) avessero un vantaggio incolmabile. Nel 2024 Meta ha rotto il paradigma con Llama 3.1 405B, un modello open weights con prestazioni paragonabili ai migliori closed-source. Qwen di Alibaba ha spinto forte con varianti ottimizzate per il cinese e per compiti multi-task. Mistral in Europa ha prodotto modelli efficienti e Mixtral per il mondo MoE. DeepSeek ha scosso gli equilibri nel 2025 con R1 e V3, dimostrando che si può addestrare modelli di frontiera con una frazione del compute dei leader. Nel 2026 la gap tra open e closed esiste ancora sui task più difficili, ma è la più stretta che sia mai stata, e per la maggior parte dei casi d’uso produttivi un modello open source è più che sufficiente — con il vantaggio che puoi farlo girare on-premise, senza mandare dati a terze parti.

Modello	Vendor	Architettura	Parametri (totali / attivi)	Context	Modalità
GPT-4o	OpenAI	Dense o MoE (non confermato)	sconosciuto	128k	Testo, immagini, audio
o1 / o3	OpenAI	Reasoning model	sconosciuto	128k-200k	Testo (+visione in o3)
Claude 4.6 Sonnet	Anthropic	Dense + extended thinking	sconosciuto	200k (1M in test)	Testo, immagini
Gemini 2.0 Pro	Google	MoE multimodale	sconosciuto	1M-2M	Testo, immagini, audio, video
Llama 3.1 405B	Meta (open)	Dense decoder	405B / 405B	128k	Testo
DeepSeek V3	DeepSeek (open)	MoE	671B / 37B	128k	Testo
DeepSeek R1	DeepSeek (open)	Reasoning MoE	671B / 37B	128k	Testo
Mixtral 8x22B	Mistral (open)	MoE	141B / 39B	64k	Testo
Qwen 2.5 72B	Alibaba (open)	Dense decoder	72B / 72B	128k	Testo, immagini

---

Agenti, tool use e la frontiera operativa

Fino a poco tempo fa gli LLM erano essenzialmente “stateless” e “isolati”: ricevevano un prompt, producevano una risposta, fine. Non potevano cercare informazioni, scrivere file, eseguire codice, interagire con API esterne. Dal 2023 in poi questo è cambiato radicalmente con l’introduzione del tool use (chiamato anche function calling): il modello impara a generare chiamate strutturate a funzioni esterne, l’applicazione le esegue, e restituisce i risultati al modello come nuovo contesto. Il modello può quindi incatenare decisioni, reagire ai risultati, cercare nuove informazioni, fino a completare un obiettivo complesso.

Nel 2024 Anthropic ha introdotto MCP (Model Context Protocol), un protocollo standard open per collegare gli LLM a strumenti e fonti di dati esterne. MCP sta diventando nel 2025-2026 l’equivalente di USB per gli agenti AI: un modo standardizzato per esporre tool, database, API, file system al modello. Nel frattempo sono emersi i primi agenti autonomi: sistemi dove l’LLM, dotato di tool e di memoria persistente, può portare a termine task multi-step anche complessi senza supervisione continua. Claude con “computer use” può muovere il mouse e leggere lo schermo. OpenAI ha lanciato “Operator” e “Agents SDK” per costruire agenti che navigano il web in autonomia. Per chi lavora in ambito SEO/marketing, gli agenti stanno cambiando l’operatività: task come audit tecnici, analisi competitor, generazione di report possono essere delegati a un sistema agentic invece di essere fatti manualmente. Se vuoi approfondire l’applicazione pratica di questi concetti, ho scritto una pagina dedicata allo sviluppo di chatbot AI con architettura RAG che copre proprio questo territorio.

---

I limiti reali degli LLM nel 2026

Ti ho raccontato fin qui cosa gli LLM sanno fare, e sono tante cose. Ma sarei disonesto se non ti dicessi anche i limiti reali, perché il rischio più grande quando lavori con questi strumenti è sopravvalutarli. Ecco quelli che secondo me sono i tre problemi strutturali con cui conviviamo nel 2026, e che non sono affatto risolti.

Allucinazioni: feature, non bug

Gli LLM “allucinano” — cioè producono informazioni false con tono confidente. È il loro problema più noto e più discusso, e la gente tende a trattarlo come un difetto da correggere. La verità scomoda è un’altra: le allucinazioni non sono un bug, sono una conseguenza matematica diretta di come funziona il next-token prediction. Il modello è addestrato a produrre il token più probabile data la distribuzione appresa dal training set. Se il prompt chiede qualcosa che non è nel training set in forma esatta, il modello produrrà comunque qualcosa — qualcosa di plausibile, grammaticalmente corretto, nel giusto formato — anche se è inventato. Non ha modo interno di distinguere “so questo con certezza” da “sto tirando a indovinare”. Le tecniche moderne (RLHF, grounding via RAG, calibration) mitigano il problema ma non lo eliminano. La morale pratica è brutale ma semplice: non usare mai un LLM come fonte di verità per fatti specifici verificabili (date, nomi, cifre, citazioni) senza un sistema di grounding esterno. Sempre verificare.

Costi energetici e impatto ambientale

Addestrare un modello di frontiera richiede energia per milioni di dollari. Servirlo in produzione globale richiede data center che consumano come piccole città. Nel 2024-2025 le stime pubblicate suggeriscono che il settore AI complessivo è passato da consumare lo 0.5% dell’elettricità mondiale a oltre il 2%, con proiezioni che potrebbero portarlo al 5-8% entro il 2030 se la crescita prosegue. Microsoft, Google, Meta, Amazon stanno investendo in energia nucleare (anche rinascimento di reattori spenti) per alimentare i loro data center AI. Questo non è un problema astratto: è uno dei vincoli fisici reali che potrebbero rallentare la corsa allo scaling nei prossimi anni. Quando usi un LLM, ricordati che dall’altra parte c’è una GPU che consuma elettricità, e quella elettricità ha un costo ambientale.

Interpretability: la scatola nera che inizia a trasparire

Un LLM con centinaia di miliardi di parametri è, per chiunque lo usi, una scatola nera: inserisci prompt, ottieni risposta, non sai davvero perché il modello ha detto proprio quella cosa e non un’altra. Il campo della mechanistic interpretability cerca di aprire questa scatola — identificare quali circuiti neurali dentro il modello implementano quali comportamenti. Anthropic è stata in prima linea su questo fronte con paper come “Scaling Monosemanticity” (2024) e il lavoro successivo sugli autoencoder sparsi, che hanno permesso di identificare “feature” interne umanamente interpretabili in Claude. Ma siamo lontani dall’avere una comprensione completa: sappiamo che esistono circuiti per il riconoscimento di entità, per il ragionamento induttivo, per il bias, ma mappare completamente il comportamento di un modello da 100+ miliardi di parametri è ancora un problema aperto. Questo ha implicazioni serie per la sicurezza AI: finché non capiamo cosa fa un modello internamente, non possiamo garantire con certezza che non farà cose indesiderate in condizioni nuove. È un problema di ricerca fondamentale, non risolto.

---

Implicazioni per SEO e AI Search

Se sei arrivato fin qui, complimenti — hai letto una guida tecnica densa. Ora il payoff: tutto questo cosa significa concretamente per chi lavora nella search, nel marketing, nella content strategy? Molto, moltissimo, il panorama è cambiato radicalmente negli ultimi due anni. Voglio darti tre angoli di lettura pratici, ognuno direttamente collegato a cose che puoi fare (o rivedere) oggi.

Dal ranking algoritmico alla generazione: come cambia la SERP

Per vent’anni la SEO ha significato “ottimizzare per apparire più in alto in una lista di dieci link blu”. Questo paradigma sta finendo. Google AI Overviews, ChatGPT Search, Perplexity, Claude con browsing: tutti questi sistemi non mostrano più una lista di link, mostrano una risposta sintetica generata da un LLM che cita alcune fonti. L’unità di misura non è più “posizione sulla SERP” ma “essere citato nella risposta generativa”. E il meccanismo che decide chi viene citato non è più solo PageRank + segnali classici, è un sistema di retrieval (ricerca dei documenti rilevanti) seguito da un LLM che sintetizza. Il che significa che essere ben indicizzati non basta: devi essere retrievable dal sistema di embedding, e il tuo contenuto deve essere utilizzabile dal LLM senza ambiguità.

RAG: il pattern che unisce LLM e search

Il paradigma dominante per applicare gli LLM a corpus di contenuti specifici — che sia un sito web, una knowledge base aziendale, una documentazione tecnica — si chiama RAG (Retrieval-Augmented Generation). Il funzionamento è concettualmente semplice: prima di rispondere, il sistema recupera dal corpus i “chunk” di testo più rilevanti per la query dell’utente (usando embedding e similarità vettoriale), li inserisce nel contesto del LLM, e gli chiede di rispondere usando quelle informazioni. Questo risolve due problemi in un colpo: riduce le allucinazioni (il modello è forzato a basarsi su testo reale, non su memoria parametrica) e permette di aggiornare la conoscenza senza riaddestrare il modello. Praticamente tutti i sistemi di AI search che esistono nel 2026 sono varianti di RAG. Se vuoi capire come ottimizzare i tuoi contenuti affinché siano facilmente recuperabili e citati dai sistemi RAG di Google e degli altri motori generativi, il mio articolo sulla reverse engineering del RAG SEO (che ho linkato all’inizio di questa guida) entra nel dettaglio operativo.

Brand monitoring negli LLM

Ecco una cosa che pochi stanno ancora facendo ma che nel 2026-2027 diventerà mainstream: monitorare come gli LLM descrivono il tuo brand. Quando un utente chiede a ChatGPT “qual è il miglior consulente SEO in Italia?”, il modello produce una risposta che cita (o non cita) certi nomi, certi siti, certe aziende. Essere presenti in quelle risposte è la nuova frontiera della brand visibility, e richiede un lavoro specifico che non si sovrappone completamente con la SEO classica. Si tratta di capire quali fonti usano i vari LLM, quali segnali pesano, come vieni rappresentato in contesti diversi. È un campo nuovo, senza tool standardizzati, dove il metodo conta più della strumentazione. Ho aperto un servizio dedicato al tracking AI del brand negli LLM proprio perché la domanda del mercato sta esplodendo e i metodi consolidati ancora non esistono — si fanno.

---

Conclusione: dalla ricorrenza alla generazione, passando per il ragionamento

Abbiamo fatto un lungo viaggio insieme. Siamo partiti da reti neurali che leggevano il testo un token alla volta come studenti distratti e siamo arrivati a modelli che generano ragionamenti passo per passo, usano strumenti, guardano immagini, ascoltano audio, ti aiutano a scrivere codice che compila al primo tentativo. Otto anni. È davvero incredibile quanto sia successo in così poco tempo, e la cosa ancora più notevole è che quasi tutto ruota intorno a un’unica architettura fondamentale — il Transformer — nata da un paper di appena otto pagine scritto nel 2017.

L’idea che voglio lasciarti è questa: gli LLM non sono magia, sono moltiplicazioni di matrici molto ben orchestrate. Ogni volta che ChatGPT ti stupisce, sotto il cofano ci sono operazioni matematiche comprensibili, formulate in un paper, replicabili in Python. Questo non toglie nulla alla meraviglia — anzi, secondo me la rende più grande, perché dimostra che la comprensione profonda del linguaggio emerge da principi matematici relativamente semplici applicati su scala estrema. Ma significa anche che nessuno ha poteri magici: se capisci i principi, puoi prevedere cosa gli LLM faranno bene e cosa faranno male. Puoi usarli con criterio invece di subirli con stupore.

Dove andiamo nel 2026-2027? La mia lettura, confortata dai segnali che vedo arrivare dai laboratori di frontiera: meno scaling puro del pretraining, molto più scaling del test-time compute (reasoning models), agenti sempre più autonomi con tool use sofisticato, multimodalità che diventa invisibile (smetterai di chiederti se il modello “vede” le immagini, darai per scontato che lo faccia), e probabilmente i primi passi seri verso architetture non-Transformer ibride che affronteranno il problema del costo quadratico in modo strutturale. Chi lavora nella SEO e nella search vivrà una riscrittura completa del proprio mestiere, non tra dieci anni ma tra dodici o diciotto mesi. La finestra per adeguarsi è aperta adesso.

Se vuoi continuare in questa direzione, il naturale passo successivo è vedere come questi concetti si applicano concretamente alla SEO: il pezzo sul reverse engineering del RAG (che ho linkato sopra) è quello che ti consiglio per primo, perché collega tutto quello che hai letto qui — embeddings, chunking, retrieval, LLM, grounding — con il lavoro quotidiano di chi ottimizza contenuti per i motori generativi. E se stai valutando come integrare questi sistemi nei tuoi workflow — costruire un chatbot RAG, impostare un sistema di brand monitoring, fare audit tecnici assistiti da agenti AI — possiamo parlarne direttamente: contattami e raccontami il tuo caso. Nel frattempo, grazie per essere arrivato in fondo. Leggere settemila parole su un argomento tecnico denso non è da tutti, e se ci sei riuscito significa che la curiosità ti sta portando nel posto giusto. Ci vediamo al prossimo articolo.