🧙 Maestro Yoda Cap. 22 · Agenti, tool use, RAG

Puntata 235

Puntata 235 — Cos’è un agente AI

Livello: 🧙 Maestro Yoda · Capitolo 22 · Agenti, tool use, RAG

Nel 2026 ogni due settimane nasce un nuovo “AI agent framework”. Quasi tutti dicono la stessa cosa con parole diverse. Per capirli serve una definizione tecnica solida, non una buzzword. Spoiler: un agente è un LLM in un loop. Il resto è ornamento.

un cervello stilizzato che ascolta (input), pensa (LLM in mezzo), agisce (mani che premono pulsanti, scrivono file, chiamano API), e ricomincia ad ascoltare. Sotto: “perception → reasoning → action → perception. Loop. Per sempre, fino a stop condition”

La definizione tecnica

Un agente AI è un sistema che:

  1. Riceve un goal (in linguaggio naturale).
  2. Decide autonomamente la sequenza di azioni da fare per raggiungerlo.
  3. Esegue le azioni interagendo con un ambiente (filesystem, API, browser, codice).
  4. Osserva i risultati e adatta il piano.
  5. Termina quando il goal è raggiunto (o quando capisce di non farcela).

La differenza chiave con “uno script che chiama un LLM”: le azioni non sono predeterminate. Le sceglie l’LLM step-by-step in base allo stato corrente.

Una formulazione formale è il loop perception-action, ereditato dalla classica AI di Russell & Norvig:

while not done:
    observation = perceive(environment)
    action      = llm.decide(goal, history, observation, tools)
    result      = execute(action, environment)
    history.append((observation, action, result))
    done        = is_goal_reached(goal, history)

L’LLM è il cervello del loop. I tool sono le mani. Lo storico è la memoria. L’ambiente è il mondo.

Le 4 componenti di un agente moderno

1. LLM (Brain)

Un modello capace di:

  • Ragionamento (anche multi-step).
  • Tool use / function calling (vedi puntata 236).
  • Output strutturato (JSON, function names, params).

Modelli adatti nel 2026: GPT-5, Claude 4.x, Gemini 2.5+, DeepSeek-R1, Qwen 3, Llama 4. Modelli piccoli (≤7B) soffrono in loop agentici lunghi (perdono coerenza dopo 5-10 step).

2. Tools (Hands)

Funzioni richiamabili dall’agente. Ognuna è descritta con:

  • Nome (search_web, read_file, run_python).
  • Descrizione (cosa fa, quando usarla).
  • Schema (parametri di input, tipi, required).
  • Implementazione (codice che esegue quando chiamata).

Stesso pattern di un’API HTTP, dichiarativo. Vedi puntata 236 per dettagli.

3. Memory (Memoria)

Storico delle interazioni. Si divide in:

  • Short-term: la conversazione corrente (entro context window).
  • Long-term: persistente tra session, archiviata in DB o RAG (vedi puntate 238, 272).
  • Working: stato intermedio del piano (es. file aperto, variabile calcolata).

4. Environment (Mondo)

Cosa l’agente può toccare:

  • File system (read/write file).
  • Shell (eseguire comandi).
  • Browser (navigare web — vedi puntata 244).
  • API (HTTP, database, servizi cloud).
  • Codice (Python REPL, sandbox).
  • Sé stesso (sub-agenti, vedi puntata 243).

Più l’environment è ampio, più potente l’agente. Più rischioso anche (vedi puntata 247 prompt injection).

La taxonomia degli “agenti” 2026

Non tutti gli “agenti” sono uguali. Quattro livelli di autonomia:

Livello 0 — Chatbot

Single LLM call, no tool, no loop. “ChatGPT base”. Non è un agente.

Livello 1 — Chatbot con tool

LLM + 1-3 tool, può chiamarne uno per request. Es. ChatGPT con web_search. Loop di 1-2 step max.

Livello 2 — Workflow agent

Pipeline fissa con LLM in punti chiave. Es. classifica documento → estrai entità → crea record. Sequenza determinata dall’umano, LLM esegue task isolati.

Livello 3 — Reactive agent

LLM decide cosa fare ogni step in base a observation. Loop ReAct (puntata 237) tipico. Es. “trova il prezzo di X su Amazon e su eBay” → l’agente decide se fare 1 o 5 search.

Livello 4 — Autonomous agent

LLM pianifica goal complessi multi-step, decompone in sub-goal, esegue per minuti/ore senza intervento umano. Es. Claude Code, Devin, AutoGPT-derivati. Stato dell’arte 2026 ma ancora fragile.

Livello 5 — Multi-agent system

Multipli agenti coordinati da supervisori, specializzati per dominio (vedi puntata 243). Es. ChatDev, MetaGPT, CrewAI architectures.

La narrativa “agentic AI” del 2024-26 spinge verso livello 3-4 ma la maggior parte degli use case business è a livello 1-2.

Il ciclo di vita di una request agentica

Esempio: “Trova le 3 PMI tessili in Toscana con migliore review su Google e mandami un’email con tabella.”

Step interni di un agente reactive (livello 3):

  1. Plan: “Devo (a) cercare PMI tessili Toscana, (b) filtrare per review, (c) preparare tabella, (d) inviare email.”
  2. Tool call: web_search("PMI tessili Toscana migliore review Google").
  3. Observation: ricevuto lista di 12 candidate.
  4. Tool call: fetch_url("https://google.com/maps/...") per ognuna delle prime 5.
  5. Observation: estratte review (4.7, 4.8, 4.6, 4.5, 4.4 stelle).
  6. Reasoning: top 3 sono X, Y, Z.
  7. Tool call: send_email(to="tu@tu.it", subject="...", body=table_html).
  8. Observation: 200 OK.
  9. Done.

Step espliciti: 5 chiamate tool. Sotto il cofano: ~10-20 LLM calls per coordinarli, ognuna con un context che cresce.

Cosa va bene fare con un agente

Use case che funzionano (in ordine di affidabilità):

  1. Code generation iterativo (Claude Code, Cursor, Devin) — l’ambiente (filesystem, compiler, test) dà feedback chiaro.
  2. Information retrieval multi-step (Perplexity Deep Research, ChatGPT Atlas) — search + sintesi.
  3. Data extraction da documenti strutturati — RAG + tool use (vedi 246).
  4. Workflow di customer support — classificazione + lookup + risposta + escalation.
  5. Automazione di task ripetitivi con interfacce stabili — fatturazione, ticket management.

Cosa va male fare con un agente

Use case fragili (in ordine di rischio):

  1. Transazioni finanziarie autonome — un errore = perdita di denaro.
  2. Comunicazioni esterne non supervisionate — un email sbagliato = danno reputazione.
  3. Modifiche destrutture senza rollback — agenti che cancellano file/DB.
  4. Browser agents su siti complessi — ogni cambio CSS = workflow rotto.
  5. Negotiation con umani non avvisati — manca il consenso informato.

Per tutti questi: human-in-the-loop obbligatorio — l’agente prepara, l’umano approva.

Perché gli agenti sono difficili (la realtà 2026)

3 problemi strutturali aperti:

a) Compounding errors

Se ogni step ha 95% di accuracy, dopo 10 step la probabilità di successo è 0.95^10 ≈ 60%. Dopo 20 step: 36%. Quasi tutti gli agent reali non superano i 5-10 step senza human intervention.

b) Context window exhaustion

Loop lunghi accumulano observation grandi (HTML scraped, file contents, JSON di API). Il context arriva a 100k+ token rapidamente, costando soldi e degradando il reasoning.

c) Reward specification

“Quando ti puoi fermare?” è difficile da formalizzare. Agenti possono o terminare presto (goal non raggiunto) o non terminare mai (loop infiniti).

Tutti e tre sono attivi temi di ricerca. Mitigazioni pratiche:

  • Verification step espliciti (controlla che hai fatto la cosa giusta).
  • Memory compression (riassumi context vecchio).
  • Max iteration cap (forza stop dopo N step).
  • Self-critique (l’agente valuta se ha completato).

Framework popolari 2026

  • LangGraph (LangChain) — graph-based, primitive per controllo flusso esplicito. Standard de facto per agenti production.
  • CrewAI — multi-agent con ruoli (“researcher”, “writer”, “critic”). Espressivo ma a volte over-engineered.
  • AutoGen (Microsoft) — multi-agent conversation-based, ricerca-oriented.
  • OpenAI Agents SDK — primitive ufficiali OpenAI, integrate con Responses API.
  • Anthropic Claude Agent SDK — primitivi Anthropic.
  • Smolagents (HuggingFace) — minimale, agenti che generano e eseguono codice.
  • PydanticAI — type-safe, validation-first.
  • MCP (puntata 242) — non un framework ma un protocollo per esporre tool.

Pattern 2026: il framework è meno importante della disciplina del prompt + tool design + eval. Cambiare framework non risolve un agente progettato male.

Glossario lampo

  • Perception-action loop — pattern classico AI in cui l’agente alterna osservazione dell’ambiente e azione.
  • Compounding errors — degradazione della success probability con il numero di step in un loop agentico.
  • Reactive vs autonomous agent — il primo decide step-by-step in base a observation, il secondo pianifica long-horizon.
  • Human-in-the-loop (HITL) — pattern in cui un umano approva o corregge step critici dell’agente.
  • Agent framework — libreria che fornisce primitive per definire tool, loop, memory, multi-agent. LangGraph, CrewAI, AutoGen i più noti.

Take-away

Un agente AI è “un LLM in un loop con tool”. La definizione è semplice. Costruirne uno che funzioni davvero per 30 step di fila è ancora un problema aperto nel 2026. La maggior parte dei “successi” agentici sono stretti (livello 1-2): tool ben definiti, loop corto, supervisione umana. Diffida di chi vende “agenti autonomi enterprise-ready” — è ancora ricerca attiva, non commodity.

➡️ Prossima puntata: tool use e function calling — il meccanismo fondamentale degli agenti.