Cursor 2.0 e Composer: come una rivisitazione multi-agente ha sorpreso la codifica dell'IA

Rilasciato Cursor, l'editor di codice e la piattaforma di agenti AI-first Cursore 2.0 il 29 ottobre 2025: un importante aggiornamento che abbina un modello di codifica appositamente progettato (denominato Compositore) con un'interfaccia riprogettata e incentrata sugli agenti e una serie di aggiornamenti della piattaforma volti a rendere la codifica agentica più veloce, sicura e collaborativa. L'azienda presenta questa release come un passaggio strategico dall'integrazione di modelli di terze parti alla distribuzione di un proprio modello e di strumenti addestrati, ottimizzati end-to-end per lo sviluppo di software "agentico".

Di seguito: uno sguardo approfondito a ciò che Cursor ha distribuito nella versione 2.0, come è stato sviluppato Composer, gli elementi concreti del changelog e, cosa più importante, cosa ha veramente sorpreso il mondo dell'intelligenza artificiale per gli sviluppatori su questa versione.

Che cos'è Cursor (e perché gli sviluppatori dovrebbero prestarvi attenzione)?

Cursor è un editor e una piattaforma progettati da zero per consentire agli sviluppatori di utilizzare l'intelligenza artificiale agenti come collaboratori di prima classe all'interno del flusso di lavoro di codifica. Combina un editor locale/remoto, l'orchestrazione degli agenti, l'integrazione di strumenti (terminali, browser, ricerca semantica) e un flusso di lavoro incentrato sul modello, in modo che gli agenti possano leggere, pianificare, modificare, testare e iterare su basi di codice reali. L'azienda definisce Cursor come "il modo migliore per programmare con l'intelligenza artificiale", focalizzato sul consentire agli agenti di eseguire utili attività di ingegneria anziché limitarsi a completare automaticamente le righe.

Perché Cursor 2.0 è importante adesso

Gli assistenti AI per il codice sono andati oltre i completamenti a singolo turno, verso flussi di lavoro più lunghi e articolati in più fasi (pianificazione → modifica → test → iterazione). Ciò crea nuovi colli di bottiglia: latenza, fedeltà del contesto su repository di grandi dimensioni, esecuzione sicura di comandi shell/CI e lavoro umano di revisione delle modifiche degli agenti. Cursore 2.0 affronta direttamente questi colli di bottiglia distribuendo un modello ottimizzato per flussi di lavoro agentici e al Primitive di interfaccia utente/architettura per eseguire più agenti contemporaneamente e in modo sicuro. In breve: Cursor punta a essere il sistema completo per l'ingegneria del software incentrata sugli agenti.

Funzionalità dell'aggiornamento Cursor 2.0:

• 4 volte più veloce: il dialogo medio viene completato in meno di 30 secondi;
• Capacità avanzate di attività multi-step: in grado di gestire in modo indipendente catene di codice complesse;
• Ricerca semantica avanzata: in grado di comprendere e trovare relazioni nell'intera base di codice;
• Ottimizzazione dell'interazione a bassa latenza, adatta allo sviluppo in tempo reale e alla prototipazione rapida;
• Addestramento tramite apprendimento per rinforzo (RL), ottimizzato per la codifica basata su agenti.

Qual è il concetto alla base di Cursor 2.0?

In sostanza, Cursor 2.0 propone tre idee interconnesse:

1. Progettazione dell'editor Agent-first

Invece di aggiungere agenti a un IDE tradizionale, Cursor 2.0 li espone come oggetti nell'editor: visibili in una barra laterale, gestibili come processi e in grado di eseguire "piani" (strategie multi-step) sul repository. Questo riformula le azioni dell'IA come attività orchestrabili, ciascuna con input, log e output che gli ingegneri possono ispezionare.

2. Modello di codifica veloce e progettato appositamente (Composer)

Il nuovo modello di Cursor, Composer, è un modello di codifica di frontiera addestrato e ottimizzato specificamente per interazioni agentiche all'interno dell'ambiente Cursor. Enfatizza la produttività e la reattività – proprietà essenziali per turni di codifica brevi e iterativi all'interno di un editor – rispetto ai costosi e grezzi benchmark basati sulla perplessità dei token. L'azienda segnala che Composer raggiunge circa Velocità di generazione 4× rispetto a modelli con capacità simili e completa la maggior parte delle svolte interattive in meno di 30 secondi nei benchmark interni. Questa velocità non è solo comodità, ma cambia anche la percezione dei flussi di lavoro agentici (dall'attesa all'iterazione).

3. Esecuzione parallela e isolata dell'agente

Cursor 2.0 consente ai team di eseguire più agenti in parallelo sullo stesso progetto, prevenendo al contempo i conflitti di file tramite sandboxing dell'area di lavoro di ciascun agente (tramite tecniche come git worktree o sandbox per lavoratori remoti). Ciò consente l'esplorazione di scenari ipotetici su larga scala: eseguire diverse strategie di riparazione, refactoring di varianti o pipeline di test in parallelo e confrontare i risultati senza interferire a vicenda.

---

Changelog di Cursor 2.0: quali sono esattamente le novità?

Cursor ha pubblicato un changelog dettagliato insieme all'annuncio della versione 2.0. I punti salienti riportati di seguito riassumono le modifiche più significative apportate al prodotto e alla ricerca.

Composer — Il primo modello di codifica agentica di Cursor

• Modello di frontiera appositamente costruito: Composer è descritto come un modello "di frontiera" ottimizzato per attività di ingegneria del software e velocità agentica. È stato addestrato con accesso agli strumenti del codice sorgente durante l'addestramento, il che lo aiuta ad apprendere modelli di ricerca, modifica e risoluzione di problemi multi-step all'interno di un repository reale.
• Vantaggio di velocità: Il cursore segnala che Composer è più o meno 4 volte più veloce nella capacità di generazione rispetto ai modelli di intelligenza comparabile nei loro benchmark e che la maggior parte delle conversazioni termina in meno di 30 secondi nella pratica, un miglioramento fondamentale per le sessioni interattive.
• Ottimizzazione agentica: Composer è stato addestrato in un ambiente agentico (con accesso a strumenti come la ricerca semantica, gli editor di testo e i test runner) e ottimizzato con metodi di apprendimento per rinforzo per favorire modifiche al codice rapide e affidabili. Alcuni studi indipendenti indicano architetture in stile MoE (con mix di esperti) e un'ottimizzazione dell'apprendimento automatico (RL) nella ricetta di addestramento del modello.

Impatto per gli sviluppatori: una latenza inferiore e una migliore consapevolezza del contesto per repository di grandi dimensioni rendono i flussi di lavoro degli agenti iterativi più rapidi e affidabili per le modifiche in più fasi.

Multi-agenti: orchestrazione di agenti paralleli

Barra laterale e gestione del piano: Una nuova interfaccia utente dell'editor consente agli sviluppatori di creare, nominare e gestire più agenti e "piani" (strategie degli agenti in più fasi) con una barra laterale persistente, in modo che gli agenti e i relativi registri siano facili da ispezionare.

Esecuzioni parallele (fino a otto agenti): Cursor 2.0 supporta l'esecuzione fino a otto agenti in parallelo su un singolo prompt, ognuno operante su una copia isolata del codice sorgente per prevenire conflitti. Ciò è possibile tramite worktree git locali o macchine remote worker. Il parallelismo trasforma la sperimentazione agentica da un processo lineare e bloccante a uno rapido e comparativo.

Browser (GA): consente agli agenti di testare e ispezionare le interfacce utente web reali

Browser passato a GA:* Il browser integrato di Cursor, originariamente in versione beta, è ora disponibile al pubblico e meglio integrato nell'editor. Gli agenti possono interagire con le pagine web, estrarre elementi DOM e inoltrare informazioni strutturate al runtime dell'agente. Ciò consente agli agenti di ricercare documentazione, recuperare API remote ed eseguire il debug basato sul web senza uscire dall'editor.

Impatto sullo sviluppatore: Gli agenti possono ora convalidare le modifiche dell'interfaccia utente, riprodurre i bug dei client e procedere con prove visive/DOM concrete anziché con descrizioni testuali cieche.

Revisione del codice e differenze migliorate

Revisione multi-file più semplice delle modifiche degli agenti. Cursor 2.0 semplifica la revisione delle modifiche apportate da un agente in un repository, senza dover passare da un file all'altro; le differenze vengono presentate in modo da ridurre il sovraccarico cognitivo.

Impatto sullo sviluppatore: Man mano che gli agenti apportano modifiche più consistenti o tra più file, il tempo impiegato dagli esseri umani per determinarne l'affidabilità diminuisce: un passaggio essenziale per l'adozione.

Terminali sandbox (GA) e controlli di sicurezza

I terminali sandbox sono GA (macOS) ed eseguono per impostazione predefinita i comandi della shell dell'agente in un ambiente sicuro. Le esecuzioni della shell sono in modalità sandbox con accesso in lettura/scrittura all'area di lavoro, nessuna rete per impostazione predefinita e inserimento in una lista consentita per i comandi sensibili. Sono disponibili controlli amministrativi per le aziende.
Impatto sullo sviluppatore: Un'esecuzione più sicura degli agenti è fondamentale; il sandboxing riduce i rischi quando un agente deve eseguire test, linter o comandi effimeri.

Modalità vocale, modalità di pianificazione e agenti in background

• Controllo vocale per gli agenti (conversione vocale in testo + parole chiave di invio personalizzate).
• Modalità Plan: crea un piano con un modello ed eseguilo con un altro; i piani possono essere eseguiti in primo piano o in background.
• Agenti di background e cloud: avvio più rapido, affidabilità del 99.9% per gli agenti cloud, migliore visibilità del lavoro in background.

Cosa suggerisce Cursor 2.0 per il più ampio panorama della codifica dell'intelligenza artificiale?

La mossa di Cursor è degna di nota per due motivi:

1. Specializzazione anziché generalità. Composer esemplifica una tendenza verso la creazione di modelli su misura per specifici domini e runtime (in questo caso: codifica agentica all'interno di un IDE). Invece di un singolo modello generalista che serva a ogni caso d'uso, i team stanno promuovendo modelli co-progettati con l'esperienza utente e la toolchain in cui operano.
2. Orchestrazione degli agenti come primitiva del prodotto. L'interfaccia utente di Cursor tratta gli agenti come risorse gestite che è possibile orchestrare, controllare e gestire tramite versioning. Questo modello di prodotto, ovvero gli agenti come processi gestiti con worktree isolati e piani condivisi, probabilmente apparirà in altri strumenti di sviluppo, man mano che i team cercheranno di scalare l'assistenza autonoma in modo sicuro.

Questa combinazione (modelli specializzati e più rapidi, più un'esperienza utente di orchestrazione deliberata) sposta il settore dai "modelli come completamento automatico" ai "modelli come collaboratori attivi", ma solleva anche questioni di governance a cui ogni team dovrà rispondere.

Come posso accedere a Cursor 2.0?

1. Scarica o aggiorna l'app Cursor dal sito ufficiale (Cursor distribuisce le versioni dal proprio sito). Cursor 2.0 è stato rilasciato come linea di prodotti v2 (Composer + interfaccia utente multi-agente), quindi il primo passo è aggiornarlo all'ultima build di Cursor.

2. Assicurati di aver abilitato Cursor 2.0 / Composer

• Il prezzo di Cursor si basa su piani di abbonamento, ognuno dei quali offre diversi livelli di accesso a Composer e ad altri modelli. L'azienda offre un piano Hobby gratuito, ma gli utenti professionali in genere optano per un piano a pagamento per sbloccare tutte le funzionalità.
• La versione 2.0 di Cursor (Composer, interfaccia utente multi-agente, browser in-app, ecc.) è evidenziata nel changelog; se l'app si è aggiornata automaticamente, dovresti già essere alla versione 2.0. In caso contrario, aggiorna l'app dalla pagina di download o dalla finestra di dialogo di aggiornamento dell'app.
• Le funzionalità di Composer o multi-file/agente potrebbero essere protette da un pulsante Beta nelle Impostazioni (versioni precedenti). Se non vedi Composer, seleziona Impostazioni → Funzionalità/Beta e abilitalo; Composer si apre solitamente tramite il collegamento Composer/Agente (ad esempio, Ctrl/Cmd + I) o dal riquadro laterale. Composer può essere attivato/disattivato e appare nell'interfaccia utente di Agent/Composer.

3. Configurare le chiavi/modelli API: Il cursore utilizza chiavi API configurate per chiamare i provider LLM (OpenAI, Anthropic, Google o provider personalizzati come CometaAPI). Apri Cursore → Impostazioni → Modelli (o Impostazioni → Chiavi API) per aggiungere chiavi provider e URL di base personalizzati. Cursore ti consentirà quindi di scegliere il modello abilitato all'interno di Chat / Agente / Compositore.

Come si usa CometAPI all'interno di Cursor? (passo dopo passo)

Breve riassunto: CometAPI è un gateway di aggregazione di modelli (un singolo endpoint che può fungere da proxy per molti fornitori di modelli). Per utilizzarlo in Cursor, è necessario registrarsi su CometAPI, ottenere una chiave API e un identificatore di modello, quindi aggiungere la chiave e l'endpoint nelle impostazioni dei modelli di Cursor come provider personalizzato (sostituendo l'URL di base) e selezionare il modello CometAPI in modalità Composer/Agent.

Passaggio A: ottieni le tue credenziali CometAPI

1. Registrati su CometAPI e creare una chiave API dalla loro dashboard. Mantieni segreta la chiave (trattala come qualsiasi token al portatore).
2. Crea/copia una chiave API e annota il nome/ID del modello che desideri utilizzare (ad esempio, claude-sonnet-4.5 o un altro modello di fornitore disponibile tramite CometAPI). Documentazione/guide CometAPI descrivere il processo ed elencare i nomi dei modelli supportati.

Passaggio B: aggiungere CometAPI come modello/provider personalizzato in Cursor

1. Apri cursore → Impostazioni profilo → Modelli (o Impostazioni → Chiavi API).
2. Se il cursore mostra un "Aggiungi modello personalizzato" or "Sostituisci URL di base OpenAI" opzione, usala:

• URL di base / Endpoint: incolla l'URL di base compatibile con CometAPI OpenAI (CometAPI documenterà se espongono un openai/v1 endpoint di stile o un endpoint specifico del provider). (Esempio: https://api.cometapi.com/v1 — utilizzare l'URL effettivo dalla documentazione CometAPI.)
• API Key: incolla la tua chiave CometAPI nel campo chiave API.
• Nome del modello: aggiungi l'identificatore del modello esattamente come i documenti CometAPI (ad esempio, claude-sonnet-4.5 or composer-like-model).

3. Verifica la connessione se Cursor offre un pulsante "Verifica" / "Test". Il meccanismo del modello personalizzato di Cursor richiede comunemente che il provider sia compatibile con OpenAI (o che Cursor accetti un URL di base + chiave). Le guide della community mostrano lo stesso schema (sovrascrivere l'URL di base → fornire la chiave → verificare).

Passaggio C: selezionare il modello CometAPI all'interno di Composer/Agent

1. Apri Composer o Agent (scorciatoia Ctrl/Cmd + I o il vetro laterale).
2. Cambia la selezione del modello da Auto (o dal tuo modello attuale) al fornitore/modello personalizzato che hai appena aggiunto.
3. Avvia una sessione di Composer o genera un agente e conferma che risponda utilizzando il modello CometAPI scelto. Esegui il test con un breve prompt (ad esempio, "cerca nel repository e aggiungi test unitari per le funzioni non riuscite in tests/”) per convalidare il comportamento.

Conclusione: si tratta di un aggiornamento epocale?

Cursor 2.0 non è solo un aggiornamento delle funzionalità; è una tesi a livello di prodotto che combina un modello di codifica appositamente progettato con primitive di orchestrazione che rendono pratici i flussi di lavoro agentici. Gli elementi sorprendenti – un modello agentico interno (Composer) esplicitamente ottimizzato per la velocità, un runtime multi-agente con meccanismi di isolamento concreti e integrazioni di strumenti più approfondite come un browser GA – segnalano una maturazione nel modo in cui l'intelligenza artificiale si integra con l'ingegneria del software. Per i team che sono disciplinati in materia di revisioni, test e igiene del flusso di lavoro, Cursor 2.0 offre un percorso credibile verso iterazioni significativamente più rapide e una maggiore automazione delle attività di ingegneria di routine. Per l'ecosistema più ampio degli sviluppatori di intelligenza artificiale, l'attenzione di Cursor sull'orchestrazione e gli strumenti degli agenti spingerà probabilmente altri fornitori a pensare oltre le interazioni con un singolo assistente e a team di agenti, barriere operative e modelli che tengono conto della latenza.