> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Gestire più agenti con agent view
> Invia e gestisci molte sessioni di Claude Code da una sola schermata. Agent view mostra cosa sta facendo ogni sessione e quali hanno bisogno del tuo input.
Agent view, aperto con `claude agents`, è una sola schermata per tutte le tue sessioni in background: cosa sta girando, cosa ha bisogno del tuo input e cosa è fatto. Invia nuove sessioni, osserva il loro stato a colpo d'occhio invece di scorrere i transcript, e intervieni solo quando uno ne ha bisogno. Ogni sessione in background è una conversazione completa di Claude Code che continua a girare senza un terminale collegato, quindi puoi aprirla, rispondere e andare via quando vuoi.
Usa agent view quando hai diversi compiti indipendenti su cui Claude può lavorare senza che tu guardi ogni passo. Invia una correzione di bug, una revisione di pull request e un'investigazione di test instabile come tre righe, continua a lavorare in un'altra finestra e controlla quando una riga mostra che ha bisogno di te o ha un risultato.
Quando vuoi lavorare più direttamente nella sessione di qualsiasi agente, collegati alla riga per entrare nella conversazione completa.
Per confrontare agent view con subagenti, team di agenti e worktrees, vedi [Run agents in parallel](/it/agents).
Agent view è in anteprima di ricerca e richiede Claude Code v2.1.139 o successivo. Controlla la tua versione con `claude --version`. L'interfaccia e le scorciatoie da tastiera potrebbero cambiare mentre la funzione si evolve.
Questa pagina copre:
* [Quick start](#quick-start): dai a Claude un compito su cui lavorare in background, controlla come sta andando e intervieni quando necessario
* [Monitor sessions with agent view](#monitor-sessions-with-agent-view), inclusi icone di stato, peek e reply, collegamento, organizzazione e scorciatoie da tastiera
* [Dispatch new agents](#dispatch-new-agents) da agent view, da dentro una sessione, o dalla tua shell
* [Manage sessions from the shell](#manage-sessions-from-the-shell)
* [How background sessions are hosted](#how-background-sessions-are-hosted) dal processo supervisor
Avvio rapido
Questa procedura illustra il ciclo principale della vista agente: invia un'attività, osserva l'aggiornamento della sua riga mentre Claude lavora, controlla per verificare lo stato e rispondi, e collegati per la conversazione completa. La sessione che invii continua a funzionare dopo che chiudi la vista agente, quindi puoi andare via e tornare ad essa.
Dalla tua shell, esegui:
```bash theme={null}
claude agents
```
Agent view si apre con un input in basso e una tabella che si riempie quando le sessioni iniziano. Premi `Esc` in qualsiasi momento per tornare alla tua shell. Le tue sessioni continuano a funzionare mentre sei via e riappaiono la prossima volta che apri agent view.
Digita un prompt che descrive un'attività e premi `Enter`. Una nuova sessione in background inizia su quell'attività e appare come una riga che mostra se sta lavorando, aspettando te, o è completata. La nuova sessione utilizza il modello mostrato nell'intestazione di agent view e la stessa [modalità di autorizzazione](#permission-mode-model-and-effort) che otterresti eseguendo `claude` in quella directory.
Ogni prompt che inserisci qui avvia la sua propria nuova sessione. Digitando un altro prompt e premendo `Enter` avvia una seconda sessione accanto alla prima piuttosto che inviare un follow-up ad essa. Puoi eseguire diversi in parallelo in questo modo.
Ogni sessione utilizza la tua quota di abbonamento indipendentemente, quindi consulta [Limitazioni](#limitations) prima di inviare molte sessioni contemporaneamente.
Seleziona una riga con i tasti freccia e premi `Space` per aprire il pannello peek. Mostra l'output più recente della sessione, o la domanda su cui sta aspettando, piuttosto che la trascrizione completa. Digita una risposta e premi `Enter` per inviarla senza lasciare agent view.
Premi `Enter` o `→` su una riga per collegarti quando vuoi la conversazione completa. La sessione prende il controllo del terminale come una sessione Claude Code interattiva completa. Premi `←` su un prompt vuoto per scollegar e tornare alla tabella.
Per spostare una sessione che hai già aperta in agent view, esegui `/bg` dentro di essa, o premi `←` su un prompt vuoto per metterla in background e aprire agent view in un unico passaggio. La sessione continua a funzionare e appare come una riga accanto a quelle che hai inviato.
Puoi usare `claude agents` come tuo punto di ingresso principale invece di `claude`: invia ogni attività da agent view, collegati quando vuoi la conversazione completa, e premi `←` per tornare alla tabella.
Monitorare le sessioni con agent view
Esegui `claude agents` per aprire agent view. Prende il controllo del terminale completo ed elenca ogni sessione raggruppata per stato, con sessioni fissate e quelle che hanno bisogno di te in cima. Ogni riga mostra il nome della sessione, l'attività corrente e quanto tempo fa è cambiata l'ultima volta.
Per impostazione predefinita, l'elenco mostra ogni sessione in background che hai avviato, in tutti i tuoi progetti. Una sessione che lavora in un repository e un'altra in un worktree diverso appaiono entrambe qui, indipendentemente da quale directory hai aperto agent view. Per limitare l'elenco a un progetto, passa `--cwd` (richiede Claude Code v2.1.141 o successivo):
```bash theme={null}
claude agents --cwd ~/projects/my-app
```
Questo mostra solo le sessioni avviate in quella directory. Una sessione che si è [spostata in un worktree](#how-file-edits-are-isolated) sotto `~/projects/my-app/.claude/worktrees/` conta ancora come appartenente a `~/projects/my-app`.
Le sessioni interattive che hai aperto in altri terminali non appaiono finché non le [metti in background](#from-inside-a-session). I [subagents](/it/sub-agents) e i [teammates](/it/agent-teams) che una sessione genera non sono elencati come righe separate.
```text theme={null}
Pinned
✽ clawd walk cycle Write assets/sprites/clawd-walk.png 3m
Ready for review
∙ jump physics Opened PR with collision fix PR #2048 2h
Needs input
✻ power-up design needs input: double jump or wall climb? 1m
Working
✽ collision detection Edit src/physics/CollisionSystem.ts 2m
✢ playtest level 3 run 12 · all checkpoints cleared in 4m
Completed
✻ title screen result: menu, options, and credits done 9m
∙ sound effects result: 14 SFX exported to assets/audio 4h
… 6 more
```
Leggere lo stato della sessione
Ogni riga inizia con un'icona il cui colore e animazione mostrano lo stato della sessione:
| Stato | L'icona mostra | Cosa significa |
| :---------- | :------------- | :---------------------------------------------------------------------------- |
| Working | Animato | Claude sta attivamente eseguendo strumenti o generando una risposta |
| Needs input | Giallo | Claude sta aspettando una domanda specifica o una decisione di permesso da te |
| Idle | Attenuato | La sessione non ha nulla da fare ed è pronta per il tuo prossimo prompt |
| Completed | Verde | Il compito è terminato con successo |
| Failed | Rosso | Il compito è terminato con un errore |
| Stopped | Grigio | La sessione è stata fermata con `Ctrl+X` o `claude stop` |
Separatamente, la forma dell'icona mostra se il processo sottostante è in esecuzione:
| Forma | Cosa significa |
| :---------------- | :--------------------------------------------------------------------------------------------------------------------------------------------- |
| `✻` o animato `✽` | Il processo della sessione è vivo e risponde immediatamente |
| `∙` | Il processo è uscito. Puoi ancora fare peek, rispondere o collegarti, e Claude riavvia da dove l'ha lasciato |
| `✢` | Una sessione [`/loop`](/it/scheduled-tasks) che dorme tra le iterazioni. La riga mostra il conteggio delle esecuzioni e un conto alla rovescia |
L'etichetta `PR #N` che può apparire al bordo destro di una riga è la [pull request che la sessione ha aperto](#pull-request-status), non parte dell'icona di stato. Quando una sessione ha aperto più di una pull request, l'etichetta mostra un conteggio invece, come `3 PRs`.
Il titolo della scheda del terminale mostra il conteggio awaiting-input mentre agent view è aperto: `2 awaiting input · claude agents` quando le sessioni hanno bisogno di input, o `claude agents` quando nessuna lo fa.
Le sessioni in background non hanno bisogno di alcun terminale aperto per continuare a lavorare. Un [processo supervisor](#the-supervisor-process) separato le esegue, quindi puoi chiudere agent view, chiudere la tua shell, o avviare una nuova sessione interattiva e il tuo lavoro inviato continua.
Lo stato della sessione persiste su disco attraverso gli auto-update e i riavvii del supervisor. Le sessioni sono anche preservate quando la tua macchina dorme. I loro processi riprendono al risveglio e il supervisor si ricollega a loro invece di trattare il gap di tempo come inattività. Lo spegnimento ferma comunque le sessioni in esecuzione; vedi [Sessions show as failed after shutdown](#sessions-show-as-failed-after-shutdown) per come recuperarle.
Riassunti delle righe
Il riassunto su una riga è generato da un [modello di classe Haiku](/it/model-config) in modo che la riga possa dirti cosa sta facendo la sessione, cosa ha bisogno, o cosa ha prodotto senza aprire il transcript. Mentre una sessione sta attivamente lavorando, il riassunto si aggiorna al massimo una volta ogni 15 secondi, più una volta quando ogni turno termina.
Da v2.1.161, quando la sessione sta eseguendo due o più elementi di lavoro paralleli, come subagents, comandi shell in background, o monitor, un conteggio `done/total` come `2/5` appare prima del testo del riassunto.
Ogni aggiornamento è una breve richiesta di classe Haiku attraverso il tuo provider normale, fatturato e gestito secondo gli stessi [termini di utilizzo dei dati](/it/data-usage) della sessione stessa. Su provider di terze parti come Bedrock, Vertex AI, Microsoft Foundry e gateway personalizzati, la richiesta ritorna al modello principale della sessione quando nessun modello Haiku è configurato. Imposta [`ANTHROPIC_DEFAULT_HAIKU_MODEL`](/it/model-config#environment-variables) per scegliere il modello per questi riassunti su quei provider.
Stato della pull request
Quando una sessione apre una pull request, un'etichetta `PR #1234` appare al bordo destro della riga, collegata alla pull request nei terminali che supportano i hyperlink. L'etichetta persiste quando invii un follow-up alla sessione, quindi la pull request rimane visibile mentre la riga ritorna al progresso live.
Quando una sessione ha aperto più di una pull request, l'etichetta mostra un conteggio invece, come `3 PRs`, colorato dalla pull request aperta che ha più bisogno di attenzione. Apri il [pannello peek](#peek-and-reply) per vederle tutte.
Il numero della pull request è colorato dal suo stato:
| Colore | Stato della pull request |
| :----- | :------------------------------------------------------ |
| Giallo | In attesa di controlli o revisione, o controlli falliti |
| Verde | Controlli superati e nessuna revisione sta bloccando |
| Viola | Unito |
| Grigio | Bozza o chiuso |
Per la maggior parte dei compiti questa colonna è dove raccogli il risultato: rivedi e unisci la pull request quando il suo numero diventa verde.
Peek and reply
Premi `Space` su una riga selezionata per aprire il pannello peek. Mostra cosa la sessione ha bisogno da te, il suo output più recente, e qualsiasi pull request che ha aperto. La maggior parte delle volte questo è sufficiente, e non hai mai bisogno di aprire il transcript completo.
Da v2.1.161, quando la sessione sta eseguendo elementi di lavoro paralleli, il pannello nomina anche quello che sta girando più a lungo e da quanto tempo sta andando, così puoi vedere cosa la sessione sta aspettando senza collegarti.
Digita una risposta nel pannello peek e premi `Enter` per inviarla a quella sessione. Quando la sessione sta facendo una domanda a scelta multipla, il pannello peek mostra le opzioni e puoi premere un tasto numero per sceglierne uno. Per altre sessioni bloccate, premi `Tab` per riempire l'input con una risposta suggerita che puoi modificare prima di inviare. Prefissa una risposta con `!` per inviare un comando Bash invece.
Da v2.1.145, con la [dettatura vocale](/it/voice-dictation) abilitata, tieni premuto o tocca il tuo tasto push-to-talk mentre l'input di risposta è focalizzato per dettare una risposta invece di digitarla. Lo stesso funziona nell'input di dispatch in fondo a agent view.
Usa `↑` e `↓` per fare peek alle sessioni adiacenti senza chiudere il pannello, o `→` per collegarti.
Collegarsi a una sessione
Premi `Enter` o `→` su una riga selezionata per collegarti. Agent view è sostituito dalla sessione interattiva completa. Quando ti colleghi, Claude pubblica un breve riassunto di cosa è successo mentre eri via.
Mentre collegato, la sessione si comporta come qualsiasi altra sessione di Claude Code: ogni [comando](/it/commands), scorciatoia da tastiera e funzione funziona.
Le sessioni collegate si rendono sempre in [modalità fullscreen](/it/fullscreen), indipendentemente dalla tua impostazione `tui`, perché una sessione in background non ha scrollback del terminale a cui aggiungere. Scorri con `PgUp`, `PgDn`, o la rotella del mouse, e premi `Ctrl+O` per la modalità transcript. Lo scroll nativo del tuo terminale e la modalità copia di tmux mostrano solo il viewport corrente, lo stesso di quando esegui qualsiasi applicazione fullscreen.
Premi `←` su un prompt vuoto per scollegar e tornare a agent view. Se una finestra di dialogo ha il focus e non risponde a `←`, premi `Ctrl+Z` per scollegar immediatamente.
`Ctrl+C` mantiene il suo comportamento di interruzione standard mentre collegato: annulla una risposta in esecuzione o un comando shell `!` piuttosto che scollegar. Premere `Ctrl+C` due volte su un prompt vuoto scollega, come in qualsiasi sessione.
Scollegar non ferma mai una sessione in background: `←`, `Ctrl+Z`, `/exit`, e doppio `Ctrl+C` o doppio `Ctrl+D` la lasciano tutte in esecuzione. Per terminare una sessione da dentro di essa, esegui `/stop`.
Premere `←` su un prompt vuoto funziona da qualsiasi sessione di Claude Code, non solo quelle a cui ti sei collegato da agent view. Mette in background la sessione corrente e apre agent view con quella riga selezionata, quindi puoi cambiare sessioni senza lasciare il terminale. La riga viene creata anche da una sessione nuova senza cronologia di conversazione, quindi `→` vi ritorna. Quando quella riga è l'unica, agent view mostra un suggerimento di onboarding sotto di essa. Puoi disattivare questa scorciatoia in `/config` (l'impostazione `leftArrowOpensAgents`).
Organizzare l'elenco
Agent view raggruppa le sessioni in modo che quelle che hanno bisogno di input siano in cima, con `Ready for review` e `Needs input` sopra `Working` e `Completed`. Questi nomi di gruppo non corrispondono uno a uno agli [stati](#read-session-state) sopra: una sessione si sposta a `Ready for review` quando ha una pull request aperta, e `Completed` raccoglie insieme sessioni finite, fallite e fermate. Premi `Ctrl+S` per raggruppare per directory invece. La tua scelta persiste tra le esecuzioni.
All'interno di un gruppo:
* Premi `Ctrl+T` per fissare una sessione in cima e [mantenere il suo processo in esecuzione](#the-supervisor-process) mentre inattivo
* Premi `Shift+↑` o `Shift+↓` per riordinare le sessioni
* Premi `Ctrl+R` per rinominare una sessione
* Premi `Enter` su un'intestazione di gruppo per comprimerla
Per rimuovere una sessione dall'elenco, premi `Ctrl+X` per fermarla e `Ctrl+X` di nuovo entro due secondi per eliminarla. Premere `Ctrl+X` su un'intestazione di gruppo elimina ogni sessione in quel gruppo dopo conferma.
L'eliminazione rimuove la sessione da agent view. Se Claude ha [creato un worktree](#how-file-edits-are-isolated) per la sessione, l'eliminazione rimuove anche quel worktree, inclusi eventuali cambiamenti non committati in esso, quindi esegui il push o il commit del lavoro che vuoi mantenere prima. Un worktree che hai creato tu stesso e in cui hai avviato la sessione viene lasciato in posto. Il transcript della conversazione rimane sulla tua macchina locale e rimane disponibile attraverso `claude --resume`.
Le sessioni completate più vecchie si ripiegano in una riga `… N more` per mantenere l'elenco breve. I fallimenti e le sessioni con una pull request aperta rimangono sempre visibili.
Filtrare le sessioni
Digita nell'input di dispatch per filtrare invece di inviare:
| Filtro | Mostra |
| :---------------------- | :--------------------------------------------------------------------------------------------------------- |
| `a:` | Sessioni che eseguono l'agente denominato |
| `s:` | Sessioni nello stato dato, come `s:working`. Accetta anche `s:blocked` per tutto ciò che sta aspettando te |
| `#` o un URL PR | La sessione che lavora su quella pull request |
| Qualsiasi altro URL | La sessione il cui primo prompt conteneva quell'URL |
Scorciatoie da tastiera
Premi `?` in agent view per vedere ogni scorciatoia nel contesto. La tabella sottostante le riassume.
| Scorciatoia | Azione |
| :-------------------- | :------------------------------------------------------------------------------------------- |
| `↑` / `↓` | Muoviti tra le righe |
| `Enter` | Collegati alla sessione selezionata, o invia se c'è testo nell'input |
| `Space` | Apri o chiudi il pannello peek per la sessione selezionata |
| `Shift+Enter` | Invia e collegati immediatamente |
| `→` | Collegati alla sessione selezionata |
| `Alt+1`..`Alt+9` | Collegati alla sessione 1–9 nella directory della sessione focalizzata |
| `Tab` | Su un input vuoto, sfoglia tutti i subagents. Altrimenti applica il suggerimento evidenziato |
| `Ctrl+S` | Cambia raggruppamento tra stato e directory |
| `Ctrl+T` | Fissa o scollega la sessione selezionata |
| `Ctrl+R` | Rinomina la sessione selezionata |
| `Ctrl+G` | Apri il prompt di dispatch nel tuo `$VISUAL` o `$EDITOR` |
| `Ctrl+X` | Ferma la sessione; premi di nuovo entro due secondi per eliminarla |
| `Shift+↑` / `Shift+↓` | Riordina la sessione selezionata |
| `Esc` | Chiudi il pannello peek, cancella l'input, o esci |
| `Ctrl+C` | Cancella l'input; premi due volte per uscire |
| `?` | Mostra tutte le scorciatoie |
Invia nuovi agenti
Puoi inviare nuove sessioni in background da agent view, inviare una sessione interattiva esistente in background, o avviarne una direttamente dalla shell.
From agent view
Digita un prompt nell'input in basso di agent view e premi `Enter` per avviare una nuova sessione in background. La sessione è denominata automaticamente dal prompt; rinominala in seguito con `Ctrl+R`.
Incolla un'immagine nel prompt per includere uno screenshot o un diagramma con il compito.
Prefissa o menziona parti del prompt per controllare come la sessione inizia:
| Input | Effect |
| :----------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ` ` | Se la prima parola corrisponde a un nome di [subagent](/it/sub-agents) personalizzato, quel subagent viene eseguito come agente principale della sessione con la configurazione dal suo frontmatter |
| `@` | Menziona un subagent personalizzato in qualsiasi punto del prompt per eseguirlo come agente principale |
| `@` | Menziona un repository sotto la directory da cui hai aperto agent view per eseguire la sessione lì |
| `/` | Suggerisci [skills](/it/skills) e [commands](/it/commands) da inviare come prompt |
| `! ` | Esegui un comando shell come un job in background invece di avviare una sessione Claude. Il job appare come una riga a cui puoi collegarti, osservare e staccarti |
| `#` o un URL di pull request | Se una sessione sta già lavorando su quel PR, selezionala invece di inviare |
| `Shift+Enter` | Invia e collegati immediatamente alla nuova sessione |
Un piccolo insieme di comandi viene eseguito in agent view stesso invece di essere inviato: `/exit` e `/quit` chiudono agent view, `/logout` ti disconnette, e `/model` imposta il [modello di dispatch](#set-the-model). Skills, i tuoi comandi personali, e built-in che espandono il prompt come `/init` vengono inviati a una nuova sessione in background come loro primo prompt. Gli altri comandi built-in mostrano un suggerimento `attach to a session to run it` invece.
Confezionare un compito ricorrente come una [skill](/it/skills) ti permette di avviare lo stesso workflow da agent view ripetutamente senza riscrivere il prompt.
Quando lo stesso `@name` corrisponde sia a un subagent che a un repository fratello, il subagent ha la precedenza. La corrispondenza della prima parola senza `@` si applica anche, quindi un prompt che inizia con uno dei tuoi nomi di subagent invia quel subagent piuttosto che trattare la parola come testo semplice. Usa la forma `@` quando vuoi essere esplicito, o inizia il prompt con una parola diversa per evitare la corrispondenza.
Invia a una directory specifica
Una nuova sessione viene eseguita nella directory da cui hai aperto agent view. Per indirizzare una directory diversa:
* Apri `claude agents` in quella directory.
* Apri `claude agents` in una directory padre che contiene diversi repository e menzionane uno con `@` nel prompt per eseguire la sessione lì.
* Dalla shell, `cd` nella directory e esegui `claude --bg ""`.
Quando agent view è raggruppato per directory, la directory della riga evidenziata diventa il target di dispatch, quindi puoi scorrere a un gruppo e inviare in esso senza riscrivere il percorso.
From inside a session
Esegui `/background` o il suo alias `/bg` per spostare la conversazione corrente in una sessione in background. Passa un prompt come `/bg run the test suite and fix any failures` per inviare un'istruzione in più prima. Se Claude sta rispondendo quando esegui `/bg`, la risposta continua nella sessione in background.
Lo spostamento in background da una sessione interattiva avvia un nuovo processo che riprende dalla conversazione salvata, quindi l'esecuzione di subagent, [monitor](/it/tools-reference#monitor-tool), e comandi in background non si trasferiscono ad esso. Claude ti chiede di confermare prima di spostare in background quando uno qualsiasi di essi è in esecuzione. Una volta in background, la sessione può avviare nuovi subagent, monitor, e comandi in background, e questi continuano a essere eseguiti durante successivi distacchi e ricollegamenti.
I flag di configurazione dal lancio originale si trasferiscono alla sessione messa in background, quindi i suoi server MCP, le impostazioni e il modello di fallback rimangono in vigore:
* `--mcp-config` e `--strict-mcp-config`
* `--settings`
* `--add-dir`
* `--plugin-dir`
* `--fallback-model`
* `--allow-dangerously-skip-permissions`
Le directory che hai aggiunto durante la sessione con [`/add-dir`](/it/permissions#additional-directories-grant-file-access-not-configuration) si trasferiscono anche.
Il trasferimento di `--allow-dangerously-skip-permissions` mantiene `bypassPermissions` raggiungibile nella sessione messa in background, ma non concede nulla di nuovo. La modalità richiede comunque la stessa accettazione interattiva una tantum descritta in [Permission mode, model, and effort](#permission-mode-model-and-effort) prima che qualsiasi sessione possa utilizzarla.
From your shell
Passa `--bg` o la sua forma lunga `--background` per avviare una sessione che va direttamente in background:
```bash theme={null}
claude --bg "investigate the flaky SettingsChangeDetector test"
```
Per eseguire un subagent specifico come agente principale della sessione, combina `--bg` con `--agent`:
```bash theme={null}
claude --agent code-reviewer --bg "address review comments on PR 1234"
```
Passa `--name` per impostare il nome di visualizzazione della sessione in agent view invece di quello generato automaticamente:
```bash theme={null}
claude --bg --name "flaky-test-fix" "investigate the flaky SettingsChangeDetector test"
```
Dopo aver messo in background, Claude stampa l'ID breve della sessione e i comandi per gestirla. Quando passi `--name`, il nome appare dopo l'ID breve:
```text theme={null}
backgrounded · 7c5dcf5d · flaky-test-fix
claude agents list sessions
claude attach 7c5dcf5d open in this terminal
claude logs 7c5dcf5d show recent output
claude stop 7c5dcf5d stop this session
```
Esegui un comando shell
Per eseguire un comando shell come un job in background invece di una sessione Claude, digita `!` come primo carattere dell'input di dispatch di agent view. Il `!` viene visualizzato come prefisso e tutto ciò che digiti dopo di esso è il comando. L'esempio seguente invia `pytest -x` dalla casella di input di agent view:
```text theme={null}
! pytest -x
```
Premi `Enter` per avviare il job. Lo stesso job può anche essere lanciato direttamente dalla tua shell con `--exec`:
```bash theme={null}
claude --bg --exec 'pytest -x'
```
Il comando viene eseguito come un job supportato da PTY e appare come una riga in agent view, con la riga di output più recente come suo stato. Un job shell esegue il comando al posto di Claude, quindi nessun modello viene invocato e l'output non viene inviato a nessuna sessione.
Per vedere l'output, collegati alla riga, premi `Space` per visualizzare l'anteprima senza collegarti, o esegui `claude logs ` dalla tua shell. L'output acquisito rimane in memoria e non viene scritto su disco. La riga e il suo output si puliscono automaticamente circa cinque minuti dopo l'uscita del comando, quindi leggi prima se hai bisogno del risultato.
How file edits are isolated
Ogni sessione in background, che sia avviata da agent view, `/bg`, o `claude --bg`, inizia nella tua directory di lavoro. Prima di modificare i file, Claude sposta la sessione in un [git worktree](/it/worktrees) isolato sotto `.claude/worktrees/`, quindi le sessioni parallele possono leggere lo stesso checkout ma ognuna scrive nel suo.
Claude salta il worktree quando:
* La sessione è già all'interno di un git worktree collegato, che Claude l'abbia creato sotto `.claude/worktrees/` o tu l'abbia creato con `git worktree add` da qualche altra parte
* La directory di lavoro non è un repository git e nessun [`WorktreeCreate` hook](/it/hooks#worktreecreate) è configurato
* La scrittura è al di fuori della directory di lavoro
Per disattivare l'isolamento del worktree per un repository dove i git worktree sono impraticabili, imposta [`worktree.bgIsolation`](/it/settings#worktree-settings) su `"none"`. Le sessioni in background modificheranno quindi la tua copia di lavoro direttamente senza spostarsi prima in un worktree. Aggiungi l'impostazione al file `.claude/settings.json` del progetto:
```json theme={null}
{
"worktree": {
"bgIsolation": "none"
}
}
```
L'impostazione `worktree.bgIsolation` richiede Claude Code v2.1.143 o successivo.
Al di fuori di un repository git, le sessioni scrivono direttamente nella directory di lavoro e non sono isolate l'una dall'altra, quindi evita di inviare sessioni parallele che modificano gli stessi file. Se utilizzi un sistema di controllo versione diverso, configura un [`WorktreeCreate` hook](/it/worktrees#non-git-version-control) e Claude isola le modifiche nello stesso modo in cui lo fa per git.
L'eliminazione di una sessione in agent view (`Ctrl+X` due volte) rimuove un worktree che Claude ha creato per essa, inclusi eventuali cambiamenti non committati, quindi unisci o spingi i cambiamenti che vuoi mantenere prima. L'eliminazione dalla shell con [`claude rm`](#manage-sessions-from-the-shell) mantiene un worktree che ha cambiamenti non committati e stampa il suo percorso in modo che tu possa pulirlo da solo. Un worktree che hai creato tu stesso e in cui hai avviato la sessione viene lasciato in posizione in entrambi i casi.
Per trovare il percorso del worktree di una sessione, visualizza l'anteprima della sessione o collegati e controlla la sua directory di lavoro.
Un [subagent](/it/sub-agents) che la sessione in background genera eredita la directory di lavoro della sessione, quindi le sue modifiche ai file finiscono nel worktree della sessione piuttosto che nella tua copia di lavoro. Per dare a un subagent il suo proprio worktree separato, imposta [`isolation: worktree`](/it/sub-agents#supported-frontmatter-fields) nel suo frontmatter o passa `isolation: "worktree"` quando lo generi.
Set the model
Il nome del modello mostrato nell'intestazione di agent view è il default di dispatch. Le nuove sessioni che avvii dall'input utilizzano questo modello, che proviene dall'impostazione [`model`](/it/settings#available-settings) nei tuoi settings utente. Impostalo selezionando un modello nel picker [`/model`](/it/model-config), o modifica l'impostazione direttamente. Per sovrascriverlo per l'intera sessione di agent view, passa `--model` quando apri agent view. Vedi [Permission mode, model, and effort](#permission-mode-model-and-effort).
Per cambiare il default di dispatch da dentro agent view, digita `/model` seguito da un nome di modello nell'input di dispatch e premi `Enter`. L'intestazione si aggiorna per mostrare quel modello con un marcatore `(session)`, e le sessioni che invii successivamente lo utilizzano. Digita `/model default` per cancellare l'override e tornare al default di dispatch. Questo override dura per il resto della corrente esecuzione di `claude agents`, non scrive nel tuo file di settings, e richiede Claude Code v2.1.172 o successivo. {/* min-version: 2.1.172 */} L'esempio seguente invia una sessione su Opus e la successiva su Sonnet:
```text theme={null}
/model opus
refactor auth
/model sonnet
run the test suite
```
Ogni sessione in background può essere eseguita su un modello diverso. Per sovrascriverlo per una sessione:
* Dalla shell, passa `--model` con `claude --bg`.
* Collegati a una sessione in esecuzione, apri `/model`, e premi `s` su un modello per passare a quel modello solo per quella sessione. Il cambiamento persiste se la sessione viene riavviata.
* Invia un [subagent](/it/sub-agents) il cui frontmatter imposta un campo `model`.
Permission mode, model, and effort
Una sessione in background legge i suoi [settings](/it/settings) dalla directory in cui viene eseguita, come se avessi avviato `claude` lì. Questo include i valori [`env`](/it/settings#available-settings) nei settings del progetto, quindi un `ANTHROPIC_MODEL` o una variabile del provider impostata lì si applica alle sessioni in background in quella directory.
La selezione del cloud provider, come `CLAUDE_CODE_USE_BEDROCK` o `CLAUDE_CODE_USE_VERTEX`, e gli alias `ANTHROPIC_DEFAULT_*_MODEL` seguono la shell che ha inviato la sessione. Le variabili dell'endpoint del gateway come `ANTHROPIC_BASE_URL` e il suo `ANTHROPIC_AUTH_TOKEN` associato non lo fanno. Vedi [il processo supervisore](#the-supervisor-process) per come le sessioni in background ottengono le impostazioni del provider e le credenziali.
Il [permission mode](/it/permissions) dipende da come hai avviato la sessione. Lo spostamento in background di una sessione esistente con `/bg` o `←` mantiene il permission mode corrente, quindi una sessione che hai cambiato in `acceptEdits` o `auto` rimane in quella modalità dopo il distacco. L'invio da agent view input o l'esecuzione di `claude --bg` dalla tua shell utilizza il `defaultMode` dai settings di quella directory, o il `permissionMode` dal frontmatter del [subagent inviato](/it/sub-agents#supported-frontmatter-fields).
Il permission mode, il modello e lo sforzo con cui una sessione in background è stata avviata, insieme ai [flag di configurazione che trasporta](#from-inside-a-session), persistono tutti quando il supervisore successivamente [arresta e riavvia](#the-supervisor-process) il processo della sessione. Una sessione che hai lanciato con `claude --bg --dangerously-skip-permissions` o `claude --bg --permission-mode bypassPermissions` rimane in `bypassPermissions` dopo quel riavvio invece di tornare al `defaultMode` della directory, e un modello o sforzo che hai cambiato a metà sessione con `/model` o `/effort` viene mantenuto.
Per impostare i default per ogni sessione che invii da agent view, passa uno qualsiasi di `--permission-mode`, `--model`, `--effort`, o `--agent` quando lo apri:
```bash theme={null}
claude agents --permission-mode plan --model opus --effort high
```
`--agent` imposta il [subagent](/it/sub-agents) utilizzato quando un prompt di dispatch non ne nomina uno, sia con `@name` che come prima parola. Per impostazione predefinita, utilizza l'impostazione [`agent`](/it/settings#available-settings) se ne è impostata una, altrimenti l'agente catch-all integrato `claude`. Nominare un subagent nell'input di dispatch sovrascrive entrambi.
`claude agents` accetta anche `--dangerously-skip-permissions` come abbreviazione per `--permission-mode bypassPermissions`, e `--allow-dangerously-skip-permissions` per rendere `bypassPermissions` disponibile nel ciclo `Shift+Tab` di ogni sessione inviata senza avviare in quella modalità. Entrambi corrispondono ai [flag CLI di livello superiore](/it/cli-reference).
Questi flag sono stati aggiunti in diverse versioni. Le versioni precedenti li rifiutano con un errore di opzione sconosciuta.
| Flag o impostazione | Versione minima |
| :--------------------------------------------------------------------------- | :------------------------------------ |
| `--permission-mode`, `--model`, `--effort`, `--dangerously-skip-permissions` | v2.1.142 {/* min-version: 2.1.142 */} |
| `--allow-dangerously-skip-permissions` | v2.1.143 {/* min-version: 2.1.143 */} |
| `--agent`, e rispetto dell'impostazione `agent` per le sessioni inviate | v2.1.157 {/* min-version: 2.1.157 */} |
Prima di v2.1.157, agent view ignora l'impostazione `agent` e invia l'agente integrato `claude`.
I default attivi appaiono nel footer sotto l'input di dispatch.
Senza questi flag, la sessione utilizza il `defaultMode` dai settings di quella directory o il `permissionMode` dal frontmatter del [subagent inviato](/it/sub-agents#supported-frontmatter-fields), e il modello mostrato nell'intestazione di agent view.
L'uso di `bypassPermissions` o `auto` è rifiutato finché non hai accettato quella modalità eseguendo `claude` con essa una volta in modo interattivo, poiché queste modalità permettono a una sessione che non stai guardando di agire senza approvazione. Lo stesso si applica sia che tu passi la modalità a `claude agents` che a `claude --bg --permission-mode`.
Settings, plugins, and MCP servers
Agent view accetta gli stessi flag di configurazione di `claude` per caricare settings, plugins, server MCP, e directory aggiuntive. Questi flag richiedono Claude Code v2.1.142 o successivo. Ogni flag si applica a agent view stesso e viene passato a ogni sessione che invii da esso, quindi un plugin o server MCP che carichi in questo modo è disponibile anche in quelle sessioni.
| Flag | Effect |
| :----------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------- |
| [`--settings `](/it/settings) | Sovrascrivi settings per agent view e sessioni inviate |
| [`--add-dir `](/it/permissions#additional-directories-grant-file-access-not-configuration) | Concedi accesso ai file a una directory aggiuntiva |
| [`--plugin-dir `](/it/plugins) | Carica un plugin da una directory locale |
| [`--mcp-config `](/it/mcp) | Carica server MCP da un file di configurazione o stringa JSON |
| `--strict-mcp-config` | Usa solo i server MCP da `--mcp-config`, ignorando altre configurazioni MCP |
Ripeti `--add-dir`, `--plugin-dir`, o `--mcp-config` una volta per valore. La forma separata da spazi, come `--add-dir a b c`, non è supportata con `claude agents`.
L'esempio seguente apre agent view con un override di settings e una directory extra:
```bash theme={null}
claude agents --settings ./ci-settings.json --add-dir ../shared-lib
```
Gestire le sessioni dalla shell
Ogni sessione in background ha un ID breve che puoi usare dalla shell. L'ID viene stampato quando avvii una sessione con `claude --bg`, e l'ID di ogni sessione è il nome della sua directory sotto `~/.claude/jobs/`. Questi comandi sono utili per lo scripting o quando non vuoi aprire agent view.
| Command | Purpose |
| :--------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `claude agents` | Apri agent view |
| `claude agents --cwd ` | Apri agent view limitato alle sessioni avviate sotto `` |
| `claude agents --json` | Stampa le sessioni attive come un array JSON e esci: ogni sessione live, più sessioni in background che stanno ancora lavorando o sono bloccate anche quando il loro processo è uscito. Aggiungi `--all` per includere anche le sessioni in background completate. Ogni voce ha `cwd`, `kind`, e `startedAt`. Le voci in background hanno anche `id`, utilizzabile con `claude attach`/`logs`/`stop`, e `state`: uno di `working`, `blocked`, `done`, `failed`, o `stopped`. `pid` e `status` sono presenti solo mentre il processo è attivo, più `waitingFor` quando status è `waiting`, che dice su cosa è bloccata la sessione, come `permission prompt` o `input needed`; `sessionId` e `name` appaiono quando impostati. Combina con `--cwd ` per filtrare |
| `claude attach ` | Collegati a una sessione in questo terminale |
| `claude logs ` | Stampa l'output recente della sessione |
| `claude stop ` | Ferma una sessione. Accetta anche `claude kill` |
| `claude respawn ` | Riavvia una sessione, in esecuzione o fermata, con la sua conversazione intatta, ad esempio per utilizzare un binario Claude Code aggiornato |
| `claude respawn --all` | Riavvia ogni sessione in esecuzione, ad esempio per spostare tutte le sessioni su un binario Claude Code aggiornato contemporaneamente |
| `claude rm ` | Rimuovi una sessione dall'elenco. Rimuove un worktree creato da Claude per la sessione se non ha modifiche non sottoposte a commit; altrimenti stampa il percorso del worktree in modo che tu possa pulirlo. Lascia in posizione un worktree che hai creato tu stesso. La trascrizione della conversazione rimane sulla tua macchina locale e rimane disponibile tramite `claude --resume` |
| `claude daemon status` | Stampa lo stato del [supervisore](#the-supervisor-process), la versione, la directory socket e il numero di worker |
| `claude daemon stop --any` | Ferma il processo supervisore e le sessioni in background che ospita. Passa `--keep-workers` per lasciare le sessioni in background in esecuzione in modo che il supervisore successivo si riconnetta ad esse. Il prossimo `claude agents` o `claude --bg` avvia un supervisore nuovo |
Come sono ospitate le sessioni in background
Ogni sessione elencata nella vista agente è considerata una sessione in background, indipendentemente dal fatto che tu sia attualmente collegato ad essa. Al contrario, una sessione avviata eseguendo `claude` direttamente è legata a quel terminale e termina quando si chiude, a meno che tu non la [invii in background](#from-inside-a-session).
Il processo supervisor
Le sessioni in background sono ospitate da un processo supervisor per utente, separato dal tuo terminale e da agent view. Il supervisor si avvia automaticamente la prima volta che metti una sessione in background o apri agent view, e non lo gestisci direttamente.
Il supervisor mantiene un processo worker pre-riscaldato pronto in modo che un dispatch da agent view o `claude --bg` si avvii senza il ritardo di un avvio a freddo. Quando esegui un dispatch, il supervisor assegna il worker pre-riscaldato alla tua sessione, applica la directory, le impostazioni e le credenziali di quella sessione ad esso, e quindi avvia una sostituzione per il prossimo dispatch. Se nessun worker pre-riscaldato sano è disponibile, il supervisor avvia un processo fresco invece.
Il supervisor e le sue sessioni si autenticano con le stesse credenziali archiviate delle tue sessioni interattive e non fanno connessioni di rete aggiuntive oltre l'API del modello. Le variabili di selezione del provider come `CLAUDE_CODE_USE_BEDROCK` e gli alias `ANTHROPIC_DEFAULT_*_MODEL` vengono letti dalla shell che ha eseguito il dispatch di ogni sessione e vengono applicati al suo worker.
{/* min-version: 2.1.174 */}Una sessione in background non eredita variabili di endpoint gateway come `ANTHROPIC_BASE_URL`, le variabili di URL base equivalenti di Bedrock, Vertex e Foundry, o un `ANTHROPIC_AUTH_TOKEN` accoppiato dalla shell che ha avviato il supervisor o dalla shell di dispatch. La sessione utilizza le tue credenziali archiviate e qualsiasi valore `env` nella directory del progetto [settings](/it/settings). Per puntare le sessioni in background in un progetto a un [gateway LLM](/it/llm-gateway), imposta `ANTHROPIC_BASE_URL` nel blocco `env` del file `.claude/settings.json` di quel progetto piuttosto che esportarlo nella tua shell. Prima della v2.1.174, una sessione in background ereditava queste variabili dalla shell di avvio del supervisor, quindi poteva utilizzare il gateway che avevi configurato in quella shell invece di quello configurato per la directory del progetto.
Ogni sessione in background è il suo proprio processo Claude Code, gestito dal supervisor piuttosto che legato al tuo terminale. Una sessione che sta attivamente lavorando, aspettando il tuo input, o ha un terminale collegato mantiene il suo processo in esecuzione. Un comando shell in background in esecuzione, un subagente, un workflow dinamico, o un monitor conta come lavoro attivo, quindi un processo a lunga esecuzione come un server di sviluppo mantiene la sessione attiva.
Una volta che una sessione finisce e rimane scollega per circa un'ora, il supervisor ferma il suo processo per liberare risorse. Una sessione che hai [bloccato](#organize-the-list) con `Ctrl+T` è esente e mantiene il suo processo in esecuzione mentre inattivo. Il transcript e lo stato rimangono su disco comunque, e la prossima volta che ti colleghi, fai peek, o rispondi a una sessione fermata, il supervisor avvia un processo fresco da dove l'ha lasciato. Quando ogni sessione è finita e nessun terminale è collegato, il supervisor stesso esce e si avvia di nuovo la prossima volta che ne hai bisogno.
Una riga vuota rimasta dalla pressione di `←` che non è mai stata data un prompt viene rimossa completamente dopo circa cinque minuti in modo che l'elenco si cancelli da solo. Le sessioni avviate con `claude --bg` e le sessioni in attesa di un prompt di configurazione come una finestra di dialogo di fiducia non vengono rimosse in questo modo.
Quando l'host ha poca memoria, il supervisor ferma prima le sessioni inattive non bloccate e ferma quelle bloccate inattive solo se ciò non ha liberato nulla.
Il supervisor osserva il binario Claude Code installato su disco e si riavvia nella nuova versione dopo che l'[auto-updater](/it/setup#auto-updates) regolare lo sostituisce. Questo è un watch di file locale, non un controllo di rete. Le sessioni in background sono processi scollegati, quindi continuano a girare attraverso il riavvio e il nuovo supervisor si ricollega a loro. Una sessione bloccata inattiva viene anche riavviata in posizione sulla nuova versione in modo che raccolga l'aggiornamento senza che tu ti ricollega.
Dove lo stato è archiviato
Lo stato della sessione è archiviato sotto la tua directory di configurazione Claude Code. Se imposti [`CLAUDE_CONFIG_DIR`](/it/env-vars), il supervisor usa quella directory invece di `~/.claude` e viene eseguito come un'istanza separata con le sue proprie sessioni.
| Path | Contents |
| :------------------------------- | :------------------------------------------------------------------------------------------------------------------------- |
| `~/.claude/daemon.log` | Log del supervisor |
| `~/.claude/daemon/roster.json` | Elenco delle sessioni in background in esecuzione, usato per ricollegarsi dopo un riavvio |
| `~/.claude/jobs//state.json` | Stato per sessione mostrato in agent view |
| `~/.claude/jobs//tmp/` | Directory di scratch per sessione. Le scritture qui non richiedono il permesso. Rimossa quando la sessione viene eliminata |
Ogni sessione in background ha la variabile di ambiente `CLAUDE_JOB_DIR` impostata sulla sua directory `~/.claude/jobs/`, quindi i comandi shell che la sessione esegue possono scrivere file temporanei su `$CLAUDE_JOB_DIR/tmp` senza collidere con sessioni parallele.
Per ispezionare questo stato senza leggere direttamente i file, esegui `claude daemon status`. Riporta se il supervisor è raggiungibile, il suo ID processo e versione, la directory socket, e quante sessioni in background sono attive. `/doctor` include un riepilogo dello stesso controllo.
Il comando avverte anche quando il supervisor in esecuzione è su una versione diversa da quella di `claude` che hai invocato, il che accade dopo un aggiornamento in cui il supervisor non si è ancora riavviato. L'avviso mostra entrambe le versioni e ti dice di eseguire `claude daemon stop --any` per raccogliere la nuova versione. Quando Claude Code è installato come servizio del sistema operativo, il comando suggerito è `claude daemon stop` senza il flag.
Su Windows, `claude daemon status` espone l'errore di file sottostante quando il file della chiave pipe del daemon è bloccato o illeggibile invece di segnalare un errore di connessione generico.
Disattiva agent view
Per disattivare completamente gli agenti in background e agent view, imposta l'[impostazione](/it/settings) `disableAgentView` su `true` o imposta la variabile di ambiente `CLAUDE_CODE_DISABLE_AGENT_VIEW`. Gli amministratori possono applicare questo attraverso [impostazioni gestite](/it/permissions#managed-settings).
Troubleshooting
`claude agents` elenca subagenti invece di aprire la visualizzazione agente
Se `claude agents` stampa un conteggio seguito dai tuoi subagenti configurati e poi esce, la visualizzazione agente non è disponibile nel tuo ambiente. Le versioni precedenti non aprivano la visualizzazione agente in ogni ambiente, incluso quando connesso tramite Bedrock, Vertex AI o Foundry. Esegui `claude update` per installare la versione più recente.
Se la visualizzazione agente ancora non si apre dopo l'aggiornamento, verifica se è stata [disattivata](#turn-off-agent-view) da un'impostazione o da una variabile di ambiente.
Agent view si apre senza sessioni
Prima di inviare la tua prima sessione, agent view mostra un breve suggerimento di onboarding con prompt di esempio al posto dell'elenco delle sessioni. Digita un prompt nell'input in basso e premi `Enter` per inviare la tua prima sessione.
Impossibile aprire agenti perché sono in esecuzione attività in background
Se premere `←` per mettere in background la sessione corrente mostra `Cannot open agents — N still running in the background`, la sessione ha lavoro in corso come un subagente, un workflow dinamico, o un comando shell in background, e la scorciatoia non lo abbandonerà silenziosamente. Esegui `/tasks` per vedere cosa è in esecuzione, quindi `/bg` per confermare l'abbandono. Vedi [From inside a session](#from-inside-a-session) per sapere cosa viene e cosa non viene trasferito quando metti in background.
Prompt rifiutato come troppo breve
L'input di dispatch si aspetta una descrizione del compito, non un'apertura conversazionale. Un prompt più corto di quattro caratteri viene rifiutato con un suggerimento `Too short` in modo che una pressione accidentale non avvii una sessione. Descrivi cosa vuoi che la sessione faccia, come `investigate the flaky checkout test`.
Le sessioni mostrano come non riuscite dopo lo spegnimento
Lo spegnimento o il riavvio della tua macchina interrompe le sessioni in background in esecuzione, quindi mostrano come non riuscite quando apri di nuovo agent view. Collegati, fai peek, o rispondi a qualsiasi sessione e la sessione si riavvia da dove l'ha lasciata.
Il sonno da solo non causa questo. Le sessioni vengono preservate durante il sonno e il supervisor si ricollega ad esse al risveglio.
Agent view dice che il servizio in background non ha risposto
Se il collegamento, il peek, o `claude logs` segnala che il servizio in background non ha risposto, il processo supervisor ha probabilmente subito un blocco. Fermalo e lascia che il prossimo `claude agents` avvii uno nuovo. Per mantenere le tue sessioni in background in esecuzione durante il riavvio, passa `--keep-workers`:
```bash theme={null}
claude daemon stop --any --keep-workers
```
Il nuovo supervisor si ricollega alle sessioni in esecuzione. Senza `--keep-workers`, il comando termina anche le sessioni in background. Il flag `--any` conferma che desideri fermare un supervisor che è stato avviato su richiesta piuttosto che come servizio installato, che è l'impostazione predefinita.
Su Windows, se il supervisor non risponde alla richiesta di arresto, il comando stampa il suo ID di processo. Termina quel processo con `taskkill /PID ` per completare il recupero. Le sessioni in background vengono comunque preservate quando hai passato `--keep-workers`.
Dispatch non riesce con `Could not resolve authentication method`
{/* min-version: 2.1.174 */}Se un dispatch in background non riesce con `Could not resolve authentication method` mentre le sessioni interattive si autenticano normalmente, il worker che ha ricevuto il dispatch non ha raccolto le credenziali. Nella versione 2.1.174 e successive il supervisor fornisce uno snapshot di credenziali fresco quando assegna un [worker pre-riscaldato](#the-supervisor-process), quindi questo errore significa che nessuna credenziale memorizzata era disponibile per il processo supervisor stesso. Conferma di aver eseguito `/login` o di aver configurato una chiave API, quindi ferma il supervisor:
```bash theme={null}
claude daemon stop --any --keep-workers
```
Il prossimo `claude agents` o `claude --bg` avvia un supervisor fresco che legge le tue credenziali memorizzate. Se ti autentichi con una variabile di ambiente come `ANTHROPIC_API_KEY` piuttosto che con `/login`, esegui quel comando successivo da una shell dove la variabile è impostata.
Vedi il [riferimento degli errori](/it/errors#could-not-resolve-authentication-method) per l'elenco completo delle cause e delle correzioni. Prima della versione 2.1.174, un worker pre-riscaldato che rimane inattivo potrebbe far emergere questo errore quando veniva assegnato a un dispatch anche quando le tue credenziali erano valide. Esegui l'aggiornamento per recuperare.
Le sessioni in background non riescono a leggere Desktop, Documents o Downloads su macOS
Su macOS, l'host della sessione in background viene eseguito come processo separato e richiede l'accesso alle cartelle protette separatamente dal tuo terminale. Se una sessione in background segnala `Operation not permitted` durante la lettura di `~/Desktop`, `~/Documents`, `~/Downloads`, o un'altra posizione protetta, concedi l'accesso in Impostazioni di Sistema sotto Privacy e Sicurezza > File e Cartelle, o abilita Accesso Completo al Disco per la voce.
Con il programma di installazione nativo, la voce appare come Claude Code e la concessione persiste tra gli aggiornamenti. Con altri metodi di installazione come Homebrew o npm, la voce mostra il percorso del binario e potrebbe dover essere concessa di nuovo dopo l'aggiornamento.
Una sessione è lenta a rispondere dopo il collegamento
Una volta che una sessione è finita e rimane scollegata per circa un'ora, il supervisor ferma il suo processo per liberare risorse. Il collegamento avvia un processo fresco da dove l'ha lasciato, il che richiede un momento. Le sessioni che stanno lavorando, aspettando te, o [fissate](#organize-the-list) non sono fermate in questo modo, quindi fissa una sessione con `Ctrl+T` per mantenerla reattiva.
`.claude/worktrees/` si sta riempiendo
Eliminare una sessione in agent view rimuove il worktree che Claude ha creato per essa. `claude rm` mantiene un worktree che ha modifiche non committate e stampa il suo percorso. Elenca le voci rimaste con `git worktree list` nella directory del progetto e rimuovi ognuna con `git worktree remove `. Vedi [Clean up worktrees](/it/worktrees#clean-up-worktrees).
Limitazioni
Agent view è un'anteprima di ricerca con le seguenti limitazioni:
* **I limiti di velocità si applicano**: le sessioni in background consumano l'utilizzo dell'abbonamento allo stesso modo delle sessioni interattive, quindi eseguire dieci agenti in parallelo utilizza la quota approssimativamente dieci volte più velocemente rispetto all'esecuzione di uno.
* **Le sessioni sono locali**: le sessioni in background vengono eseguite sulla vostra macchina. Vengono preservate durante la sospensione ma si fermano se la macchina si spegne.
* **I worktrees creati da Claude vengono eliminati con la sessione in agent view**: unite o inviate i cambiamenti prima di eliminare una sessione che ha modificato file nel suo proprio worktree. `claude rm` mantiene un worktree che ha modifiche non sottoposte a commit; un worktree che avete creato voi stessi viene lasciato in posizione.
Per altri modi di eseguire Claude in parallelo, vedi:
* [Esegui agenti in parallelo](/it/agents): confronta agent view con subagenti, team di agenti e worktrees
* [Team di agenti](/it/agent-teams): coordina più sessioni che si messaggiano l'una con l'altra
* [Claude Code on the web](/it/claude-code-on-the-web): esegui sessioni in un ambiente cloud gestito invece che localmente