Strumenti, agenti e protocolli: Claude Code, Codex, MCP e tutto quello che uso ogni giorno.
Chiudo il terminale a metà refactor e il giorno dopo *Codex CLI* ha dimenticato tutto? No: ogni conversazione è una **sessione** salvata su disco come file *JSONL*, e con **codex resume** la riapro esattamente dov'ero. ==Non riparto mai da zero==: vedo il picker interattivo, la scorciatoia *--last*, la ripresa per nome o ID, il fork per sperimentare senza rompere l'originale e la variante *exec resume* per gli script.
Un **output style** cambia *come* Claude Code risponde, non cosa sa: riscrive il *system prompt* e vale a ogni turno. Guardo i quattro stili integrati — Default, Proactive, Explanatory, Learning — e come ne scrivo uno mio in un file markdown. Poi le due cose su cui quasi tutte le guide in giro sono ferme al 2025: ==il comando /output-style non esiste più, si passa da /config==, e senza *keep-coding-instructions* il mio stile custom spegne le istruzioni di software engineering di Claude.
Se ti sei già connesso qualche **server MCP** esistente e ora vuoi ==scrivere il tuo==, questa è la guida che avrei voluto trovare io. Ti mostro cos'è davvero un server MCP dentro, come lo tiro su in **Python con FastMCP**, come espongo il primo *tool* e come lo aggancio a un sistema interno reale — con un occhio serio a **sicurezza** e a cosa ==NON== va mai esposto.
Nel pezzo su *--full-auto* ho raccontato la sandbox; qui giro l'altra manopola: la **approval policy**, cioè quando Codex si ferma a chiedermi il permesso prima di agire. I tre valori — *untrusted*, *on-request*, *never* — sembrano autoesplicativi ma non lo sono: *untrusted* esegue da solo ==solo le letture note come sicure==, e *never* non spegne affatto la sandbox. In più vedo le due opzioni che le guide veloci saltano: la policy granulare per categorie e l'Auto-review, che fa valutare le richieste a un revisore automatico invece che a me.
Apro *Claude Code* in un progetto e mi tocca rispiegare ogni volta struttura, comandi e convenzioni? No: quello che direi a voce lo scrivo una volta in un file **CLAUDE.md**, che l'assistente legge all'inizio di ogni sessione. ==Non è configurazione che vincola, è contesto che guida==: vedo dove vivono i file nella gerarchia della memoria, come scrivo istruzioni che vengono davvero seguite, come importo altri file con *@path* e come genero e verifico tutto con */init*, */memory* e */context*.
**Record a Skill** è il nuovo modo di insegnare un flusso a *Claude Cowork* nell'app desktop: dal menu **+** del compositore avvii la registrazione, esegui il compito una volta mentre racconti *cosa* stai facendo e *perché*, e Claude trasforma la dimostrazione in una ==skill== riutilizzabile da richiamare poi con uno slash command. In questo articolo percorro tutto il flusso dall'inizio alla fine — dov'è il pulsante, cosa costruisce Claude nel momento in cui premi stop, cosa ottieni davvero (una semplice SKILL.md), come la riesegui e quali flussi vale la pena registrare e quali no.
Il flag *--full-auto* di Codex CLI è la scorciatoia che tutti imparano per prima: niente richieste di approvazione e scritture confinate al repository. Ma sotto c'è di più: **--full-auto forza la sandbox a workspace-write** e vince perfino sul flag *--sandbox* passato accanto, e su *codex exec* oggi è ==un percorso deprecato di compatibilità== che stampa un warning. Vedo cosa combina davvero, come funziona la sandbox nei tre modi disponibili, e la coppia di flag espliciti che uso al suo posto.
**OpenCode** è l'agente di coding open source che gira nel terminale e parla con ==75+ provider==: Claude, Codex, Copilot e persino Ollama in locale. In questo tutorial lo installo, lo configuro con un opencode.json multi-modello e poi faccio il passo in più: lo trasformo in un'API HTTP e lo invoco da una **Minimal API .NET 9** con Refit. Gli snippet .NET sono verificati con build e test automatici.
Gli agenti CLI sono ottimi a consumare token, molto meno a fermarsi da soli. Sia **Codex CLI** sia **Claude Code** oggi hanno leve concrete per mettere un tetto ai consumi: il comando ==/goal con token budget== e il *rollout_budget* in **config.toml** da una parte, ==/usage, /compact e le variabili d'ambiente== dall'altra. In questo articolo raccolgo i comandi e le chiavi di configurazione che uso davvero, con una cheat sheet da tenere a portata di mano.
Chiudo il terminale, torno il giorno dopo e *Claude Code* ha dimenticato tutto? No: ogni conversazione è una **sessione** salvata su disco, agganciata alla cartella del progetto. Con **--continue** riprendo al volo l'ultima, con **--resume** scelgo quale ripescare dal *session picker*. ==Non riparto mai da zero==: vedo la differenza tra i due comandi, come ritrovo una vecchia conversazione, come biforco una sessione con *--fork-session* e dove finiscono i transcript.
Ogni volta che apro *Codex CLI* in un repo nuovo mi ritrovo a ripetere le stesse istruzioni: come girano i test, che convenzioni seguo, cosa non toccare. Il **file AGENTS.md** risolve proprio questo: Codex lo legge ==prima di iniziare a lavorare== e ne costruisce una catena di istruzioni, dal file globale in *~/.codex* fino a quello del progetto. Vedo cos'è davvero AGENTS.md, come funziona la sua discovery a livelli, il ruolo di *AGENTS.override.md* e dei fallback, e il flusso che seguo per scriverne uno utile.
Un **orchestratore** mette davanti a Claude Code una sola interfaccia e dietro più backend: ==Ollama in locale per i task semplici, Claude e OpenAI/Codex nel cloud per quelli difficili==. In questo tutorial installiamo e configuriamo il **Claude Code Router** passo passo, partendo da zero.
Claude Code, GitHub Copilot, Cursor e Gemini non sono lo stesso strumento con un nome diverso: ognuno **vince in un terreno preciso**. Li usiamo tutti e quattro ogni giorno e qui li mettiamo a confronto su criteri reali — contesto, modalita agente, MCP, lavoro in locale, costo — per dire ==quale conviene in quale scenario==, senza tifoserie.
Il 2 giugno 2026 Microsoft ha annunciato **Scout**, il suo primo **Autopilot**: un agente AI ==sempre attivo== che vive dentro il Microsoft 365 e *agisce in autonomia* su calendario, mail, Teams, OneDrive. Non è un nuovo Copilot: è una **categoria diversa**. Vediamo cosa cambia davvero per una PMI italiana — e le tre domande da farsi prima di abilitarlo.
Claude Code scrive in fretta, ma *chi rivede*? Un'idea: un **plugin** che a fine sessione passa il *diff* a un piccolo team di reviewer AI — **Junie, Copilot, Gemini, Codex** — ==ma solo a quelli davvero installati sul tuo PC==. Se uno manca, viene semplicemente saltato: nessun errore.
Quando una sessione di *Claude Code* si allunga, il problema non è il modello: è il **contesto** che si riempie di ricerche, log e file che non rileggerò mai. I **subagent** servono a questo — assistenti specializzati che lavorano nel loro contesto e mi restituiscono ==solo il riassunto==. Vedo cosa fa il comando **/agents**, come creo un subagent in pochi passi, e i tre campi (description, tools, model) che decidono se la delega funziona davvero.
Aggiungere un **server MCP** a Claude Code e a Codex segue lo stesso schema: un comando per gestirli e un file dove vengono elencati. Qui vedi il comando **/mcp**, i sottocomandi *add*, *list* e *remove*, e i file di configurazione — *~/.claude.json* e *~/.codex/config.toml* — con l'esempio del server *Playwright* spiegato ==riga per riga sugli screenshot annotati==.
VS Code ha il supporto **MCP** integrato: gli *MCP server* aggiungono strumenti, risorse e prompt alla chat agentica. Si installano in due modi — dalla vista *Estensioni* cercando **@mcp**, oppure scrivendo a mano il file **.vscode/mcp.json**. In questa guida configuro il server *Playwright*, imposto segreti e sandbox, e mostro ==dove leggere i log quando qualcosa non parte==.
Un **marketplace** è solo un repo GitHub con un file JSON: da lì *Claude Code* installa i tuoi plugin ==con un comando, da qualsiasi macchina==. In questo tutorial creo un repo **privato**, ci metto dentro un plugin che salva la sessione in **Obsidian** e lo espongo con due comandi — */salva-session* e */salva-session:compact*. Il tutto installabile **da remoto**, non da una cartella locale.
Il file **settings.json** è il vero pannello di controllo di *Claude Code*: poche righe decidono se l'agente lavora in **squadra**, come carica gli strumenti *MCP*, cosa fa ==alla fine di ogni sessione== e da dove installa i plugin. Parto dal mio file reale — ==con i dati sensibili oscurati== — e smonto le quattro sezioni che tocco più spesso, con i link alla documentazione ufficiale.
Il **18 giugno 2026** il *Model Context Protocol* ha pubblicato il suo *Enterprise-Managed Authorization*: agenti AI come Claude possono ora collegarsi al CRM, alla posta e al gestionale **con un solo login SSO**, log centralizzati e revoca immediata. Per una PMI italiana sparisce ==l'ultimo vero blocco== all'adozione degli agenti: niente più mille OAuth slegati, niente più account personali appiccicati a sistemi aziendali. Vedo cosa cambia davvero, cosa significa per chi ha già provato Claude o ChatGPT in azienda e i primi passi concreti per arrivarci.
La modalità interattiva di *Codex CLI* è comoda per esplorare, ma quando voglio inserire l'agente in una *pipeline* serve altro: **codex exec** esegue un singolo task ==senza aprire il terminale interattivo== ed esce. Progresso su *stderr*, risultato finale su *stdout*, output JSON per gli script e sandbox in sola lettura di default. Vedo cosa fa davvero codex exec, come ne leggo l'output da uno script e il flusso che uso per metterlo in CI con permessi minimi.
Nelle sessioni lunghe con *Claude Code* il vero collo di bottiglia non è il modello: è il **contesto** che si riempie. Il comando **/compact** riassume la conversazione e la rimette in pista, ma se lascio decidere all'auto-compattazione rischio di perderla ==nel momento peggiore==. Vedo cosa fa davvero /compact, come guidarlo con un focus e il flusso che seguo per tenere il contesto sotto il 60% e spendere meno token.
Il 28 maggio 2026 Anthropic ha rilasciato **Claude Opus 4.8** insieme alla research preview di *Dynamic Workflows*: ==centinaia di subagenti in parallelo dentro una singola sessione==, contesto 1M token e **4× meno errori** di codice lasciati passare. Vedo cosa cambia davvero per il **vibe coding aziendale** nelle PMI italiane e come muoversi senza farsi travolgere dai costi.
Maggio 2026 ha portato in pochi giorni *Agentforce Operations* di Salesforce, la nuova generazione di IBM *watsonx Orchestrate* al Think 2026 e Camunda *ProcessOS* in beta. È il segnale che l'**agentic AI** è ==uscita dalla fase demo ed è entrata nei processi reali==. Cosa significa concretamente per le **imprese italiane** e da dove iniziare **senza bruciare budget**.
COOL