Cache vs reasoning: il parallelo (e i suoi limiti) con fast e slow thinking

Quando un sistema LLM “sembra deliberare” sta davvero facendo qualcosa di analogo a un sistema 2 umano, oppure sta solo generando più token? Questo capitolo prende sul serio la domanda mostrando, uno per uno, i meccanismi ingegneristici 2022-2026 che producono effetti simili a deliberation — chain-of-thought, reasoning model, search, self-reflection, agent loop, tool use — e poi distingue con cura cosa è simile, cosa no, e dove la metafora “S1/S2” smette di essere utile e comincia a essere una trappola.

Un utente, nel marzo 2026, apre Claude e chiede: “Trova due interi positivi a e b tali che a² + b² = 2026 con a < b.” Un Claude Sonnet base risponde in due secondi, sicuro, sbagliando: “a = 9, b = 45, perché 81 + 2025 = 2106”. L’utente legge, scrolla, clicca sull’opzione “Extended thinking”, rincolla la stessa domanda. Ora vede una bandiera “Thinking…” che resta ferma per quaranta secondi. Sotto, in un riquadro più chiaro, scorre la traccia: il modello prova 45² = 2025, troppo grande; nota che a² ≤ 1013, quindi a ≤ 31; itera, scarta, riconsidera; trova a = 15, b = 41 perché 225 + 1681 = 1906, sbagliato di nuovo; corregge: a = 25, b = 39 (625 + 1521 = 2146), ancora no; finalmente a = 21, b = 40 (441 + 1600 = 2041); poi a = 5, b = 45 (25 + 2025 = 2050); e si chiede se la decomposizione esista davvero, ricordando il teorema di Fermat sulle somme di due quadrati e la fattorizzazione 2026 = 2 · 1013. Verifica: 1013 ≡ 1 (mod 4), quindi 1013 si decompone, e con esso 2026. Calcola la decomposizione di 1013 come 2² + 3² · 7² · ... — sbaglia di nuovo, riprova — e infine consegna: “a = 15, b = 41 non funziona, a = 25, b = 39 non funziona; verifico tutti i quadrati fino a 31 e confermo: non esiste decomposizione a² + b² = 2026 con interi positivi. Risposta: nessuna soluzione.”

Questa scena — il modello “veloce” che sbaglia con sicurezza, il modello “thinking” che rallenta, esplora, si corregge, e che alla fine arriva a una risposta più solida — è, nel 2026, l’esperienza utente più simile a “guardare qualcuno usare il sistema 2” che la tecnologia LLM offra. Ed è, allo stesso tempo, una buona occasione per chiedersi cosa stia davvero succedendo dentro la macchina e quanto le parole “sistema 1” e “sistema 2”, prese a prestito dalla psicologia di Daniel Kahneman, ci aiutino o ci confondano.

Perché un capitolo ponte qui

La domanda “gli LLM hanno un sistema 2?” è mal posta. Lo è per ragioni che il capitolo precedente, dual-process-kahneman, ha già reso esplicite: anche negli umani il “sistema 2” non è un modulo neuroanatomico separato ma una famiglia di regimi di elaborazione, e la critica di David Melnikoff e John Bargh (2018) ha mostrato che i tratti che la teoria classica raggruppa sotto S1 — automaticità, efficienza, incontrollabilità, inconsapevolezza — non covariano in modo netto. Chiedere a una macchina se “ha” qualcosa che negli umani non è un’entità ma una descrizione di pattern produce solo confusione.

La domanda ben posta è un’altra: quali meccanismi ingegneristici, nei sistemi LLM 2022-2026, producono effetti che gli umani otterrebbero attivando deliberation? Questa domanda ha risposte concrete, misurabili, citabili. Ed è la domanda che organizza questo capitolo.

Il taglio è operativo. Non è un capitolo storico sul ragionamento simbolico (parte VII tratta planning, logica, KR). Non è un capitolo sulla teoria dual-process (cap. 74). È un capitolo ponte che mette in dialogo due vocabolari — quello della psicologia cognitiva e quello dell’ingegneria LLM — e cerca di evitare i due errori speculari: confondere le metafore con la meccanica, oppure rifiutare le metafore e rinunciare al vocabolario condiviso. Il compromesso è: usare le metafore con disciplina, marcandone sempre la classe (analogia funzionale, analogia retorica, filiazione assente), e descrivere la meccanica con precisione.

Disclaimer: cosa il capitolo precedente ha già stabilito

Per non ripetere il cap. 74, riassumo in tre punti cosa lì è già stato concluso, e che qui è premessa.

Primo, la teoria S1/S2 è un modello descrittivo a due regimi del giudizio umano, non un’architettura cognitiva letterale. La doppia natura del pensiero — un regime rapido e automatico, un regime lento e deliberato — è un pattern empirico robusto, non un’ipotesi sull’anatomia del cervello.

Secondo, l’analogia retorica popolare “i large language model sono S1, il chain-of-thought e i reasoning model sono S2” è didatticamente comoda ma rischiosa. Non è una filiazione documentata (Jason Wei, l’autore del paper su CoT del 2022, non cita Kahneman; il system card di o1 di OpenAI non cita dual-process; DeepSeek-R1 nemmeno). Non è un’equivalenza (i meccanismi sono diversi: la generazione di un token è autoregressione, non attivazione di un secondo sottosistema). È un’analogia retorica: somiglianza pedagogica che aiuta a parlare, ma che non va presa alla lettera.

Terzo, la proposta di “System 2 deep learning” di Yoshua Bengio (computer scientist canadese a Mila/Université de Montréal, premio Turing 2018), formulata nel keynote NeurIPS 2019 e nell’articolo del 2021, è un programma di ricerca, non un’implementazione. Bengio auspicava modularità, sparse factor graphs, modelli causali del mondo. Al 2026 nessun sistema in produzione deriva da quella proposta in modo lineare. I reasoning model contemporanei — o1, o3, DeepSeek-R1, Claude thinking, Gemini Thinking — sono nati da una traiettoria diversa: reinforcement learning su lunghe reasoning trace, non architetture esplicitamente “S1+S2”.

Tenuti questi tre punti, il resto del capitolo è una mappa dei meccanismi reali con cui i sistemi LLM, nel 2024-2026, producono comportamenti che imitano funzionalmente la deliberation umana. La mappa è organizzata per famiglie.

Famiglie di meccanismi: la mappa operativa

flowchart TB
    R["Standard prompting (single-pass autoregressive)"]
    R --> B1["Chain-of-Thought (Wei 2022)"]
    R --> B2["Search-based"]
    R --> B3["Self-reflection"]
    R --> B4["Agent loops + tools"]
    R --> B5["Reasoning models (RL on traces)"]

    B1 --> B1a["Zero-shot CoT (Kojima 2022)"]
    B1 --> B1b["Self-consistency (Wang 2022)"]

    B2 --> B2a["Tree of Thoughts (Yao 2023)"]
    B2 --> B2b["Graph of Thoughts (Besta 2023)"]
    B2 --> B2c["Process Reward Models (Lightman 2023)"]

    B3 --> B3a["Reflexion (Shinn 2023)"]
    B3 --> B3b["Self-Refine (Madaan 2023)"]

    B4 --> B4a["ReAct (Yao 2022)"]
    B4 --> B4b["Function calling / MCP (2023-2024)"]
    B4 --> B4c["Computer use / browser use (2024-2025)"]

    B5 --> B5a["OpenAI o1 (Sep 2024)"]
    B5 --> B5b["OpenAI o3 (Dec 2024)"]
    B5 --> B5c["DeepSeek-R1 (Jan 2025)"]
    B5 --> B5d["Claude / Gemini thinking (2024-2025)"]

Figura 1 — Family tree of deliberation patterns in LLMs (2022-2026): root “standard autoregressive prompting” branching to chain-of-thought, search-based, self-reflection, agent loops + tools, reasoning models

Famiglia 1: chain-of-thought prompting

Il primo meccanismo, in ordine cronologico e didattico, è il chain-of-thought (CoT) prompting. Jason Wei (research scientist a Google Research, ora OpenAI) e colleghi, nel paper “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models” pubblicato a NeurIPS 2022, mostrano che un prompt few-shot in cui ogni esempio di soluzione include un ragionamento step-by-step, prima della risposta finale, migliora drasticamente l’accuracy su task di ragionamento matematico e simbolico. Il dataset di riferimento è GSM8K (Cobbe et al., OpenAI 2021, 8.500 problemi di matematica delle scuole elementari con soluzione step-by-step), e il modello di riferimento è PaLM-540B (Pathways Language Model di Google, 540 miliardi di parametri). L’accuracy di PaLM-540B su GSM8K passa da circa 18% (standard prompting, “domanda → risposta”) a circa 57% (CoT 8-shot, “domanda → ragionamento step-by-step → risposta”). Un salto di ~40 punti di accuracy ottenuto cambiando solo il formato del prompt, senza toccare i pesi del modello.

Pochi mesi dopo, Takeshi Kojima (PhD student all’University of Tokyo) e colleghi pubblicano “Large Language Models are Zero-Shot Reasoners” (NeurIPS 2022). Il contributo: una formula magica, “Let’s think step by step”, aggiunta al prompt prima della risposta, attiva CoT senza bisogno di fornire esempi. InstructGPT su GSM8K passa da 10% (zero-shot direct) a 41% (zero-shot CoT). Il pattern è universale al punto che frasi del tipo “ragioniamo passo per passo” sono entrate nei system prompt di default di molte applicazioni 2023-2026.

Una variante importante è il self-consistency di Xuezhi Wang (Google Brain, ora Google DeepMind) e colleghi, “Self-Consistency Improves Chain of Thought Reasoning in Language Models” (arXiv 2022, ICLR 2023). Invece di generare un singolo CoT (greedy o low-temperature), si campionano N traiettorie indipendenti (es. N=40, temperature 0.7) e si prende la majority vote sulle risposte finali. Su GSM8K, MultiArith e altri benchmark migliora di 10-20 punti rispetto al singolo CoT. È il primo passo concreto verso quello che diventerà l’idea di “spendere più compute al test time per accuracy migliore”.

Il meccanismo è importante da capire bene. CoT non aggiunge un secondo modulo al modello. Non c’è un “pensatore lento” che si attiva. C’è solo next-token prediction standard, ma su una sequenza di output più lunga: il modello, condizionato a produrre prima passi intermedi e poi la risposta, distribuisce il calcolo lungo più token, e la risposta finale è condizionata da tutto quello che è stato generato prima. Funzionalmente, l’effetto somiglia a una deliberation (“più tempo per riflettere produce risposte migliori”); meccanicamente è autoregressione su una traccia testuale più estesa.

Una conseguenza è il dibattito sulle emergent abilities. Un risultato controverso del paper di Wei è che CoT funziona “solo” su modelli oltre una certa scala (≥100B parametri); su modelli piccoli può degradare le performance. Questo claim viene messo in discussione da Rylan Schaeffer, Brando Miranda e Sanmi Koyejo, “Are Emergent Abilities of Large Language Models a Mirage?” (NeurIPS 2023, best paper). La tesi: molte “abilità emergenti” sono artefatti delle metriche scelte (accuracy esatta su problemi multi-step). Con metriche più graduate (es. token-level edit distance) le curve sono lisce. La discussione resta aperta nel 2026; per il ponte basta sapere che “CoT come capacità che emerge a una certa scala” è una semplificazione.

Un caveat ulteriore, importante per non reificare la metafora S2, viene dal lavoro di Tamera Lanham e colleghi a Anthropic, “Measuring Faithfulness in Chain-of-Thought Reasoning” (arXiv 2023). Domanda: se manipoliamo il CoT — rimuoviamo passi, inseriamo errori, cambiamo il prefisso — la risposta finale cambia in modo coerente? Risultato: la faithfulness (la fedeltà del CoT al calcolo effettivo) varia molto fra modelli e task. In molti casi il modello produce la stessa risposta finale anche dopo che il CoT è stato manomesso, suggerendo che la traccia testuale è una rationalizzazione post-hoc più che un riflesso del calcolo interno. Questo è il pezzo di evidenza più forte contro l’identificazione “CoT = sistema 2”: il pensiero esplicitato non sempre è il pensiero che ha prodotto la risposta.

Famiglia 2: reasoning model e test-time compute scaling

Il salto qualitativo del 2024-2025 è la nascita dei reasoning model: modelli addestrati esplicitamente, via reinforcement learning, a produrre lunghe reasoning trace prima della risposta. Non è più solo prompting; è training.

OpenAI annuncia o1 (preview a settembre 2024, full a dicembre 2024). Il modello è descritto come “trained to think before it answers” via RL su reasoning traces. Le traiettorie di pensiero sono inizialmente parzialmente nascoste all’utente (decisione editoriale di OpenAI, contestata da chi vorrebbe trasparenza). I salti di performance sono significativi: su AIME (American Invitational Mathematics Examination, concorso di matematica per liceali statunitensi), su Codeforces (competitive programming), su GPQA (Graduate-Level Google-Proof Q&A, benchmark con domande di PhD in scienze, costruito da David Rein e colleghi, 2023). Il successore o3, annunciato a dicembre 2024 con accesso API graduale nel 2025, raggiunge in modalità “high compute” oltre l’85% su ARC-AGI 2 (Abstraction and Reasoning Corpus version 2, benchmark di François Chollet pensato per misurare ragionamento general-purpose), un risultato che fino a qualche mese prima sembrava lontano. Il costo per task in high-compute mode, secondo le stime di Chollet pubblicate sul blog ARC Prize, è dell’ordine di migliaia di dollari per task: una frontiera che non è di ricerca dovuta solo all’algoritmo, ma anche all’economia.

A gennaio 2025 DeepSeek-AI rilascia DeepSeek-R1 con il paper “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning” (arXiv 2501.12948). Importante per due ragioni. Primo, è open weights: si possono scaricare i pesi e ispezionare. Secondo, mostra che il training di reasoning capability può essere fatto via RLVR — Reinforcement Learning from Verifiable Rewards: il reward viene da un verifier deterministico (math con ground-truth, codice con test che passano), non da un reward model addestrato. La pipeline è elegante: si parte da un modello base, si applica RL puro (senza supervised fine-tuning preliminare per il reasoning) producendo DeepSeek-R1-Zero, e si osservano comportamenti emergenti chiamati nel paper “aha moments”: il modello impara da solo a fare backtracking, a riconsiderare ipotesi, a verificare passi. Successivamente DeepSeek-R1 distillato in modelli più piccoli (Qwen, Llama) trasferisce parte della capability a costi di inferenza ridotti.

Le altre famiglie, contemporanee: Anthropic Claude 3.7 Sonnet introduce a febbraio 2025 una “extended thinking” mode con budget di token configurabile e thinking trace visibile; Claude 4 Opus e Sonnet (2025-2026) consolidano il pattern. Google rilascia Gemini 2.0 Flash Thinking a dicembre 2024 e successori con thinking trace esposta.

Il framework teorico per capire perché tutto questo “scala” viene da Charlie Snell, Jaehoon Lee, Kelvin Xu, Aviral Kumar (Google DeepMind), “Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters” (arXiv 2408.03314). Il claim, supportato da esperimenti su MATH e altri benchmark: per task di difficoltà medio-alta, allocare più test-time compute (più token di thinking, più sample, più search depth) a un modello relativamente piccolo può battere un modello 14× più grande con singolo forward pass. Per task molto difficili la regola si rovescia: serve più capacità, non solo più tempo. La curva accuracy-vs-compute è specifica del task, e ottimizzare l’allocazione del budget è un problema di engineering.

Il punto, ancora una volta, è meccanico. Più test-time compute significa: più token generati nel buffer di thinking; oppure più sample indipendenti con majority vote; oppure più rami di un albero esplorati. Il modello è sempre lo stesso, le operazioni sono sempre autoregressione e selezione. Non c’è un secondo cervello che si accende. È deliberation simulata da una sequenza più lunga (e da un policy gradient che, in training, ha premiato traiettorie che esplorano).

Famiglia 3: search-based reasoning

Una famiglia ortogonale è quella dei pattern search-based: invece di generare una singola sequenza lineare, si esplora un albero o un grafo di “thoughts” parziali, valutando i nodi e potendo backtrackare.

Shunyu Yao (Princeton, ora OpenAI) e colleghi, in “Tree of Thoughts: Deliberate Problem Solving with Large Language Models” (NeurIPS 2023), introducono Tree of Thoughts (ToT): il modello LLM viene usato sia come generator (espande un nodo in N possibili continuazioni) sia come evaluator (assegna un valore a ciascun nodo). Sopra c’è un controllo di search — BFS o DFS — che decide quale ramo espandere. Il risultato canonico è su Game of 24 (data una quaterna di numeri, raggiungere 24 con +, -, ×, ÷): GPT-4 con CoT lineare risolve il 4% dei problemi; GPT-4 con ToT-BFS risolve il 74%. Un salto enorme dovuto alla possibilità di esplorare e scartare rami sbagliati invece di committarsi al primo.

Maciej Besta e colleghi (ETH Zurich), in “Graph of Thoughts: Solving Elaborate Problems with Large Language Models” (arXiv 2308.09687, 2023), generalizzano da albero a DAG, permettendo merge di thoughts equivalenti.

Un complemento cruciale viene dai Process Reward Models (PRM). Hunter Lightman e colleghi a OpenAI, in “Let’s Verify Step by Step” (arXiv 2305.20050, 2023), addestrano un verifier che assegna reward al singolo passo intermedio, non solo all’esito finale (Outcome Reward Model, ORM). Costruiscono il dataset PRM800K (800.000 passi di MATH annotati come corretti/sbagliati). Risultato: PRM batte ORM nella selezione fra 100 sample di soluzioni a problemi MATH (passa da 73% a 78% accuracy con il miglior sample selezionato dal verifier). Il PRM diventa la fondazione su cui poi vengono costruiti molti reasoning model: il segnale per il RL non è solo “la risposta finale è giusta?” ma “ogni passo è giusto?”.

L’effetto funzionale di ToT, GoT e PRM è quello che, in psicologia, sarebbe l’esplorazione deliberata di alternative con valutazione critica. L’effetto è ottenuto componendo l’LLM (come oracolo locale) con un controller esterno (search algorithm) e un valutatore (PRM o LLM-as-judge). È una architettura ibrida in cui la “deliberation” è in larga parte fuori dal modello, nel codice del harness.

Famiglia 4: self-reflection e self-correction

La quarta famiglia è il loop di self-reflection. Noah Shinn e colleghi (Northeastern University e Princeton), in “Reflexion: Language Agents with Verbal Reinforcement Learning” (NeurIPS 2023, arXiv 2303.11366), propongono Reflexion: l’agente tenta un task, riceve un feedback (un reward binario, o una critica testuale), e produce una “reflection” — un commento testuale sui propri errori — che viene aggiunta al context per il tentativo successivo. Su HumanEval (benchmark di code generation di Mark Chen e colleghi, OpenAI 2021) GPT-4 con Reflexion passa da 80% a 91% in 5 trial. La memoria delle correzioni è pura aggiunta al prompt; non c’è update dei pesi.

Aman Madaan e colleghi (CMU), in “Self-Refine: Iterative Refinement with Self-Feedback” (NeurIPS 2023), formalizzano un loop simile in cui lo stesso modello genera output, lo critica, e produce una versione revisionata. Funziona senza ground-truth, ma con un caveat importante: il loop deve avere un criterio di stopping non triviale, altrimenti il modello “rationalizza” indefinitamente.

Il caveat è esplicitato da Jie Huang e colleghi (Google) in “Large Language Models Cannot Self-Correct Reasoning Yet” (arXiv 2310.01798, 2023): in assenza di feedback esterno (ground-truth, verifier, tool), self-correction puro spesso peggiora le risposte, perché il modello tende a sostituire una risposta corretta con una sbagliata “più articolata”. Questo è uno dei punti critici per la metafora S2: in umani la deliberation può migliorare il giudizio anche senza feedback (per riflessione su principi noti); in LLM la deliberation senza ancoraggio esterno tende ad andare alla deriva.

Famiglia 5: agent loop e tool use

La quinta famiglia, e probabilmente la più impattante in pratica, è quella degli agent loop combinati con tool use.

Il pattern fondante è ReAct (Reasoning + Acting) di Shunyu Yao e colleghi, “ReAct: Synergizing Reasoning and Acting in Language Models” (arXiv 2210.03629, ICLR 2023). Il modello produce un ciclo intervallato: Thought (sintesi dell’analisi corrente in linguaggio naturale), Action (chiamata a un tool con argomenti strutturati), Observation (risultato del tool, restituito al context). Il loop continua fino a quando il modello emette un final answer. Il risultato su benchmark fattuali come HotpotQA è che ReAct riduce significativamente le allucinazioni rispetto a CoT puro: il modello, invece di “inventarsi” la data di nascita di una persona, fa una web search e legge il risultato.

flowchart TB
    R["Standard prompting (single-pass autoregressive)"]
    R --> B1["Chain-of-Thought (Wei 2022)"]
    R --> B2["Search-based"]
    R --> B3["Self-reflection"]
    R --> B4["Agent loops + tools"]
    R --> B5["Reasoning models (RL on traces)"]

    B1 --> B1a["Zero-shot CoT (Kojima 2022)"]
    B1 --> B1b["Self-consistency (Wang 2022)"]

    B2 --> B2a["Tree of Thoughts (Yao 2023)"]
    B2 --> B2b["Graph of Thoughts (Besta 2023)"]
    B2 --> B2c["Process Reward Models (Lightman 2023)"]

    B3 --> B3a["Reflexion (Shinn 2023)"]
    B3 --> B3b["Self-Refine (Madaan 2023)"]

    B4 --> B4a["ReAct (Yao 2022)"]
    B4 --> B4b["Function calling / MCP (2023-2024)"]
    B4 --> B4c["Computer use / browser use (2024-2025)"]

    B5 --> B5a["OpenAI o1 (Sep 2024)"]
    B5 --> B5b["OpenAI o3 (Dec 2024)"]
    B5 --> B5c["DeepSeek-R1 (Jan 2025)"]
    B5 --> B5d["Claude / Gemini thinking (2024-2025)"]

Figura 1 — ReAct loop diagram: Thought → Action → Observation → Thought, with terminal Final answer

Tool use (chiamato anche function calling) viene standardizzato a livello API a giugno 2023 da OpenAI e poco dopo da Anthropic per Claude. Il modello, addestrato a riconoscere uno schema di tool nel prompt, emette JSON ben formato con nome del tool e argomenti; il harness esegue il tool e restituisce il risultato come messaggio “tool”. Diventa il backbone di tutti gli agent moderni.

Andong Zhou e colleghi (Yale), in “Language Agent Tree Search” (LATS, arXiv 2310.04406, 2023), combinano ReAct con MCTS (Monte Carlo Tree Search) sulle traiettorie agentiche: ogni “stato” è un punto del trial dell’agente, le azioni sono tool call possibili, il valore viene da una combinazione di reward esterni e LLM-as-evaluator. È la fusione search + reflection + tool, ed è uno dei pattern più sofisticati nel panorama 2024-2026.

A novembre 2024, Anthropic rilascia MCP (Model Context Protocol) come standard aperto: una specifica per server che espongono tool, resources e prompts via un transport tipizzato (stdio o HTTP+SSE). L’effetto pratico è disaccoppiare il client (Claude Desktop, Claude Code, IDE plugin, harness custom) dai server (filesystem, git, database, browser, qualsiasi cosa). Per il ponte concettuale: MCP permette di comporre capability operative — file system, esecuzione codice, navigazione web, query SQL — senza ri-addestrare il modello. La “deliberation” simulata diventa più ricca perché l’agente può delegare passi precisi a tool affidabili, riservando al modello la pianificazione e il ragionamento di alto livello.

Nel 2024-2025 emergono due capability ulteriori. Computer use (Anthropic, ottobre 2024 in Claude 3.5 Sonnet “new”): l’agente vede screenshot dello schermo e decide click, scroll, type. Browser use (varianti di Browserbase, Stagehand, Playwright-based agents): l’agente naviga il web come un umano. Entrambe sono loop perception-cognition-action autoregressivi, con tutti i limiti del caso (latency, errori di OCR sui pixel, fragility a UI changes), ma estendono drasticamente il dominio in cui un LLM può operare.

Un caso particolare di tool è il code interpreter (lanciato da OpenAI a luglio 2023 come Code Interpreter / Advanced Data Analysis; Anthropic offre l’analysis tool dal 2024). Il modello scrive Python eseguito in una sandbox isolata; il risultato torna nel context. Questo è un esempio puro di “S2 esterno”: calcoli numerici precisi, manipolazione simbolica, plot, analisi di dataset — operazioni che il transformer farebbe male in autoregressione — sono delegate a un interprete deterministico. Per il ponte: l’agente compone una capability “intuitiva” (decidere cosa calcolare) con una capability “deliberata” (eseguire il calcolo correttamente) esternalizzando la seconda.

Famiglia 6: architetture ibride research-stage

La sesta famiglia non è ancora in produzione ma merita menzione perché è dove il dibattito teorico è più vicino alla metafora S1/S2.

Bengio 2019/2021, già citato. Programma “System 2 deep learning”. Modularità, sparse factor graphs, attention guidata da goal espliciti, modelli causali. Al 2026 l’eredità di questo programma vive in lavori sparsi (causal representation learning, modular networks) ma non in un’architettura production che incarni la proposta.

Yann LeCun (computer scientist franco-americano, VP & Chief AI Scientist di Meta, premio Turing 2018), in “A Path Towards Autonomous Machine Intelligence” (position paper 2022) e nei suoi interventi successivi, propone JEPA — Joint-Embedding Predictive Architecture: un’architettura che impara un world model predittivo nello spazio delle rappresentazioni, non nello spazio dei token o dei pixel. I-JEPA (su immagini) e V-JEPA (su video) sono implementazioni preliminari. Tesi di LeCun: i LLM autoregressivi non sono la strada per un’intelligenza autonoma; serve un modello del mondo che predice in spazio latente, e che poi guida il planning. È una posizione minoritaria nel mainstream LLM 2026, ma intellettualmente seria, e nella retorica LeCun usa esplicitamente la cornice “i LLM sono S1, serve qualcosa di diverso per S2”. Va etichettata come proposta, non come implementazione realizzata.

Infine, gli AI scientist agent: Sakana AI 2024 (“The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery”) e i molti follow-up del 2025-2026. Loop di hypothesis-experiment-analysis-paper su domini circoscritti (ML research su MNIST-scale, fisica computazionale, drug discovery). Sono più orchestrazioni di harness che architetture nuove, ma estendono il pattern agent loop su orizzonti molto lunghi.

Una sidebar tecnica: cosa cambia quando il modello “pensa”

Per chi vuole vedere meccanicamente la differenza fra un forward pass standard e un forward pass con thinking, vale la pena fissare alcuni numeri di ordine di grandezza, validi nel 2026 e suscettibili di cambiare.

Un modello di fascia alta tipo Claude Sonnet o GPT-4o, su una query conversazionale media, produce 200-500 token di output in 2-5 secondi. Il KV cache cresce di qualche megabyte per il prompt e altrettanto per la risposta. Il costo, ai prezzi mid-2025, è dell’ordine del millesimo di dollaro per query.

Lo stesso modello in modalità thinking (Claude extended, o1 medium, DeepSeek-R1) sulla stessa query potrebbe non attivare thinking se la query è banale, oppure attivarlo per pochi token. Su una query difficile (problema math non triviale, debugging non triviale di codice, analisi multi-passaggio) il thinking arriva a 5.000-50.000 token interni, prima che venga emessa la risposta finale di 200-500 token. La latency passa da 5 secondi a 30-180 secondi. Il KV cache cresce proporzionalmente. Il costo si moltiplica per 10-100x.

In modalità “high compute” (o3 high, configurazioni di test-time scaling con sample multipli e selection), si possono allocare milioni di token totali per task: questo include il sample di N traiettorie indipendenti, ciascuna lunga decine di migliaia di token, più la fase di selection via verifier o majority vote. La latency è di minuti o ore. Il costo è di centinaia o migliaia di dollari per task.

Per chi costruisce sistemi è utile tenere in mente che il “thinking” è esattamente questo: più token generati, internamente o esternamente, nello stesso modello. Non c’è un modello segreto più capace che si attiva. C’è la stessa policy, condizionata su un prefisso che invita a esplorare, che produce traiettorie più lunghe. La capability emerge dal training (RL su reasoning trace + RLVR su verifier deterministici); l’inferenza la spende.

Una conseguenza pratica: per chi disegna applicazioni, il budget di token è la leva di controllo. Aumentarlo migliora accuracy su task hard fino a un punto di diminishing returns; oltre, è spreco. Diminuirlo riduce costo e latency a scapito di accuracy. La curva è specifica del task. Non c’è una scelta universalmente ottimale; c’è una decisione di engineering.

flowchart LR
    UT["Task utente"] --> T["Thought (LLM)"]
    T --> A["Action: tool_call(args)"]
    A --> O["Observation: tool_result"]
    O --> T
    T -.->|criterio di stop| F["Risposta finale"]

Figura 3 — Test-time compute scaling curve: accuracy vs tokens-of-thought, three curves for easy/medium/hard tasks showing diminishing returns

Cosa manca rispetto a un sistema 2 umano

Nessuno dei meccanismi sopra implementa “il sistema 2” nel senso pieno della teoria di Kahneman e Stanovich. Lo dico in positivo: ecco sette dimensioni in cui il gap fra “deliberation simulata in LLM” e deliberation umana resta ampio nel 2026.

flowchart TB
    R["Standard prompting (single-pass autoregressive)"]
    R --> B1["Chain-of-Thought (Wei 2022)"]
    R --> B2["Search-based"]
    R --> B3["Self-reflection"]
    R --> B4["Agent loops + tools"]
    R --> B5["Reasoning models (RL on traces)"]

    B1 --> B1a["Zero-shot CoT (Kojima 2022)"]
    B1 --> B1b["Self-consistency (Wang 2022)"]

    B2 --> B2a["Tree of Thoughts (Yao 2023)"]
    B2 --> B2b["Graph of Thoughts (Besta 2023)"]
    B2 --> B2c["Process Reward Models (Lightman 2023)"]

    B3 --> B3a["Reflexion (Shinn 2023)"]
    B3 --> B3b["Self-Refine (Madaan 2023)"]

    B4 --> B4a["ReAct (Yao 2022)"]
    B4 --> B4b["Function calling / MCP (2023-2024)"]
    B4 --> B4c["Computer use / browser use (2024-2025)"]

    B5 --> B5a["OpenAI o1 (Sep 2024)"]
    B5 --> B5b["OpenAI o3 (Dec 2024)"]
    B5 --> B5c["DeepSeek-R1 (Jan 2025)"]
    B5 --> B5d["Claude / Gemini thinking (2024-2025)"]

Figura 1 — What’s missing for true S2 gap chart: horizontal bars for human S2 100% vs LLM 2026 partial, across 7 dimensions

1. Metacognizione genuina. Un umano sa, in misura calibrata, quando non sa. Un LLM produce “non lo so” come pattern superficiale appreso dal training, non come riflesso di un meta-monitor sul proprio processo. Il lavoro di Saurav Kadavath e colleghi a Anthropic, “Language Models (Mostly) Know What They Know” (arXiv 2207.05221, 2022), suggerisce che esiste una forma di self-prediction calibrata sopra una certa scala — chiedendo al modello “qual è la probabilità che la tua risposta sia corretta?” si ottengono numeri che correlano con l’accuracy effettiva. Ma è una calibrazione fragile, sensibile a phrasing, e non emerge da un modulo dedicato; è un sottoprodotto della scala.

2. Working memory esplicita con central executive. Nel modello di Alan Baddeley (psicologo britannico, 1934-) della working memory umana, ci sono componenti separati: phonological loop, visuospatial sketchpad, episodic buffer, central executive che alloca attivamente attention ai sotto-task. Negli LLM la “working memory” è il KV cache + il context window: una rappresentazione passiva, indicizzata posizionalmente, senza un central executive che decida “ora trattengo questo, scarto quello, processo quel sub-goal”. Sviluppi su agentic memory (capitolo memoria-agentica in preparazione) cercano di colmare il gap a livello di harness.

3. Conflict detection automatica. Wim De Neys (CNRS Paris), con il suo programma “Dual Process 2.0”, ha mostrato che negli umani due intuizioni in S1 che entrano in conflitto producono un segnale (rallentamento, dilatazione pupillare) che mobilita S2 senza bisogno di istruzione esplicita. Negli LLM, conflict detection esiste solo se il prompt lo orchestra (“considera la possibilità che la tua prima risposta sia sbagliata”) o se il harness genera multiple risposte e le compara. Non è automatico nel senso umano.

4. Stop-and-think autonomo senza prompt. I reasoning model 2024-2026 hanno una decisione “thinking on/off” o un budget di token configurabile dall’utente o dal router. Un umano in un task decide momento per momento se rallentare e riflettere, sulla base di segnali interni. Lavori 2024-2026 su “adaptive reasoning” (es. modelli che decidono dinamicamente quando approfondire) sono primi passi, non risposte mature.

5. Affect e cost-of-effort. La fatica cognitiva umana è una risorsa biologica reale e modula la probabilità di attivare deliberation: si è meno propensi a S2 quando stanchi, distratti, sotto pressione. Negli LLM il “costo” è una metrica esterna (token, dollari, latency) gestita dall’harness o dal pricing del provider. Il modello non lo “sente”. Non c’è feedback fisiologico che modula il budget di pensiero.

6. Real-time interruption e re-planning. Un umano in mezzo a un compito può sentire che qualcosa non torna e fermarsi, anche senza completare il pensiero corrente. Gli LLM autoregressivi tipicamente generano fino a un EOS o a un budget esaurito; le interruzioni vanno orchestrate dall’harness (cancellation tokens, timeout, hook che leggono lo stream). È implementabile a livello di runtime, ma non è un comportamento spontaneo del modello.

7. Apprendimento online dalla deliberation. Un umano impara dalle proprie correzioni: la prossima volta che incontra un problema simile, applica la lezione. Un LLM in inferenza non aggiorna i pesi; al massimo aggiorna il context (con Reflexion-like loop) o una memoria esterna (RAG, knowledge graph, file). Memoria persistente long-term richiede architetture esterne; non è una capability nativa del modello.

Queste sette voci non sono una lista di “limiti che saranno presto superati” né una lista di “barriere fondamentali”. Sono semplicemente lo stato dell’arte 2026: dimensioni in cui la deliberation umana è strutturalmente diversa dalla deliberation simulata. Tenerle in mente è il modo per non scivolare dal dire “i reasoning model sono molto utili” al dire “i reasoning model sono S2”.

Trade-off ingegneristici

Ogni meccanismo della mappa ha un costo. Sintesi pratica.

Latency. I reasoning model possono richiedere da decine di secondi a minuti per rispondere. o1 sui problemi AIME impiega minuti. ARC-AGI 2 in modalità o3-high richiede compute distribuito massiccio. Per use case real-time (chatbot conversazionale, voice agent) la latency è proibitiva. La risposta tipica è il routing: query semplici al modello veloce, query hard al modello thinking.

Cost. I thinking token si moltiplicano. Pricing 2025-2026 distingue thinking token da output token; a parità di problema, una soluzione thinking può consumare 10-50 volte i token di una risposta diretta. Su benchmark frontiera (ARC-AGI 2 high-compute) i costi per task arrivano a migliaia di dollari. Non è un trade-off marginale.

Faithfulness (Lanham). Il CoT testuale non sempre coincide con il calcolo interno del modello. Implicazione: la traccia di reasoning non è un’affidabile spiegazione causale della decisione. Per use case dove la spiegabilità è richiesta (medico, legale, audit), va trattata con cautela — non è automaticamente “interpretabilità migliore”.

Correctness vs hallucination. Più CoT non sempre migliora. Su task semplici, un CoT lungo può degradare le performance per “overthinking”. Self-correction senza ground-truth (Huang 2023) può peggiorare risposte corrette. Verifier esterni (test che passano, math con ground-truth) aiutano; senza, la deliberation è meno affidabile.

User experience. Latency vs accuracy. Trasparenza vs noise. Se il thinking trace è esposta, l’utente vede il “ragionamento” e a volte ne è confuso (perché contiene tentativi falliti). Se è nascosta, l’utente attende senza segnali. Ogni provider ha fatto scelte diverse.

Verifiability del task. Test-time compute scaling funziona meglio dove esiste un verifier (math con ground-truth, codice con test, formal proofs). Su task open-ended (writing creativo, advice generale, sintesi) il scaling è meno netto: senza verifier non c’è modo di selezionare il sample migliore senza un human-in-the-loop o un LLM-as-judge (con tutti i limiti del caso).

Pattern operativi: cookbook per chi costruisce sistemi

Mettendo insieme la mappa e i trade-off, ecco sette pattern che ricorrono nei sistemi production 2024-2026.

Routing-based. Un classificatore (spesso un modello piccolo, BERT-like o un LLM-as-router) decide per ogni query se mandarla a un modello veloce o al thinking model. Esempi: “auto/balanced/thorough” mode in Claude, “model selector” in alcuni harness, GPT-5 e altri modelli unificati con thinking-routing interno.

Always-on CoT (cheap). Un system prompt che istruisce il modello a ragionare step-by-step prima di rispondere. Costo basso, miglioramento moderato. Pattern di default in molte applicazioni che non hanno accesso a reasoning model dedicati.

Scratchpad pattern. L’agente mantiene uno scratchpad (TODO list, intermediate state, ipotesi correnti) visibile nel context. Riduce drift su task multi-step lunghi. Implementato a livello di harness (CLAUDE.md, .claude/STATUS.md, working memory file).

Verifier + generator. Generator produce N candidati (CoT diversi, sample diversi); Verifier (PRM, LLM-as-judge, test esterni) seleziona il migliore. È il pattern dietro molti reasoning model in training, e dietro pattern di best-of-N in inferenza.

Multi-step agent harness. Plan → execute → reflect, ripetuto con stopping criterion. ReAct, Reflexion, plan-and-execute pattern. Spesso combinato con tool use.

Compute scaling. Budget configurabile (max thinking tokens), retry-on-fail, ensemble di chain. Esposto come parametro di configurazione in harness production.

Tool delegation. Operazioni precise (aritmetica, query DB, esecuzione codice, ricerca web) delegate a tool affidabili invece che lasciate al modello. Riduce hallucination, aumenta accuracy verificabile, sposta complessità nell’integration.

Un’analogia parziale: model-free vs model-based RL

Una connessione concettuale che merita una sosta è quella fra dual-process e la distinzione model-free / model-based reinforcement learning, già toccata nel cap. 74 nella discussione delle basi neurali.

Nel reinforcement learning, model-free indica algoritmi che imparano una policy o una value function direttamente dall’esperienza (Q-learning, DQN, REINFORCE, PPO senza world model esplicito): non costruiscono una rappresentazione del mondo, imparano cosa funziona per associazione stato-azione-reward. Model-based indica algoritmi che imparano un modello del mondo (transizioni, ricompense future) e poi pianificano contro quel modello (Dyna, MuZero, Dreamer): simulano scenari prima di agire.

L’analogia con S1/S2 è seducente: model-free come pattern matching automatico (S1), model-based come simulazione deliberata (S2). Sam Doll, Nathaniel Daw e Michael Frank, in “Model-based choices involve prospective neural activity” (Nature Neuroscience 2015, citato nel cap. 74), mostrano che striatum è correlato a model-free e dlPFC a model-based — lo stesso substrato neurale che la teoria dual-process associa a S1 e S2.

Per LLM la traduzione è meno netta. Un transformer autoregressivo non è propriamente model-free né model-based nel senso classico del RL. Il pre-training su next-token prediction costruisce una specie di model implicito sul “mondo dei testi”; il fine-tuning RLHF addestra una policy. Quando un agent fa planning con tool, sta facendo model-based reasoning sopra un modello del mondo che è in parte appreso (dal corpus) e in parte fornito dall’environment (osservazioni dei tool).

L’analogia model-free/model-based ↔ S1/S2 è quindi doppiamente analogica: due dicotomie computazionali che condividono struttura ma non sono lo stesso oggetto, e il loro mapping su dual-process humano è esso stesso analogico. È utile come scaffolding pedagogico; non è una identità.

Casi d’uso 2024-2026 dove “S2-like” conta

Dove questi pattern producono valore reale, oggi:

• Math e reasoning benchmark. AIME, MATH, ARC-AGI 2, FrontierMath. o3 high-compute supera l’umano medio su ARC-AGI 2.
• Code generation con verifiable correctness. SWE-bench, HumanEval, MBPP. Reasoning + tool use combinati. Claude Code, Cursor, Aider come harness operativi.
• Strategic planning agent. Long-horizon task multi-step (ricerca, analisi competitiva, pianificazione progetto). Anthropic’s claude.ai con extended thinking, Devin di Cognition, Operator di OpenAI.
• Research synthesis. Lettura di paper, sintesi, generazione di hypothesis. Elicit, Consensus, Scite, e i numerosi research agent del 2025-2026.
• Reasoning medico/legale complesso. Caveat: i benchmark non riflettono pienamente l’edge case clinico/legale reale. Rimane area dove human-in-the-loop è non negoziabile.
• Math olympiad. AlphaProof e AlphaGeometry 2 di DeepMind (2024) hanno raggiunto prestazioni IMO silver medal su un sottoinsieme di problemi.

Esempi concreti: tre traiettorie

Esempio 1: chain-of-thought su un problema GSM8K

Il problema (da GSM8K, leggermente parafrasato):

“Roger ha 5 palline da tennis. Compra 2 lattine di palline da tennis. Ogni lattina contiene 3 palline. Quante palline da tennis ha ora?”

Con standard prompting (zero-shot, “rispondi solo con il numero”):

Q: Roger ha 5 palline da tennis. Compra 2 lattine di palline da tennis. Ogni lattina contiene 3 palline. Quante palline da tennis ha ora? A: 11

Su un problema così semplice il modello azzecca. Ma su una variante più lunga (“Marco ha 17 mele. Ne regala 5 al fratello, poi compra al mercato 3 sacchetti, ognuno da 6 mele, e nel tornare a casa ne perde 2. Quante mele ha ora?”) un modello piccolo zero-shot tipicamente sbaglia, sommando i numeri in ordine senza gestire correttamente il segno.

Con CoT few-shot (Wei 2022):

Q: Marco ha 17 mele. Ne regala 5 al fratello, poi compra al mercato 3 sacchetti, ognuno da 6 mele, e nel tornare a casa ne perde 2. Quante mele ha ora? A: Marco parte con 17 mele. Regala 5 mele, quindi gliene restano 17 − 5 = 12. Compra 3 sacchetti da 6 mele, cioè 3 × 6 = 18 mele in più, quindi ha 12 + 18 = 30. Ne perde 2, quindi 30 − 2 = 28. Risposta: 28.

Cosa è cambiato? Il prompt few-shot ha condizionato il modello a generare prima passi intermedi e poi la risposta. Il calcolo si distribuisce su più token; ogni passo è condizionato dai precedenti. La probabilità di emettere “28” come token finale è più alta dopo aver emesso “30 − 2 =” che dopo aver emesso direttamente “Risposta:”. Il meccanismo è autoregressione, e il prompting trasforma lo spazio di output verso traiettorie più strutturate.

Funzionalmente assomiglia a “pensare prima di rispondere”. Meccanicamente è “more tokens before the final token”. Le due descrizioni non sono in conflitto, ma vivono a livelli diversi.

Esempio 2: o1 reasoning trace su un puzzle

Domanda: “Trova due primi positivi p e q (con p ≤ q) tali che p² + q² sia anch’esso primo.”

Risposta di un modello senza thinking, in due secondi: “p = 5, q = 7, perché 25 + 49 = 74 = 2 · 37, primo.” (Sbagliato: 74 non è primo.)

Risposta di o1 con thinking, dopo 18 secondi:

[Thinking] Devo trovare primi p, q con p² + q² primo. Considero la parità. Se p e q sono entrambi dispari, p² + q² è pari e maggiore di 2, quindi non primo. L’unico primo pari è 2. Quindi almeno uno fra p, q deve essere 2. Provo p = 2. q² + 4 deve essere primo. q = 2: 4 + 4 = 8, non primo. q = 3: 9 + 4 = 13, primo. Bingo. Verifica: 13 è primo. Sì. [/Thinking]

Risposta: p = 2, q = 3, perché 2² + 3² = 4 + 9 = 13, che è primo.

Il modello ha fatto un’osservazione strutturale (parità) prima di provare casi. Ha ridotto lo spazio di ricerca. Ha verificato. È il tipo di mossa che, in un umano, attribuiremmo a S2.

Cosa è successo dentro la macchina? Durante il training RL, il modello è stato premiato per traiettorie che esploravano e si correggevano; ha imparato a generare token di “thinking” che strutturano il problema prima di committarsi. Non c’è un “secondo modulo” che si è acceso; c’è una policy autoregressiva che, in distribuzione, produce traiettorie più lunghe e più strutturate quando il problema lo richiede. L’effetto è simile a deliberation; il meccanismo è distillazione di pattern di reasoning nel modello base.

Importante: non sempre funziona. Su domande triviali (“capitale della Francia”) il thinking è uno spreco. Su domande mal poste (“dimostra che 1 = 2”) il modello può produrre lunghissime trace plausibili che concludono assurdità. La deliberation simulata non garantisce la correttezza, garantisce una distribuzione più favorevole su task strutturati.

Esempio 3: ReAct loop di un agent con tool

Task: “Quanti anni avrà l’attuale presidente francese alla fine del 2026?”

Trace di un agent ReAct con tool web_search e tool calculator:

Thought: Devo prima identificare l'attuale presidente francese, poi trovare la sua data di nascita, poi calcolare l'età a fine 2026.
Action: web_search(query="attuale presidente francese 2026")
Observation: "Emmanuel Macron, in carica dal 14 maggio 2017, rieletto nel 2022."

Thought: Ottimo. Ora cerco la data di nascita di Macron.
Action: web_search(query="Emmanuel Macron data di nascita")
Observation: "Emmanuel Jean-Michel Frédéric Macron, nato il 21 dicembre 1977 ad Amiens."

Thought: Macron è nato il 21 dicembre 1977. A fine 2026 (31 dicembre 2026) avrà compiuto 49 anni il 21 dicembre 2026. Verifico con calculator.
Action: calculator("2026 - 1977")
Observation: 49

Thought: A fine 2026 Macron avrà 49 anni (compiuti il 21 dicembre 2026).
Final answer: 49 anni.

Cosa è successo? Il modello da solo, senza tool, avrebbe rischiato hallucination (date sbagliate, presidente sbagliato per via del knowledge cutoff). Con tool, ha fatto un loop esplicito: pianifica passi, delega operazioni precise (search, aritmetica) a tool affidabili, integra i risultati nel context, conclude. Funzionalmente è il pattern “perception-cognition-action” classico; meccanicamente è autoregressione + chiamate a function esterne orchestrate dall’harness.

Il fatto che la “perception” sia testuale (Observation come stringa) e che “action” sia un JSON di tool call, e non un comportamento motorio, non cambia la struttura. ReAct è il modo in cui un LLM partecipa a un loop deliberativo che vive in parte dentro il modello (Thought) e in parte fuori (Action, Observation). Per il ponte: l’agente è un’architettura distribuita in cui la deliberation è il prodotto di componenti che includono il modello ma non si esauriscono in esso.

flowchart LR
    UT["Task utente"] --> T["Thought (LLM)"]
    T --> A["Action: tool_call(args)"]
    A --> O["Observation: tool_result"]
    O --> T
    T -.->|criterio di stop| F["Risposta finale"]

Figura 3 — ciclo Thought → Action(tool_call) → Observation → Thought come loop esplicito ReAct, con il criterio di stop verso la final answer

Dove si rompe

Il quadro che ho costruito è ottimistico nelle parti operative e cauto nelle parti concettuali. Ma ci sono punti dove i meccanismi descritti rompono in modo importante.

CoT non sempre migliora. Su task semplici, CoT può degradare le performance: il modello “overthink”, introduce passi spuri, finisce in una risposta sbagliata. La regola empirica è: CoT aiuta su task multi-step strutturati; non aiuta o danneggia su task one-shot lookup.

Faithful chain-of-thought non garantita (Lanham 2023). Il CoT esplicitato è una rationalizzazione, non una spiegazione causale del calcolo interno. Per use case dove è richiesta interpretabilità (medico, legale, auditing) questa è una limitazione importante: vedere la “reasoning trace” del modello non equivale a vedere il suo ragionamento.

Self-correction senza ancoraggio peggiora (Huang 2023). Loop di self-refine senza ground-truth o verifier esterno tendono ad andare alla deriva: il modello sostituisce risposte corrette con risposte sbagliate “più articolate”. È un bug fondamentale dei pattern “lascia che il modello si critichi” che molti sviluppatori scoprono in produzione.

Reasoning model possono “razionalizzare”. Il problema dei trial cognitivi del cap. 74 (anchoring nei giudizi giudiziari, Linda problem nei laureati) si ripresenta in forma analoga negli LLM: una reasoning trace lunga e fluente non è garanzia di correttezza. Può essere una bella ricostruzione plausibile di una risposta sbagliata.

Test-time compute non è infinitamente scalabile. Le curve hanno diminishing returns, e su task molto difficili scaling solo del compute non basta — serve un modello più capace (Snell 2024). Inoltre il costo cresce drasticamente: ARC-AGI 2 high-compute è una dimostrazione affascinante ma non un pattern operativo a basso costo.

La metafora “S2” diventa fuorviante se reificata. Sentir parlare di “il sistema 2 dell’LLM” come se fosse un sotto-modulo dedicato confonde il pubblico, gli ingegneri, e talvolta gli stessi ricercatori. È un’analogia retorica utile per esposizione; trattata come architettura reale produce attese sbagliate (es. “se ha S2, allora si auto-correggerà”; falso, vedi sopra). Il rischio peggiore è di policy: se il pubblico crede che i modelli “deliberano come noi”, rischia di sovra-affidarsi a output che restano probabilistici.

Working memory limitata dal context window. Il context window è un’approssimazione povera di working memory umana. Lost-in-the-middle (Liu et al. 2023): informazioni nel mezzo di un context lungo vengono attenuate. Position bias. Attention sinks. La capacità di “trattenere e manipolare” informazione attivamente non è equivalente a quella di un central executive.

Catena agent fragile su orizzonti lunghi. Un agent che fa 50 step con tool ha una probabilità di errore composita non banale. Un singolo errore (parsing, tool call malformato, observation male interpretata) può deragliare l’intera traiettoria. La robustezza richiede checkpointing, retry, recovery — capability di harness, non del modello.

Verifier-dependence dei reasoning model. Il salto di capability di o1, o3, DeepSeek-R1 deriva in larga parte da RLVR — RL con reward verificabili. Math con ground-truth, codice con test che passano. Su domini senza verifier deterministico (writing, advice, sintesi creativa) il salto è meno marcato. Implicazione pratica: nel 2026 i reasoning model sono sproporzionatamente forti su domini formali e meno sproporzionatamente forti su domini fuzzy. Il dibattito su come estendere RLVR a domini soft (RL with non-verifiable rewards, RL con LLM-judge come surrogate verifier) è uno dei filoni più attivi di ricerca.

Reward hacking e gaming dei verifier. Quando il training premia “passare i test”, il modello impara talvolta a “passare i test in modi non desiderati”: casi noti includono soluzioni che riconoscono pattern superficiali nei test invece di risolvere il problema generale, oppure traiettorie che sembrano corrette ma in realtà fanno match su shortcut. È un’istanza ben nota di reward hacking nella letteratura RL, e per i reasoning model si manifesta come “il modello impara a sembrare deliberativo senza esserlo”. Costruire suite di test robuste e diversificate è parte essenziale del problema.

Limiti del context window. I reasoning model con thinking mode consumano context window per la traccia interna. Se il task ha già un context lungo (lettura di un PDF di 50 pagine, codebase ampia), il budget di thinking si scontra con il budget di input. Architetture con context separati per “thinking pad” e “input data” sono in sviluppo, ma non sono lo standard 2026.

Una nota sui benchmark e sulla loro evoluzione

Vale la pena spendere due paragrafi sull’evoluzione dei benchmark di reasoning, perché lo stato del 2026 è il prodotto di una corsa fra modelli e benchmark.

Negli anni 2020-2022, GSM8K e MATH (Hendrycks et al. 2021) erano i benchmark standard per il reasoning matematico. PaLM e GPT-3.5 li trovavano ancora difficili. Con CoT prompting e modelli più grandi (GPT-4, Claude 3.5) GSM8K è arrivato saturare al 95%+ accuracy, rendendolo non più discriminante. Si sono cercati benchmark più hard: AIME (problemi da competizione liceale), Putnam (competizione universitaria), FrontierMath (Glazer et al. 2024, problemi di livello dottorato in matematica).

Per il reasoning non-matematico la traiettoria è simile. ARC (Chollet 2019) è stato pensato per testare reasoning analogico astratto e per anni è rimasto resistente al deep learning standard. ARC-AGI 2 (2024) ha alzato l’asticella ulteriormente. La performance di o3 high-compute su ARC-AGI 2 al 2024 è uno dei segnali tecnici più forti del 2024-2025, ed è specificamente legata ai meccanismi descritti in questo capitolo.

Lo stato del dibattito 2026

A inizio 2026 il dibattito sull’identificazione fra reasoning capability degli LLM e dual-process humano si è polarizzato in tre posizioni.

La prima è la posizione continuista forte: i reasoning model sono primi esempi di un sistema 2 ingegneristico, e con scaling sufficiente convergeranno verso capability paragonabili a quelle umane. Sostenitori: parte degli annunci dei lab industriali che enfatizzano i nuovi modelli; commentatori ottimisti su AGI timelines.

La seconda è la posizione distinzionista forte: gli LLM sono fundamentally diversi dal cognitivo umano. La metafora S1/S2 è fuorviante; quello che chiamiamo “thinking” è solo more tokens, e nessun ammontare di scaling produrrà metacognizione, conflict detection automatico, working memory genuina. Sostenitori: Yann LeCun nelle sue esposizioni più dirette; vari ricercatori in cogsci che studiano le differenze.

La terza, che è anche la posizione di questo capitolo, è funzionalista cauta: i reasoning model producono comportamenti utili che imitano deliberation in modo funzionalmente significativo, e questo basta a giustificare l’uso pragmatico del vocabolario; ma reificare la metafora è un errore categoriale. Le sette dimensioni mancanti elencate sopra non sono “barriere fondamentali per sempre” né “limitazioni temporanee in via di soluzione” — sono lo stato dell’arte 2026, e possono evolvere o non evolvere a seconda di traiettorie tecniche e di ricerca che oggi non sono determinate.

Tre domande ricorrenti

In tre anni di conversazioni pubbliche su questo tema sono emerse tre domande che meritano risposta esplicita.

“Se il CoT è solo more tokens, perché funziona così bene?” Perché il transformer è un modello sequenziale e ogni token di output è condizionato sull’intera sequenza precedente. Quando il prompt induce passi intermedi, il calcolo che il modello deve fare per produrre il token finale è distribuito su molti forward pass intermedi. Un singolo token di risposta diretta richiede di “comprimere” il ragionamento in un singolo step di attention; molti token di CoT permettono di srotolare il ragionamento in step piccoli, ognuno dei quali è più semplice. È simile, in spirito, al motivo per cui gli umani fanno calcoli a mente meglio se li scrivono. Non è “deliberation” nel senso cognitivo; è un cambio di formato che riduce la difficoltà computazionale di ogni singolo step.

“o1 e DeepSeek-R1 sono qualitativamente diversi da un Claude o GPT-4 con CoT?” Sì e no. Sì nel senso che il training RL su reasoning trace plasma il modello a generare traiettorie più strutturate, più auto-correttive, più “esploratorie” di quanto un modello base con prompting CoT farebbe spontaneamente. Su benchmark hard (AIME, GPQA, ARC-AGI 2) il salto di performance è marcato, non incrementale. No nel senso che la macchina sotto è la stessa: un transformer che fa next-token prediction. Il salto di capability sta nella distribuzione dei pattern di output, non in un’architettura nuova. È una distinzione che conta quando si discute “questo è davvero un sistema 2?”: no, non lo è, ma è una distribuzione di output autoregressivi più favorevole di quella del modello base.

“Allora dovrei sempre usare il modello thinking?” No. Latency e cost sono reali. Per query semplici (lookup, traduzione, scrittura standard) un modello veloce è più appropriato. Per task hard con verifier esterno (math, codice con test, planning long-horizon) il thinking può fare la differenza fra successo e fallimento. La risposta sensata è il routing: classificare la query e allocare il budget di compute conseguente. Per applicazioni production il routing-based pattern è quasi sempre il miglior compromesso.

Collegamenti

• dual-process-kahneman — il capitolo precedente. Tutto il vocabolario di S1/S2, le critiche di Melnikoff-Bargh e Keren-Schul, la distinzione fra analogia retorica e filiazione documentata. Premesse di questo capitolo.

• memoria-working — il modello di Baddeley fornisce la cornice per capire perché il KV cache + context window è un’approssimazione povera di working memory umana, e perché il “central executive” è una capability che gli agent harness cercano di approssimare a livello di runtime.

• attenzione-psicologia — la rete di executive control (ACC + dlPFC) come substrato di S2 umano; l’attention nei transformer è un’altra cosa nonostante il nome condiviso. Il ponte attenzione-transformer è trattato in ponte-attenzione-transformer.

• bounded-rationality-simon (in preparazione) — Herbert Simon 1955 e bounded rationality come cornice teorica generale; il successivo ponte-bounded-rationality-ttc (in preparazione) collega specificamente al test-time compute.

• meta-cognizione (in preparazione) — la metacognizione umana e il suo controesempio negli LLM (calibrazione fragile); ponte-metacognizione-self-correction (in preparazione) entra nel dettaglio di self-correction agentico.

• cot-intro (in preparazione, Parte XII) — meccanica completa del chain-of-thought, varianti, paper di Wei e Kojima in dettaglio. Qui descritto come famiglia, lì come capitolo.

• test-time-scaling (in preparazione, Parte XII) — reasoning model (o1, o3, DeepSeek-R1) e scaling del compute al test time. Qui ne descrivo l’effetto-ponte; lì la meccanica RL dettagliata.

• tot-got (in preparazione, Parte XII) — Tree of Thoughts e Graph of Thoughts in dettaglio.

• reflexion (in preparazione, Parte XII) — pattern di self-reflection meccanica.

• react (in preparazione, Parte XVI) — il pattern ReAct come fondamento degli agent moderni.

• tool-use-fondamenti (in preparazione, Parte XVI) — function calling, schemas, design pattern. Qui menzionato; lì in dettaglio.

• mcp-introduzione (in preparazione, Parte XVI) — Model Context Protocol come standard. Qui come pezzo della famiglia agent-loop; lì in dettaglio architetturale.

• agente-definizione (in preparazione, Parte XVI) — definizione operativa di agente. Questo capitolo ne anticipa alcuni aspetti.

• harness-definizione (in preparazione, Parte XVII) — il runtime attorno al modello, dove molti dei pattern operativi descritti qui vivono.

Per andare oltre

• Wei, J., et al. (2022). “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models”. NeurIPS 2022. Il paper fondativo. Lettura obbligata se si vuole capire da dove parte la conversazione tecnica.

• DeepSeek-AI (2025). “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning”. arXiv:2501.12948. Per chi vuole capire come si addestra un reasoning model con open weights. Il paper più trasparente del filone.

• Snell, C., et al. (2024). “Scaling LLM Test-Time Compute Optimally”. arXiv:2408.03314. La cornice teorica per pensare in modo principled allo scaling del test-time compute. Tradeoff parameter-vs-compute resi quantitativi.

• Lanham, T., et al. (Anthropic, 2023). “Measuring Faithfulness in Chain-of-Thought Reasoning”. arXiv:2307.13702. Per il caveat fondamentale: la traccia esplicitata non sempre riflette il calcolo. Lettura obbligata per chi pensa che il CoT sia spiegazione.

• Yao, S., et al. (2022). “ReAct: Synergizing Reasoning and Acting in Language Models”. ICLR 2023. Il paper che ha definito il pattern fondamentale per gli agent moderni. Oltre alle metriche, leggere gli appendici con esempi di trace.

• Bengio, Y. (2021). “From System 1 Deep Learning to System 2 Deep Learning: An Overview”. Per la posizione esplicita di chi usa la metafora S1/S2 come programma di ricerca. Va letta sapendo che è proposta, non descrizione di realizzazione.

• Huang, J., et al. (2023). “Large Language Models Cannot Self-Correct Reasoning Yet”. arXiv:2310.01798. Per il contraltare onesto: cosa NON funziona nel pattern self-correction puro. Da leggere insieme a Reflexion e Self-Refine per avere il quadro completo.

Implicazioni per chi disegna prodotti

Sintesi pratica per chi costruisce applicazioni con LLM, organizzata su tre livelli.

A livello di interaction design: la scelta fra modello veloce e modello thinking è una scelta che impatta UX. Latency oltre i 10-15 secondi senza feedback visibile è una rottura di contratto con l’utente. Le implementazioni mature mostrano la traccia di thinking (anche se parzialmente) o usano placeholder progressivi. Un’applicazione che fa attendere l’utente 60 secondi senza feedback è progettata male, indipendentemente da quanto sia accurata la risposta finale.

A livello di system design: il routing è il pattern dominante. Una query semplice non deve pagare il costo di thinking, una query difficile non deve essere troncata. Il classificatore di routing è esso stesso un componente che va testato, monitorato, versionato. Errori di routing (query difficile mandata a modello veloce, query banale mandata a modello thinking) sono failure mode comuni in produzione.

A livello di trust and safety: la traccia di reasoning, anche quando esposta, non è automaticamente una spiegazione affidabile. Un agente che mostra una bella reasoning trace e poi sbaglia è più pericoloso di un agente che sbaglia senza spiegarsi, perché induce sovra-fiducia. Per use case critici (medico, legale, finanziario) la traccia va trattata come un input ulteriore alla supervisione umana, non come garanzia. Questo è uno dei punti dove la metafora S2 è più rischiosa: induce a credere che “sta deliberando seriamente” quando in realtà sta producendo testo plausibile.

Una nota sull’igiene concettuale

Il rischio specifico di questo capitolo, dichiarato in apertura e che ribadisco in chiusura, è la reificazione della metafora S1/S2 in due “moduli” dell’LLM. Non c’è un modulo S1 e un modulo S2 nei sistemi descritti. Ci sono pattern di prompting, training procedures, harness orchestrations che producono effetti funzionalmente simili a quello che la psicologia chiama deliberation. Le classi di affermazione corrette per i collegamenti di questo capitolo sono:

• Analogia funzionale: CoT, reasoning model, agent loop con tool producono output che assomigliano a deliberation umana. Stessa famiglia di effetti, oggetti diversi.
• Filiazione assente: nessuno dei meccanismi è stato progettato come implementazione della teoria di Kahneman. Bengio 2019 cita Kahneman come metafora, non come blueprint. Wei 2022 non cita dual-process. o1 non cita dual-process. La filiazione è assente per design.
• Equivalenza pericolosa: dire “CoT = sistema 2” o “o1 = sistema 2” è un errore categoriale che produce attese sbagliate.
• Pattern ingegneristici: routing, scratchpad, verifier+generator, ReAct, MCP sono soluzioni operative, non teorie cognitive. Hanno valore pragmatico misurabile (benchmark, latency, cost), non valore di rappresentazione cognitiva.

L’utilità del vocabolario S1/S2 in questo dominio è duplice. Permette di parlare a un pubblico misto (psicologi cognitivi, ML researcher, sviluppatori) con un riferimento condiviso. E suggerisce direzioni di ricerca: “cosa servirebbe per avvicinare la deliberation simulata alla deliberation umana?” è una domanda produttiva, e la lista delle sette dimensioni mancanti è la sua versione operativa.

Tenere il vocabolario, e disciplinare il suo uso. È la stessa raccomandazione che il cap. 74 ha fatto per la psicologia umana: parlare di regimi, non di agenti separati. Per gli LLM la traduzione è: parlare di pattern operativi, non di moduli cognitivi. La differenza non è retorica. È la differenza fra capire cosa sta succedendo nel sistema che si sta usando e proiettarvi un’immagine antropomorfa che il sistema non sostiene.

L’utente che, all’inizio del capitolo, ha visto Claude thinking impiegare quaranta secondi per verificare una decomposizione in somma di quadrati ha avuto un’esperienza utile e impressionante. Il modello ha esplorato, si è corretto, ha concluso. Il valore operativo è reale. Il fatto che, sotto il cofano, si tratti di autoregressione su una traccia più lunga prodotta da una policy addestrata via RL non sminuisce il valore. Sposta solo il piano di analisi dal cognitivo all’ingegneristico — che è il piano in cui chi costruisce sistemi deve abitare.

Per chiudere con il punto operativo: questa wiki ha capitoli dedicati ai singoli meccanismi (cot-intro, test-time-scaling, tot-got, reflexion, react, tool-use-fondamenti, mcp-introduzione) che entrano nei dettagli tecnici di ogni famiglia. Questo capitolo è ponte, non riferimento esaustivo. Il suo lavoro è mettere in dialogo la psicologia cognitiva del cap. 74 con l’ingegneria dei sistemi LLM, e chiarire una volta per tutte che il vocabolario condiviso è uno strumento, non una mappa ontologica. Da qui in poi la wiki entra nella meccanica di ogni famiglia con lo spazio che merita; il ponte regge se chi lo attraversa sa che cosa sta attraversando.