> ## 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.
# Gérer plusieurs agents avec la vue agent
> Lancez et gérez plusieurs sessions Claude Code à partir d'un seul écran. La vue agent affiche ce que chaque session fait et lesquelles ont besoin de votre intervention.
La vue agent, ouverte avec `claude agents`, est un seul écran pour toutes vos sessions en arrière-plan : ce qui s'exécute, ce qui a besoin de votre intervention, et ce qui est terminé. Lancez de nouvelles sessions, observez leur état en un coup d'œil au lieu de faire défiler les transcriptions, et intervenez uniquement quand l'une d'elles a besoin de vous. Chaque session en arrière-plan est une conversation Claude Code complète qui continue de s'exécuter sans terminal attaché, vous pouvez donc l'ouvrir, répondre et partir quand vous le souhaitez.
Utilisez la vue agent quand vous avez plusieurs tâches indépendantes sur lesquelles Claude peut travailler sans que vous regardiez chaque étape. Lancez une correction de bug, un examen de pull request et une enquête sur un test instable sous forme de trois lignes, continuez à travailler dans une autre fenêtre et vérifiez quand une ligne indique qu'elle a besoin de vous ou qu'elle a un résultat.
Quand vous voulez travailler plus directement dans la session d'un agent, attachez-vous à la ligne pour entrer dans la conversation complète.
Pour comparer la vue agent avec les sous-agents, les équipes d'agents et les worktrees, consultez [Exécuter les agents en parallèle](/fr/agents).
La vue agent est un aperçu de recherche et nécessite Claude Code v2.1.139 ou ultérieur. Vérifiez votre version avec `claude --version`. L'interface et les raccourcis clavier peuvent changer à mesure que la fonctionnalité évolue.
Cette page couvre :
* [Démarrage rapide](#quick-start) : donnez à Claude une tâche à accomplir en arrière-plan, vérifiez-la et intervenez quand c'est nécessaire
* [Surveiller les sessions avec la vue agent](#monitor-sessions-with-agent-view), y compris les icônes d'état, l'aperçu et la réponse, l'attachement, l'organisation et les raccourcis clavier
* [Lancer de nouveaux agents](#dispatch-new-agents) à partir de la vue agent, depuis l'intérieur d'une session, ou depuis votre shell
* [Gérer les sessions depuis le shell](#manage-sessions-from-the-shell)
* [Comment les sessions en arrière-plan sont hébergées](#how-background-sessions-are-hosted) par le processus superviseur
Démarrage rapide
Cette procédure pas à pas couvre la boucle principale de la vue agent : dispatcher une tâche, regarder sa ligne se mettre à jour au fur et à mesure que Claude travaille, jeter un coup d'œil pour vérifier et répondre, et s'attacher pour la conversation complète. La session que vous dispatcher continue de s'exécuter après que vous fermiez la vue agent, vous pouvez donc partir et y revenir.
Depuis votre shell, exécutez :
```bash theme={null}
claude agents
```
La vue agent s'ouvre avec une entrée en bas et un tableau qui se remplit au fur et à mesure que les sessions commencent. Appuyez sur `Esc` à tout moment pour revenir à votre shell. Vos sessions continuent de s'exécuter pendant que vous êtes absent et réapparaissent la prochaine fois que vous ouvrez la vue agent.
Tapez une invite décrivant une tâche et appuyez sur `Entrée`. Une nouvelle session en arrière-plan démarre sur cette tâche et apparaît sous forme de ligne indiquant si elle fonctionne, attend votre intervention, ou est terminée. La nouvelle session utilise le modèle affiché dans l'en-tête de la vue agent et le même [mode de permission](#permission-mode-model-and-effort) que vous obtiendriez en exécutant `claude` dans ce répertoire.
Chaque invite que vous entrez ici démarre sa propre nouvelle session. Taper une autre invite et appuyer sur `Entrée` lance une deuxième session aux côtés de la première plutôt que d'envoyer un suivi à celle-ci. Vous pouvez en exécuter plusieurs en parallèle de cette façon.
Chaque session utilise votre quota d'abonnement indépendamment, consultez donc [Limitations](#limitations) avant de dispatcher plusieurs à la fois.
Sélectionnez une ligne avec les touches fléchées et appuyez sur `Espace` pour ouvrir le panneau d'aperçu. Il affiche la sortie la plus récente de la session, ou la question sur laquelle elle attend, plutôt que la transcription complète. Tapez une réponse et appuyez sur `Entrée` pour l'envoyer sans quitter la vue agent.
Appuyez sur `Entrée` ou `→` sur une ligne pour vous attacher quand vous voulez la conversation complète. La session prend le contrôle du terminal en tant que session Claude Code interactive complète. Appuyez sur `←` sur une invite vide pour vous détacher et revenir au tableau.
Pour déplacer une session que vous avez déjà ouverte dans la vue agent, exécutez `/bg` à l'intérieur, ou appuyez sur `←` sur une invite vide pour la mettre en arrière-plan et ouvrir la vue agent en une seule étape. La session continue de s'exécuter et apparaît sous forme de ligne aux côtés de celles que vous avez dispatchées.
Vous pouvez utiliser `claude agents` comme point d'entrée principal au lieu de `claude` : dispatcher chaque tâche à partir de la vue agent, vous attacher quand vous voulez la conversation complète, et appuyer sur `←` pour revenir au tableau.
Surveiller les sessions avec la vue agent
Exécutez `claude agents` pour ouvrir la vue agent. Elle prend le contrôle du terminal complet et répertorie chaque session groupée par état, avec les sessions épinglées et celles qui ont besoin de vous en haut. Chaque ligne affiche le nom de la session, l'activité actuelle, et depuis combien de temps elle a changé pour la dernière fois.
Par défaut, la liste affiche chaque session en arrière-plan que vous avez démarrée, dans tous vos projets. Une session travaillant dans un référentiel et une autre dans une worktree différente apparaissent toutes les deux ici, quel que soit le répertoire à partir duquel vous avez ouvert la vue agent. Pour limiter la liste à un projet, passez `--cwd` (nécessite Claude Code v2.1.141 ou ultérieur) :
```bash theme={null}
claude agents --cwd ~/projects/my-app
```
Cela affiche uniquement les sessions démarrées sous ce répertoire. Une session qui a [déménagé dans une worktree](#how-file-edits-are-isolated) sous `~/projects/my-app/.claude/worktrees/` compte toujours comme appartenant à `~/projects/my-app`.
Les sessions interactives que vous avez ouvertes dans d'autres terminaux n'apparaissent pas jusqu'à ce que vous les [mettiez en arrière-plan](#from-inside-a-session). Les [sous-agents](/fr/sub-agents) et les [coéquipiers](/fr/agent-teams) qu'une session génère ne sont pas répertoriés comme des lignes séparées.
```text theme={null}
Épinglées
✽ clawd walk cycle Write assets/sprites/clawd-walk.png 3m
Prêtes pour examen
∙ jump physics Opened PR with collision fix PR #2048 2h
Nécessite une intervention
✻ power-up design needs input: double jump or wall climb? 1m
En cours
✽ collision detection Edit src/physics/CollisionSystem.ts 2m
✢ playtest level 3 run 12 · all checkpoints cleared in 4m
Terminées
✻ title screen result: menu, options, and credits done 9m
∙ sound effects result: 14 SFX exported to assets/audio 4h
… 6 more
```
Lire l'état de la session
Chaque ligne commence par une icône dont la couleur et l'animation montrent l'état de la session :
| État | L'icône s'affiche comme | Ce que cela signifie |
| :------------------------- | :---------------------- | :-------------------------------------------------------------------------------- |
| En cours | Animée | Claude exécute activement des outils ou génère une réponse |
| Nécessite une intervention | Jaune | Claude attend une question spécifique ou une décision de permission de votre part |
| Inactif | Estompé | La session n'a rien à faire et est prête pour votre prochain message |
| Terminée | Vert | La tâche s'est terminée avec succès |
| Échouée | Rouge | La tâche s'est terminée avec une erreur |
| Arrêtée | Gris | La session a été arrêtée avec `Ctrl+X` ou `claude stop` |
Séparément, la forme de l'icône indique si le processus sous-jacent s'exécute :
| Forme | Ce que cela signifie |
| :--------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
| `✻` ou `✽` animé | Le processus de la session est actif et répond immédiatement |
| `∙` | Le processus a quitté. Vous pouvez toujours apercevoir, répondre, ou vous attacher, et Claude redémarre à partir de là où il s'était arrêté |
| `✢` | Une session [`/loop`](/fr/scheduled-tasks) dormant entre les itérations. La ligne affiche son nombre d'exécutions et un compte à rebours |
L'étiquette `PR #N` qui peut apparaître au bord droit d'une ligne est le [statut de la pull request que la session a ouvert](#pull-request-status), pas une partie de l'icône d'état. Quand une session a ouvert plus d'une pull request, l'étiquette affiche un nombre à la place, comme `3 PRs`.
Le titre de l'onglet du terminal affiche le nombre d'entrées en attente pendant que la vue agent est ouverte : `2 awaiting input · claude agents` quand les sessions ont besoin d'une intervention, ou `claude agents` quand ce n'est pas le cas.
Les sessions en arrière-plan n'ont besoin d'aucun terminal ouvert pour continuer à fonctionner. Un [processus superviseur](#the-supervisor-process) séparé les exécute, vous pouvez donc fermer la vue agent, fermer votre shell, ou démarrer une nouvelle session interactive et votre travail lancé continue.
L'état de la session persiste sur le disque via les mises à jour automatiques et les redémarrages du superviseur. Les sessions sont également préservées quand votre machine se met en veille. Leurs processus reprennent au réveil et le superviseur se reconnecte à eux au lieu de traiter l'écart de temps comme inactif. L'arrêt arrête toujours les sessions en cours ; consultez [Les sessions s'affichent comme échouées après l'arrêt](#sessions-show-as-failed-after-shutdown) pour savoir comment les récupérer.
Résumés des lignes
Le résumé d'une ligne dans chaque ligne est généré par un [modèle de classe Haiku](/fr/model-config) afin que la ligne puisse vous dire ce que la session fait, ce qu'elle a besoin, ou ce qu'elle a produit sans ouvrir la transcription. Pendant qu'une session fonctionne activement, le résumé s'actualise au maximum une fois toutes les 15 secondes, plus une fois quand chaque tour se termine.
À partir de v2.1.161, quand la session exécute deux ou plusieurs éléments de travail parallèles, comme des sous-agents, des commandes shell en arrière-plan, ou des moniteurs, un nombre `done/total` comme `2/5` apparaît avant le texte du résumé.
Chaque actualisation est une courte demande de classe Haiku via votre fournisseur normal, facturée et traitée selon les mêmes [conditions d'utilisation des données](/fr/data-usage) que la session elle-même. Sur les fournisseurs tiers tels que Bedrock, Vertex AI, Microsoft Foundry, et les passerelles personnalisées, la demande revient au modèle principal de la session quand aucun modèle Haiku n'est configuré. Définissez [`ANTHROPIC_DEFAULT_HAIKU_MODEL`](/fr/model-config#environment-variables) pour choisir le modèle pour ces résumés sur ces fournisseurs.
Statut de la pull request
Quand une session ouvre une pull request, une étiquette `PR #1234` apparaît au bord droit de la ligne, liée à la pull request dans les terminaux qui supportent les hyperliens. L'étiquette persiste quand vous envoyez un suivi à la session, donc la pull request reste visible pendant que la ligne revient à la progression en direct.
Quand une session a ouvert plus d'une pull request, l'étiquette affiche un nombre à la place, comme `3 PRs`, colorée par la pull request ouverte qui a le plus besoin d'attention. Ouvrez le [panneau d'aperçu](#peek-and-reply) pour les voir toutes.
Le numéro de la pull request est coloré par son statut :
| Couleur | Statut de la pull request |
| :------ | :----------------------------------------------------------------------- |
| Jaune | En attente de vérifications ou d'examen, ou les vérifications ont échoué |
| Vert | Les vérifications ont réussi et aucun examen ne bloque |
| Violet | Fusionnée |
| Gris | Brouillon ou fermée |
Pour la plupart des tâches, cette colonne est l'endroit où vous collectez le résultat : examinez et fusionnez la pull request quand son numéro devient vert.
Aperçu et réponse
Appuyez sur `Espace` sur une ligne sélectionnée pour ouvrir le panneau d'aperçu. Il affiche ce que la session a besoin de vous, sa sortie la plus récente, et toutes les pull requests qu'elle a ouvertes. La plupart du temps, c'est suffisant, et vous n'avez jamais besoin d'ouvrir la transcription complète.
À partir de v2.1.161, quand la session exécute des éléments de travail parallèles, le panneau nomme également le plus long en cours d'exécution et depuis combien de temps il s'exécute, afin que vous puissiez voir ce que la session attend sans vous attacher.
Tapez une réponse dans le panneau d'aperçu et appuyez sur `Entrée` pour l'envoyer à cette session. Quand la session pose une question à choix multiples, le panneau d'aperçu affiche les options et vous pouvez appuyer sur une touche numérique pour en choisir une. Pour les autres sessions bloquées, appuyez sur `Tab` pour remplir l'entrée avec une réponse suggérée que vous pouvez modifier avant d'envoyer. Préfixez une réponse avec `!` pour envoyer une commande Bash à la place.
À partir de v2.1.145, avec la [dictée vocale](/fr/voice-dictation) activée, maintenez ou appuyez sur votre touche push-to-talk pendant que l'entrée de réponse est active pour dicter une réponse au lieu de la taper. La même chose fonctionne dans l'entrée de lancement en bas de la vue agent.
Utilisez `↑` et `↓` pour apercevoir les sessions adjacentes sans fermer le panneau, ou `→` pour vous attacher.
S'attacher à une session
Appuyez sur `Entrée` ou `→` sur une ligne sélectionnée pour vous attacher. La vue agent est remplacée par la session interactive complète. Quand vous vous attachez, Claude affiche un court récapitulatif de ce qui s'est passé pendant que vous étiez absent.
Pendant que vous êtes attaché, la session se comporte comme n'importe quelle autre session Claude Code : chaque [commande](/fr/commands), raccourci clavier, et fonctionnalité fonctionne.
Les sessions attachées s'affichent toujours en [mode plein écran](/fr/fullscreen), quel que soit votre paramètre `tui`, car une session en arrière-plan n'a pas d'historique de terminal à ajouter. Faites défiler avec `PgUp`, `PgDn`, ou la molette de la souris, et appuyez sur `Ctrl+O` pour le mode transcription. Le défilement natif de votre terminal et le mode copie tmux affichent uniquement la fenêtre d'affichage actuelle, comme lorsque vous exécutez n'importe quelle application plein écran.
Appuyez sur `←` sur une invite vide pour vous détacher et revenir à la vue agent. Si une boîte de dialogue a le focus et ne répond pas à `←`, appuyez sur `Ctrl+Z` pour vous détacher immédiatement.
`Ctrl+C` conserve son comportement d'interruption standard pendant que vous êtes attaché : il annule une réponse en cours d'exécution ou une commande shell `!` plutôt que de vous détacher. Appuyer sur `Ctrl+C` deux fois sur une invite vide vous détache, comme dans n'importe quelle session.
Se détacher n'arrête jamais une session en arrière-plan : `←`, `Ctrl+Z`, `/exit`, et double `Ctrl+C` ou double `Ctrl+D` la laissent toutes s'exécuter. Pour terminer une session depuis l'intérieur, exécutez `/stop`.
Appuyer sur `←` sur une invite vide fonctionne à partir de n'importe quelle session Claude Code, pas seulement celles auxquelles vous vous êtes attaché à partir de la vue agent. Elle met en arrière-plan la session actuelle et ouvre la vue agent avec cette ligne sélectionnée, vous pouvez donc basculer entre les sessions sans quitter le terminal. La ligne est créée même à partir d'une session nouvelle sans historique de conversation, donc `→` y revient. Quand cette ligne est la seule, la vue agent affiche un indice d'intégration en dessous. Vous pouvez désactiver ce raccourci dans `/config` (le paramètre `leftArrowOpensAgents`).
Organiser la liste
La vue agent groupe les sessions afin que celles qui ont besoin d'une intervention soient en haut, avec `Prêtes pour examen` et `Nécessite une intervention` au-dessus de `En cours` et `Terminées`. Ces noms de groupe ne correspondent pas un-à-un aux [états](#read-session-state) ci-dessus : une session se déplace vers `Prêtes pour examen` quand elle a une pull request ouverte, et `Terminées` collecte les sessions terminées, échouées et arrêtées ensemble. Appuyez sur `Ctrl+S` pour grouper par répertoire à la place. Votre choix persiste entre les exécutions.
Dans un groupe :
* Appuyez sur `Ctrl+T` pour épingler une session en haut et [garder son processus en cours d'exécution](#the-supervisor-process) pendant l'inactivité
* Appuyez sur `Shift+↑` ou `Shift+↓` pour réorganiser les sessions
* Appuyez sur `Ctrl+R` pour renommer une session
* Appuyez sur `Entrée` sur un en-tête de groupe pour le réduire
Pour supprimer une session de la liste, appuyez sur `Ctrl+X` pour l'arrêter et `Ctrl+X` à nouveau dans les deux secondes pour la supprimer. Appuyer sur `Ctrl+X` sur un en-tête de groupe supprime chaque session de ce groupe après confirmation.
La suppression supprime la session de la vue agent. Si Claude a [créé une worktree](#how-file-edits-are-isolated) pour la session, la suppression supprime également cette worktree, y compris toutes les modifications non validées qu'elle contient, donc poussez ou validez le travail que vous voulez conserver en premier. Une worktree que vous avez créée vous-même et dans laquelle vous avez démarré la session est laissée en place. La transcription de conversation reste sur votre machine locale et reste disponible via `claude --resume`.
Les sessions terminées plus anciennes se replient dans une ligne `… N more` pour garder la liste courte. Les échecs et les sessions avec une pull request ouverte restent toujours visibles.
Filtrer les sessions
Tapez dans l'entrée de lancement pour filtrer au lieu de lancer :
| Filtre | Affiche |
| :------------------------- | :----------------------------------------------------------------------------------------------------------- |
| `a:` | Sessions exécutant l'agent nommé |
| `s:` | Sessions dans l'état donné, comme `s:working`. Accepte également `s:blocked` pour tout ce qui attend de vous |
| `#` ou une URL PR | La session travaillant sur cette pull request |
| N'importe quelle autre URL | La session dont la première invite contenait cette URL |
Raccourcis clavier
Appuyez sur `?` dans la vue agent pour voir chaque raccourci en contexte. Le tableau ci-dessous les résume.
| Raccourci | Action |
| :-------------------- | :------------------------------------------------------------------------------------------------- |
| `↑` / `↓` | Se déplacer entre les lignes |
| `Entrée` | S'attacher à la session sélectionnée, ou lancer si du texte est dans l'entrée |
| `Espace` | Ouvrir ou fermer le panneau d'aperçu pour la session sélectionnée |
| `Shift+Entrée` | Lancer et s'attacher immédiatement |
| `→` | S'attacher à la session sélectionnée |
| `Alt+1`..`Alt+9` | S'attacher à la session 1–9 dans le répertoire de la session active |
| `Tab` | Sur une entrée vide, parcourir tous les sous-agents. Sinon appliquer la suggestion en surbrillance |
| `Ctrl+S` | Basculer le groupement entre l'état et le répertoire |
| `Ctrl+T` | Épingler ou dépingler la session sélectionnée |
| `Ctrl+R` | Renommer la session sélectionnée |
| `Ctrl+G` | Ouvrir l'invite de lancement dans votre `$VISUAL` ou `$EDITOR` |
| `Ctrl+X` | Arrêter la session ; appuyez à nouveau dans les deux secondes pour la supprimer |
| `Shift+↑` / `Shift+↓` | Réorganiser la session sélectionnée |
| `Esc` | Fermer le panneau d'aperçu, effacer l'entrée, ou quitter |
| `Ctrl+C` | Effacer l'entrée ; appuyez deux fois pour quitter |
| `?` | Afficher tous les raccourcis |
Lancer de nouveaux agents
Vous pouvez lancer de nouvelles sessions en arrière-plan à partir de la vue agent, envoyer une session interactive existante en arrière-plan, ou en démarrer une directement depuis le shell.
À partir de la vue agent
Tapez une invite dans l'entrée en bas de la vue agent et appuyez sur `Entrée` pour démarrer une nouvelle session en arrière-plan. La session est nommée automatiquement à partir de l'invite ; renommez-la plus tard avec `Ctrl+R`.
Collez une image dans l'invite pour inclure une capture d'écran ou un diagramme avec la tâche.
Préfixez ou mentionnez des parties de l'invite pour contrôler comment la session démarre :
| Entrée | Effet |
| :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ` ` | Si le premier mot correspond à un nom de [sous-agent](/fr/sub-agents) personnalisé, ce sous-agent s'exécute comme l'agent principal de la session avec la configuration de son frontmatter |
| `@` | Mentionnez un sous-agent personnalisé n'importe où dans l'invite pour l'exécuter comme l'agent principal |
| `@` | Mentionnez un référentiel sous le répertoire à partir duquel vous avez ouvert la vue agent pour exécuter la session là |
| `/` | Suggérez des [skills](/fr/skills) et des [commandes](/fr/commands) à lancer comme l'invite |
| `! ` | Exécutez une commande shell comme une tâche en arrière-plan au lieu de démarrer une session Claude. La tâche apparaît comme une ligne à laquelle vous pouvez vous attacher, regarder et vous détacher |
| `#` ou une URL de pull request | Si une session travaille déjà sur cette PR, sélectionnez-la au lieu de lancer |
| `Shift+Entrée` | Lancer et s'attacher immédiatement à la nouvelle session |
Un petit ensemble de commandes s'exécutent dans la vue agent elle-même au lieu de lancer : `/exit` et `/quit` ferment la vue agent, `/logout` vous déconnecte, et `/model` définit le [modèle de lancement](#set-the-model). Les skills, vos propres commandes, et les built-ins qui développent les invites comme `/init` sont envoyés à une nouvelle session en arrière-plan comme leur première invite. Les autres commandes built-in affichent plutôt un indice `attach to a session to run it`.
Empaqueter une tâche récurrente comme un [skill](/fr/skills) vous permet de démarrer le même workflow à partir de la vue agent à plusieurs reprises sans retaper l'invite.
Quand le même `@name` correspond à la fois à un sous-agent et à un référentiel frère, le sous-agent prend la priorité. La correspondance du premier mot sans `@` s'applique également, donc une invite qui commence par l'un de vos noms de sous-agent lance ce sous-agent plutôt que de traiter le mot comme du texte brut. Utilisez la forme `@` quand vous voulez être explicite, ou commencez l'invite par un mot différent pour éviter la correspondance.
Lancer vers un répertoire spécifique
Une nouvelle session s'exécute dans le répertoire à partir duquel vous avez ouvert la vue agent. Pour cibler un répertoire différent :
* Ouvrez `claude agents` dans ce répertoire.
* Ouvrez `claude agents` dans un répertoire parent qui contient plusieurs référentiels et mentionnez-en un avec `@` dans l'invite pour exécuter la session là.
* Depuis le shell, `cd` dans le répertoire et exécutez `claude --bg ""`.
Quand la vue agent est groupée par répertoire, le répertoire de la ligne en surbrillance devient la cible de lancement, vous pouvez donc faire défiler jusqu'à un groupe et lancer dedans sans retaper le chemin.
À partir d'une session
Exécutez `/background` ou son alias `/bg` pour déplacer la conversation actuelle dans une session en arrière-plan. Passez une invite comme `/bg run the test suite and fix any failures` pour donner une instruction supplémentaire d'abord. Si Claude répond quand vous exécutez `/bg`, la réponse continue dans la session en arrière-plan.
Mettre en arrière-plan à partir d'une session interactive démarre un processus nouveau qui reprend à partir de la conversation enregistrée, donc l'exécution de sous-agents, de [moniteurs](/fr/tools-reference#monitor-tool), et de commandes en arrière-plan ne se transfèrent pas à celui-ci. Claude vous demande de confirmer avant de mettre en arrière-plan quand l'un d'eux s'exécute. Une fois en arrière-plan, la session peut démarrer de nouveaux sous-agents, moniteurs, et commandes en arrière-plan, et ceux-ci continuent de s'exécuter lors des détachements et réattachements ultérieurs.
Les drapeaux de configuration de la session de lancement d'origine se reportent à la session mise en arrière-plan, donc ses serveurs MCP, paramètres et modèle de secours restent en vigueur :
* `--mcp-config` et `--strict-mcp-config`
* `--settings`
* `--add-dir`
* `--plugin-dir`
* `--fallback-model`
* `--allow-dangerously-skip-permissions`
Les répertoires que vous avez ajoutés pendant la session avec [`/add-dir`](/fr/permissions#additional-directories-grant-file-access-not-configuration) se reportent également.
Reporter `--allow-dangerously-skip-permissions` maintient `bypassPermissions` accessible dans la session mise en arrière-plan, mais cela ne confère rien de nouveau. Le mode nécessite toujours la même acceptation interactive unique décrite dans [Mode de permission, modèle et effort](#permission-mode-model-and-effort) avant que toute session puisse l'utiliser.
À partir du shell
Passez `--bg` ou sa forme longue `--background` pour démarrer une session qui va directement en arrière-plan :
```bash theme={null}
claude --bg "investigate the flaky SettingsChangeDetector test"
```
Pour exécuter un sous-agent spécifique comme l'agent principal de la session, combinez `--bg` avec `--agent` :
```bash theme={null}
claude --agent code-reviewer --bg "address review comments on PR 1234"
```
Passez `--name` pour définir le nom d'affichage de la session dans la vue agent au lieu du nom généré automatiquement :
```bash theme={null}
claude --bg --name "flaky-test-fix" "investigate the flaky SettingsChangeDetector test"
```
Après avoir mis en arrière-plan, Claude affiche l'ID court de la session et les commandes pour la gérer. Quand vous passez `--name`, le nom apparaît après l'ID court :
```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
```
Exécuter une commande shell
Pour exécuter une commande shell comme une tâche en arrière-plan au lieu d'une session Claude, tapez `!` comme premier caractère de l'entrée de lancement de la vue agent. Le `!` s'affiche comme un préfixe et tout ce que vous tapez après lui est la commande. L'exemple suivant lance `pytest -x` à partir de la boîte d'entrée de la vue agent :
```text theme={null}
! pytest -x
```
Appuyez sur `Entrée` pour démarrer la tâche. La même tâche peut également être lancée directement depuis votre shell avec `--exec` :
```bash theme={null}
claude --bg --exec 'pytest -x'
```
La commande s'exécute comme une tâche sauvegardée par PTY et apparaît comme une ligne dans la vue agent, avec la ligne de sortie la plus récente comme son statut. Une tâche shell exécute la commande à la place de Claude, donc aucun modèle n'est invoqué et la sortie n'est pas envoyée à aucune session.
Pour voir la sortie, attachez-vous à la ligne, appuyez sur `Espace` pour jeter un œil sans vous attacher, ou exécutez `claude logs ` depuis votre shell. La sortie capturée reste en mémoire et n'est pas écrite sur le disque. La ligne et sa sortie se nettoient automatiquement environ cinq minutes après la sortie de la commande, donc lisez-la avant si vous avez besoin du résultat.
Comment les modifications de fichiers sont isolées
Chaque session en arrière-plan, qu'elle soit démarrée à partir de la vue agent, `/bg`, ou `claude --bg`, démarre dans votre répertoire de travail. Avant de modifier des fichiers, Claude déplace la session dans une [git worktree](/fr/worktrees) isolée sous `.claude/worktrees/`, afin que les sessions parallèles puissent lire le même checkout mais chacune écrit dans la sienne.
Claude ignore la worktree quand :
* La session est déjà à l'intérieur d'une git worktree liée, que Claude l'ait créée sous `.claude/worktrees/` ou que vous l'ayez créée avec `git worktree add` ailleurs
* Le répertoire de travail n'est pas un référentiel git et aucun hook [`WorktreeCreate`](/fr/hooks#worktreecreate) n'est configuré
* L'écriture est en dehors du répertoire de travail
Pour désactiver l'isolation de worktree pour un référentiel où les git worktrees ne sont pas pratiques, définissez [`worktree.bgIsolation`](/fr/settings#worktree-settings) sur `"none"`. Les sessions en arrière-plan modifient alors votre copie de travail directement sans d'abord se déplacer dans une worktree. Ajoutez le paramètre au fichier `.claude/settings.json` du projet :
```json theme={null}
{
"worktree": {
"bgIsolation": "none"
}
}
```
Le paramètre `worktree.bgIsolation` nécessite Claude Code v2.1.143 ou ultérieur.
En dehors d'un référentiel git, les sessions écrivent dans le répertoire de travail directement et ne sont pas isolées les unes des autres, donc évitez de lancer des sessions parallèles qui modifient les mêmes fichiers. Si vous utilisez un système de contrôle de version différent, configurez un hook [`WorktreeCreate`](/fr/worktrees#non-git-version-control) et Claude isole les modifications de la même manière qu'il le fait pour git.
Supprimer une session dans la vue agent (`Ctrl+X` deux fois) supprime une worktree que Claude a créée pour elle, y compris les modifications non validées, donc fusionnez ou poussez les modifications que vous voulez conserver d'abord. Supprimer depuis le shell avec [`claude rm`](#manage-sessions-from-the-shell) conserve une worktree qui a des modifications non validées et affiche son chemin pour que vous puissiez la nettoyer vous-même. Une worktree que vous avez créée vous-même et dans laquelle vous avez démarré la session est laissée en place de toute façon.
Pour trouver le chemin de la worktree d'une session, jetez un œil à la session ou attachez-vous et vérifiez son répertoire de travail.
Un [sous-agent](/fr/sub-agents) que la session en arrière-plan lance hérite du répertoire de travail de la session, donc ses modifications de fichiers se retrouvent dans la worktree de la session plutôt que dans votre copie de travail. Pour donner à un sous-agent sa propre worktree séparée à la place, définissez [`isolation: worktree`](/fr/sub-agents#supported-frontmatter-fields) dans son frontmatter ou passez `isolation: "worktree"` lors de son lancement.
Définir le modèle
Le nom du modèle affiché dans l'en-tête de la vue agent est la valeur par défaut du lancement. Les nouvelles sessions que vous démarrez à partir de l'entrée utilisent ce modèle, qui provient du paramètre [`model`](/fr/settings#available-settings) dans vos paramètres utilisateur. Définissez-le en sélectionnant un modèle dans le sélecteur [`/model`](/fr/model-config), ou modifiez le paramètre directement. Pour le remplacer pour l'ensemble de la session de la vue agent, passez `--model` lors de l'ouverture de la vue agent. Voir [Mode de permission, modèle et effort](#permission-mode-model-and-effort).
Pour changer la valeur par défaut du lancement à partir de la vue agent, tapez `/model` suivi d'un nom de modèle dans l'entrée de lancement et appuyez sur `Entrée`. L'en-tête se met à jour pour afficher ce modèle avec un marqueur `(session)`, et les sessions que vous lancez après utilisent ce modèle. Tapez `/model default` pour effacer le remplacement et revenir à la valeur par défaut du lancement. Ce remplacement dure pour le reste de l'exécution actuelle de `claude agents`, n'écrit pas dans votre fichier de paramètres, et nécessite Claude Code v2.1.172 ou ultérieur. {/* min-version: 2.1.172 */} L'exemple suivant lance une session sur Opus et la suivante sur Sonnet :
```text theme={null}
/model opus
refactor auth
/model sonnet
run the test suite
```
Chaque session en arrière-plan peut s'exécuter sur un modèle différent. Pour le remplacer pour une session :
* Depuis le shell, passez `--model` avec `claude --bg`.
* Attachez-vous à une session en cours d'exécution, ouvrez `/model`, et appuyez sur `s` sur un modèle pour basculer pour cette session uniquement. Le changement persiste si la session est relancée.
* Lancez un [sous-agent](/fr/sub-agents) dont le frontmatter définit un champ `model`.
Mode de permission, modèle et effort
Une session en arrière-plan lit ses [paramètres](/fr/settings) à partir du répertoire dans lequel elle s'exécute, de la même manière que si vous aviez démarré `claude` là. Cela inclut les valeurs [`env`](/fr/settings#available-settings) dans les paramètres du projet, donc une variable `ANTHROPIC_MODEL` ou de fournisseur définie là s'applique aux sessions en arrière-plan dans ce répertoire.
La sélection du fournisseur cloud, comme `CLAUDE_CODE_USE_BEDROCK` ou `CLAUDE_CODE_USE_VERTEX`, et les alias `ANTHROPIC_DEFAULT_*_MODEL` suivent le shell qui a lancé la session. Les variables de point de terminaison de passerelle comme `ANTHROPIC_BASE_URL` et son `ANTHROPIC_AUTH_TOKEN` associé ne le font pas. Voir [le processus superviseur](#the-supervisor-process) pour savoir comment les sessions en arrière-plan sourçent les paramètres du fournisseur et les identifiants.
Le [mode de permission](/fr/permissions) dépend de la façon dont vous avez démarré la session. Mettre en arrière-plan une session existante avec `/bg` ou `←` conserve le mode de permission actuel, donc une session que vous avez basculée vers `acceptEdits` ou `auto` reste dans ce mode après détachement. Lancer à partir de l'entrée de la vue agent ou exécuter `claude --bg` depuis votre shell utilise le `defaultMode` à partir des paramètres de ce répertoire, ou le `permissionMode` à partir du [frontmatter du sous-agent lancé](/fr/sub-agents#supported-frontmatter-fields).
Le mode de permission, le modèle et l'effort avec lesquels une session en arrière-plan a été démarrée, ainsi que les [drapeaux de configuration qu'elle porte](#from-inside-a-session), persistent tous quand le superviseur [arrête et redémarre](#the-supervisor-process) ultérieurement le processus de la session. Une session que vous avez lancée avec `claude --bg --dangerously-skip-permissions` ou `claude --bg --permission-mode bypassPermissions` reste dans `bypassPermissions` après ce redémarrage au lieu de revenir au `defaultMode` du répertoire, et un modèle ou un effort que vous avez changé en milieu de session avec `/model` ou `/effort` est conservé.
Pour définir les valeurs par défaut pour chaque session que vous lancez à partir de la vue agent, passez l'un de `--permission-mode`, `--model`, `--effort`, ou `--agent` lors de son ouverture :
```bash theme={null}
claude agents --permission-mode plan --model opus --effort high
```
`--agent` définit le [sous-agent](/fr/sub-agents) utilisé quand une invite de lancement ne nomme pas un, soit avec `@name` soit comme premier mot. Il prend par défaut le paramètre [`agent`](/fr/settings#available-settings) s'il en existe un, sinon l'agent intégré `claude` fourre-tout. Nommer un sous-agent dans l'entrée de lancement remplace les deux.
`claude agents` accepte également `--dangerously-skip-permissions` comme raccourci pour `--permission-mode bypassPermissions`, et `--allow-dangerously-skip-permissions` pour rendre `bypassPermissions` disponible dans le cycle `Shift+Tab` de chaque session lancée sans démarrer dans ce mode. Les deux correspondent aux [drapeaux CLI de haut niveau](/fr/cli-reference).
Ces drapeaux ont été ajoutés au fil des versions. Les versions antérieures les rejettent avec une erreur unknown-option.
| Drapeau ou paramètre | Version minimale |
| :--------------------------------------------------------------------------- | :------------------------------------ |
| `--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`, et respect du paramètre `agent` pour les sessions lancées | v2.1.157 {/* min-version: 2.1.157 */} |
Avant v2.1.157, la vue agent ignore le paramètre `agent` et lance l'agent intégré `claude`.
Les valeurs par défaut actives apparaissent dans le pied de page sous l'entrée de lancement.
Sans ces drapeaux, la session utilise le `defaultMode` à partir des paramètres de ce répertoire ou le `permissionMode` à partir du [frontmatter du sous-agent lancé](/fr/sub-agents#supported-frontmatter-fields), et le modèle affiché dans l'en-tête de la vue agent.
Utiliser `bypassPermissions` ou `auto` est refusé jusqu'à ce que vous ayez accepté ce mode en exécutant `claude` avec lui une fois de manière interactive, puisque ces modes permettent à une session que vous ne regardez pas d'agir sans approbation. La même chose s'applique que vous passiez le mode à `claude agents` ou à `claude --bg --permission-mode`.
Paramètres, plugins et serveurs MCP
La vue agent accepte les mêmes drapeaux de configuration que `claude` pour charger les paramètres, les plugins, les serveurs MCP et les répertoires supplémentaires. Ces drapeaux nécessitent Claude Code v2.1.142 ou ultérieur. Chaque drapeau s'applique à la vue agent elle-même et est transmis à chaque session que vous lancez à partir de celle-ci, donc un plugin ou un serveur MCP que vous chargez de cette manière est disponible dans ces sessions aussi.
| Drapeau | Effet |
| :----------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------ |
| [`--settings `](/fr/settings) | Remplacer les paramètres pour la vue agent et les sessions lancées |
| [`--add-dir `](/fr/permissions#additional-directories-grant-file-access-not-configuration) | Accorder l'accès aux fichiers à un répertoire supplémentaire |
| [`--plugin-dir `](/fr/plugins) | Charger un plugin à partir d'un répertoire local |
| [`--mcp-config `](/fr/mcp) | Charger les serveurs MCP à partir d'un fichier de configuration ou d'une chaîne JSON |
| `--strict-mcp-config` | Utiliser uniquement les serveurs MCP de `--mcp-config`, en ignorant les autres configurations MCP |
Répétez `--add-dir`, `--plugin-dir`, ou `--mcp-config` une fois par valeur. La forme séparée par des espaces, comme `--add-dir a b c`, n'est pas prise en charge avec `claude agents`.
L'exemple suivant ouvre la vue agent avec un remplacement de paramètres et un répertoire supplémentaire :
```bash theme={null}
claude agents --settings ./ci-settings.json --add-dir ../shared-lib
```
Gérer les sessions depuis le shell
Chaque session en arrière-plan a un ID court que vous pouvez utiliser depuis le shell. L'ID est affiché quand vous démarrez une session avec `claude --bg`, et l'ID de chaque session est son nom de répertoire sous `~/.claude/jobs/`. Ces commandes sont utiles pour les scripts ou quand vous ne voulez pas ouvrir la vue agent.
| Commande | Objectif |
| :--------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `claude agents` | Ouvrir la vue agent |
| `claude agents --cwd ` | Ouvrir la vue agent limitée aux sessions démarrées sous `` |
| `claude agents --json` | Afficher les sessions actives en tant que tableau JSON et quitter : chaque session active, plus les sessions en arrière-plan qui travaillent encore ou sont bloquées même quand leur processus a quitté. Ajoutez `--all` pour inclure aussi les sessions en arrière-plan terminées. Chaque entrée a `cwd`, `kind`, et `startedAt`. Les entrées en arrière-plan ont aussi `id`, utilisable avec `claude attach`/`logs`/`stop`, et `state` : l'une de `working`, `blocked`, `done`, `failed`, ou `stopped`. `pid` et `status` sont présents uniquement tant que le processus est actif, plus `waitingFor` quand status est `waiting`, qui indique sur quoi la session est bloquée, comme `permission prompt` ou `input needed` ; `sessionId` et `name` apparaissent quand ils sont définis. Combinez avec `--cwd ` pour filtrer |
| `claude attach ` | S'attacher à une session dans ce terminal |
| `claude logs ` | Afficher la sortie récente de la session |
| `claude stop ` | Arrêter une session. Accepte aussi `claude kill` |
| `claude respawn ` | Redémarrer une session, en cours d'exécution ou arrêtée, avec sa conversation intacte, par exemple pour utiliser un binaire Claude Code mis à jour |
| `claude respawn --all` | Redémarrer chaque session en cours d'exécution, par exemple pour déplacer toutes les sessions vers un binaire Claude Code mis à jour en une seule fois |
| `claude rm ` | Supprimer une session de la liste. Supprime une worktree que Claude a créée pour la session si elle n'a pas de modifications non validées ; sinon affiche le chemin de la worktree pour que vous puissiez la nettoyer. Laisse en place une worktree que vous avez créée vous-même. La transcription de la conversation reste sur votre machine locale et reste disponible via `claude --resume` |
| `claude daemon status` | Afficher l'état du [superviseur](#the-supervisor-process), la version, le répertoire socket et le nombre de workers |
| `claude daemon stop --any` | Arrêter le processus superviseur et les sessions en arrière-plan qu'il héberge. Passez `--keep-workers` pour laisser les sessions en arrière-plan en cours d'exécution afin que le superviseur suivant se reconnecte à elles. Le prochain `claude agents` ou `claude --bg` démarre un nouveau superviseur |
Comment les sessions en arrière-plan sont hébergées
Chaque session listée dans la vue agent est considérée comme une session en arrière-plan, que vous y soyez actuellement attaché ou non. En contraste, une session démarrée en exécutant `claude` directement est liée à ce terminal et se termine quand il se ferme, sauf si vous [l'envoyez en arrière-plan](#from-inside-a-session).
Le processus superviseur
Les sessions en arrière-plan sont hébergées par un processus superviseur par utilisateur, séparé de votre terminal et de la vue agent. Le superviseur démarre automatiquement la première fois que vous mettez une session en arrière-plan ou ouvrez la vue agent, et vous ne le gérez pas directement.
Le superviseur maintient un processus worker préchauffé prêt pour qu'une dispatch depuis la vue agent ou `claude --bg` démarre sans le délai d'un lancement à froid. Quand vous dispatchez, le superviseur assigne le worker préchauffé à votre session, applique le répertoire, les paramètres et les identifiants de cette session à celui-ci, puis démarre un remplacement pour la prochaine dispatch. Si aucun worker préchauffé sain n'est disponible, le superviseur lance un processus frais à la place.
Le superviseur et ses sessions s'authentifient avec les mêmes identifiants stockés que vos sessions interactives et ne font aucune connexion réseau supplémentaire au-delà de l'API du modèle. Les variables de sélection de fournisseur telles que `CLAUDE_CODE_USE_BEDROCK` et les alias `ANTHROPIC_DEFAULT_*_MODEL` sont lues depuis le shell qui a dispatché chaque session et sont appliquées à son worker.
{/* min-version: 2.1.174 */}Une session en arrière-plan n'hérite pas des variables de point de terminaison de passerelle telles que `ANTHROPIC_BASE_URL`, les variables d'URL de base Bedrock, Vertex et Foundry équivalentes, ou un `ANTHROPIC_AUTH_TOKEN` appairé depuis le shell qui a démarré le superviseur ou depuis le shell de dispatch. La session utilise vos identifiants stockés et toute valeur `env` dans le bloc [settings](/fr/settings) du répertoire du projet à la place. Pour pointer les sessions en arrière-plan dans un projet vers une [passerelle LLM](/fr/llm-gateway), définissez `ANTHROPIC_BASE_URL` dans le bloc `env` du fichier `.claude/settings.json` de ce projet plutôt que de l'exporter dans votre shell. Avant la v2.1.174, une session en arrière-plan héritait ces variables du shell de lancement du superviseur, donc elle pouvait utiliser la passerelle que vous aviez configurée dans ce shell au lieu de celle configurée pour le répertoire du projet.
Chaque session en arrière-plan est son propre processus Claude Code, géré par le superviseur plutôt que lié à votre terminal. Une session qui fonctionne activement, attend votre entrée, ou a un terminal attaché garde son processus en cours d'exécution. Une commande shell en arrière-plan en cours d'exécution, un sous-agent, un workflow dynamique, ou un monitor compte comme un travail actif, donc un processus de longue durée tel qu'un serveur de développement maintient la session active.
Une fois qu'une session se termine et reste non attachée pendant environ une heure, le superviseur arrête son processus pour libérer des ressources. Une session que vous avez [épinglée](#organize-the-list) avec `Ctrl+T` est exemptée et garde son processus en cours d'exécution pendant qu'elle est inactive. La transcription et l'état restent sur le disque de toute façon, et la prochaine fois que vous vous attachez, apercevez, ou répondez à une session arrêtée, le superviseur démarre un processus frais à partir de là où il s'était arrêté. Quand chaque session s'est terminée et qu'aucun terminal n'est connecté, le superviseur lui-même quitte et redémarre la prochaine fois que vous en avez besoin.
Une ligne vide laissée après avoir appuyé sur `←` qui n'a jamais reçu d'invite est supprimée entièrement après environ cinq minutes pour que la liste se vide d'elle-même. Les sessions démarrées avec `claude --bg` et les sessions en attente d'une invite de configuration telle qu'une boîte de dialogue de confiance ne sont pas supprimées de cette façon.
Quand l'hôte manque de mémoire, le superviseur arrête d'abord les sessions inactives non épinglées et arrête les sessions épinglées inactives seulement si cela n'a rien libéré.
Le superviseur regarde le binaire Claude Code installé sur le disque et redémarre dans la nouvelle version après que l'[auto-updater](/fr/setup#auto-updates) régulier le remplace. C'est une montre de fichier local, pas une vérification réseau. Les sessions en arrière-plan sont des processus détachés, donc elles continuent de s'exécuter pendant le redémarrage et le nouveau superviseur se reconnecte à elles. Une session épinglée inactive est également redémarrée sur place dans la nouvelle version pour qu'elle récupère la mise à jour sans que vous vous réattachiez.
Où l'état est stocké
L'état de la session est stocké sous votre répertoire de configuration Claude Code. Si vous définissez [`CLAUDE_CONFIG_DIR`](/fr/env-vars), le superviseur utilise ce répertoire à la place de `~/.claude` et s'exécute comme une instance séparée avec ses propres sessions.
| Chemin | Contenu |
| :------------------------------- | :--------------------------------------------------------------------------------------------------------------------------- |
| `~/.claude/daemon.log` | Journal du superviseur |
| `~/.claude/daemon/roster.json` | Liste des sessions en arrière-plan en cours d'exécution, utilisée pour se reconnecter après un redémarrage |
| `~/.claude/jobs//state.json` | État par session affiché dans la vue agent |
| `~/.claude/jobs//tmp/` | Répertoire de travail par session. Les écritures ici ne demandent pas de permission. Supprimé quand la session est supprimée |
Chaque session en arrière-plan a la variable d'environnement `CLAUDE_JOB_DIR` définie à son répertoire `~/.claude/jobs/`, donc les commandes shell que la session exécute peuvent écrire des fichiers temporaires à `$CLAUDE_JOB_DIR/tmp` sans entrer en collision avec les sessions parallèles.
Pour inspecter cet état sans lire les fichiers directement, exécutez `claude daemon status`. Il rapporte si le superviseur est accessible, son ID de processus et sa version, le répertoire socket, et combien de sessions en arrière-plan sont actives. `/doctor` inclut un résumé de la même vérification.
La commande avertit également quand le superviseur en cours d'exécution est sur une version différente de celle du `claude` que vous avez invoqué, ce qui se produit après une mise à jour que le superviseur n'a pas encore redémarrée. L'avertissement affiche les deux versions et vous dit d'exécuter `claude daemon stop --any` pour récupérer la nouvelle version. Quand Claude Code est installé en tant que service du système d'exploitation, la commande suggérée est `claude daemon stop` sans le drapeau.
Sur Windows, `claude daemon status` affiche l'erreur de fichier sous-jacente quand le fichier de clé pipe du daemon est verrouillé ou illisible au lieu de signaler un échec de connexion générique.
Désactiver la vue agent
Pour désactiver complètement les agents en arrière-plan et la vue agent, définissez le paramètre `disableAgentView` [setting](/fr/settings) à `true` ou définissez la variable d'environnement `CLAUDE_CODE_DISABLE_AGENT_VIEW`. Les administrateurs peuvent appliquer cela via les [paramètres gérés](/fr/permissions#managed-settings).
Dépannage
`claude agents` affiche les sous-agents au lieu d'ouvrir la vue agent
Si `claude agents` affiche un nombre suivi de vos sous-agents configurés puis se ferme, la vue agent n'est pas disponible dans votre environnement. Les versions antérieures n'ouvraient pas la vue agent dans tous les environnements, notamment lors de la connexion via Bedrock, Vertex AI ou Foundry. Exécutez `claude update` pour installer la dernière version.
Si la vue agent ne s'ouvre toujours pas après la mise à jour, vérifiez si elle a été [désactivée](#turn-off-agent-view) par un paramètre ou une variable d'environnement.
La vue agent s'ouvre sans sessions
Avant de lancer votre première session, la vue agent affiche un court indice d'intégration avec des invites d'exemple à la place de la liste des sessions. Tapez une invite dans l'entrée en bas et appuyez sur `Entrée` pour lancer votre première session.
Impossible d'ouvrir les agents car du travail s'exécute en arrière-plan
Si appuyer sur `←` pour mettre la session actuelle en arrière-plan affiche `Cannot open agents — N still running in the background`, la session a du travail en cours comme un sous-agent, un workflow dynamique, ou une commande shell en arrière-plan, et le raccourci n'abandonnera pas silencieusement. Exécutez `/tasks` pour voir ce qui s'exécute, puis `/bg` pour confirmer l'abandon. Voir [Depuis l'intérieur d'une session](#from-inside-a-session) pour savoir ce qui se transfère et ce qui ne se transfère pas quand vous mettez en arrière-plan.
Invite rejetée comme trop courte
L'entrée de dispatch attend une description de tâche, pas une ouverture conversationnelle. Une invite plus courte que quatre caractères est rejetée avec un indice `Too short` pour qu'une frappe accidentelle ne démarre pas une session. Décrivez ce que vous voulez que la session fasse, par exemple `investigate the flaky checkout test`.
Les sessions s'affichent comme échouées après l'arrêt
L'arrêt ou le redémarrage de votre machine arrête les sessions en arrière-plan en cours d'exécution, elles s'affichent donc comme échouées quand vous ouvrez à nouveau la vue agent. Attachez-vous, apercevez, ou répondez à n'importe laquelle d'entre elles et la session redémarre à partir de là où elle s'était arrêtée.
La mise en veille seule ne cause pas cela. Les sessions sont préservées lors de la mise en veille et le superviseur se reconnecte à elles au réveil.
La vue agent indique que le service en arrière-plan n'a pas répondu
Si l'attachement, l'aperçu, ou `claude logs` signale que le service en arrière-plan n'a pas répondu, le processus superviseur a probablement bloqué. Arrêtez-le et laissez le prochain `claude agents` en démarrer un nouveau. Pour garder vos sessions en arrière-plan en cours d'exécution pendant le redémarrage, passez `--keep-workers` :
```bash theme={null}
claude daemon stop --any --keep-workers
```
Le nouveau superviseur se reconnecte aux sessions en cours d'exécution. Sans `--keep-workers`, la commande termine également les sessions en arrière-plan. Le drapeau `--any` confirme que vous voulez arrêter un superviseur qui a démarré à la demande plutôt que comme service installé, ce qui est la valeur par défaut.
Sur Windows, si le superviseur ne répond pas à la demande d'arrêt, la commande affiche son ID de processus. Terminez ce processus avec `taskkill /PID ` pour terminer la récupération. Les sessions en arrière-plan sont toujours préservées quand vous avez passé `--keep-workers`.
Le dispatch échoue avec `Could not resolve authentication method`
{/* min-version: 2.1.174 */}Si un dispatch en arrière-plan échoue avec `Could not resolve authentication method` tandis que les sessions interactives s'authentifient normalement, le worker qui a reçu le dispatch n'a pas récupéré les identifiants. Sur v2.1.174 et versions ultérieures, le superviseur fournit un nouvel instantané d'identifiants quand il assigne un [worker préchauffé](#the-supervisor-process), donc cette erreur signifie qu'aucun identifiant stocké n'était disponible pour le processus superviseur lui-même. Confirmez que vous avez exécuté `/login` ou configuré une clé API, puis arrêtez le superviseur :
```bash theme={null}
claude daemon stop --any --keep-workers
```
Le prochain `claude agents` ou `claude --bg` démarre un nouveau superviseur qui lit vos identifiants stockés. Si vous vous authentifiez avec une variable d'environnement comme `ANTHROPIC_API_KEY` plutôt qu'avec `/login`, exécutez cette prochaine commande à partir d'un shell où la variable est définie.
Voir la [référence d'erreur](/fr/errors#could-not-resolve-authentication-method) pour la liste complète des causes et des correctifs. Avant v2.1.174, un worker préchauffé qui restait inactif pouvait générer cette erreur quand il était assigné à un dispatch même quand vos identifiants étaient valides. Mettez à jour pour récupérer.
Les sessions en arrière-plan ne peuvent pas lire Desktop, Documents ou Downloads sur macOS
Sur macOS, l'hôte de session en arrière-plan s'exécute comme son propre processus et demande l'accès aux dossiers protégés séparément de votre terminal. Si une session en arrière-plan signale `Operation not permitted` lors de la lecture de `~/Desktop`, `~/Documents`, `~/Downloads`, ou un autre emplacement protégé, accordez l'accès dans Paramètres système sous Confidentialité et sécurité > Fichiers et dossiers, ou activez Accès complet au disque pour l'entrée.
Avec l'installateur natif, l'entrée apparaît comme Claude Code et l'autorisation persiste lors des mises à jour. Avec d'autres méthodes d'installation comme Homebrew ou npm, l'entrée affiche le chemin du binaire et peut avoir besoin d'être accordée à nouveau après la mise à jour.
Une session est lente à répondre après l'attachement
Une fois qu'une session s'est terminée et reste non attachée pendant environ une heure, le superviseur arrête son processus pour libérer des ressources. S'attacher démarre un processus frais à partir de là où il s'était arrêté, ce qui prend un moment. Les sessions qui fonctionnent, attendent votre intervention, ou sont [épinglées](#organize-the-list) ne sont pas arrêtées de cette façon, donc épinglez une session avec `Ctrl+T` pour la garder réactive.
`.claude/worktrees/` se remplit
Supprimer une session dans la vue agent supprime la worktree que Claude a créée pour elle. `claude rm` conserve une worktree qui a des modifications non validées et affiche son chemin. Listez les entrées restantes avec `git worktree list` dans le répertoire du projet et supprimez chacune avec `git worktree remove `. Voir [Nettoyer les worktrees](/fr/worktrees#clean-up-worktrees).
Limitations
La vue agent est en aperçu de recherche avec les limitations suivantes :
* **Les limites de débit s'appliquent** : les sessions en arrière-plan consomment votre utilisation d'abonnement de la même manière que les sessions interactives, donc exécuter dix agents en parallèle utilise le quota environ dix fois plus vite qu'en exécuter un seul.
* **Les sessions sont locales** : les sessions en arrière-plan s'exécutent sur votre machine. Elles sont préservées lors de la mise en veille mais s'arrêtent si la machine s'éteint.
* **Les worktrees créées par Claude sont supprimées avec la session en vue agent** : fusionnez ou poussez les modifications avant de supprimer une session qui a modifié des fichiers dans sa propre worktree. `claude rm` conserve une worktree qui a des modifications non validées ; une worktree que vous avez créée vous-même est laissée en place.
Pour d'autres façons d'exécuter Claude en parallèle, consultez :
* [Exécuter les agents en parallèle](/fr/agents) : comparez la vue agent avec les sous-agents, les équipes d'agents, et les worktrees
* [Équipes d'agents](/fr/agent-teams) : coordonnez plusieurs sessions qui se messagent mutuellement
* [Claude Code sur le web](/fr/claude-code-on-the-web) : exécutez les sessions dans un environnement cloud géré au lieu de localement