> ## Documentation Index > Fetch the complete documentation index at: https://docs.devin.ai/llms.txt > Use this file to discover all available pages before exploring further. # Sous-agents > Déléguez des tâches à des sous-agents indépendants qui travaillent au premier plan ou en arrière-plan Les sous-agents permettent à l’agent principal de lancer des agents de travail indépendants pour prendre en charge des sous-tâches. Un sous-agent partage les outils et le contexte de la base de code avec le parent, mais fonctionne dans son propre fil de conversation -- il n’hérite pas de l’historique des conversations du parent. Cela est utile pour les tâches qui bénéficient d’un travail ciblé et indépendant -- comme l’exploration d’une base de code, l’exécution de tests ou l’implémentation d’une fonctionnalité en parallèle. Vous pouvez demander explicitement à l’agent d’utiliser des sous-agents (p. ex. « étudie le fonctionnement de l’authentification dans un sous-agent »), ou l’agent peut décider de déléguer de lui-même lorsqu’il estime qu’une tâche bénéficierait d’un travail indépendant. D’après nos mesures, les **sous-agents** **améliorent à la fois les performances globales de développement** **et** **réduisent les coûts**. ***
## Fonctionnement des sous-agents
Lorsque l'agent lance un sous-agent, il sélectionne l'un des **profils de sous-agent** disponibles et choisit si le sous-agent doit s'exécuter au premier plan ou en arrière-plan. Les sous-agents peuvent s'exécuter selon deux modes : S'exécute directement dans votre session. L'agent parent se met en pause et attend que le sous-agent ait terminé avant de continuer. Vous pouvez approuver ou refuser les appels d’outil au fur et à mesure. S'exécute en parallèle pendant que l'agent parent continue de travailler. L'agent parent est automatiquement informé lorsque le sous-agent a terminé. Les outils non approuvés sont automatiquement refusés. Vous ne voyez pas directement la sortie brute du sous-agent. Lorsqu'un sous-agent termine, l'agent parent lit le résultat et vous en résume les principaux constats et actions.
### Coût des sous-agents
Les sous-agents s’exécutent dans leurs propres sessions d’agent, chacune avec sa propre fenêtre de contexte et ses propres appels d’inférence. Ils entraînent donc des coûts indépendamment de l’agent parent. Les dépenses de l’agent parent couvrent son propre travail ; chaque sous-agent qu’il lance ajoute sa propre utilisation à cela. Avec les forfaits basés sur les prompts, chaque sous-agent consomme des crédits supplémentaires, tout comme un message utilisateur. Le nombre de crédits dépend du modèle qu’utilise le sous-agent ; les tâches qui font appel à plusieurs sous-agents (ou qui les [imbriquent](/fr/cli/subagents#nesting-depth)) consomment donc plus de crédits. Comme le coût augmente avec le nombre de sous-agents, les tâches qui se répartissent entre de nombreux sous-agents (ou les [imbriquent](#nesting-depth)) coûtent plus cher. Utilisez les sous-agents de manière intentionnelle lorsque le parallélisme ou un contexte plus ciblé justifie cette dépense supplémentaire.
### Contrôles Enterprise
Les administrateurs peuvent définir quel modèle les sous-agents utilisent — et même s’ils s’exécutent ou non — via le paramètre **Modèle de sous-agent par défaut** dans les paramètres d’org/Enterprise. Paramètre Modèle de sous-agent par défaut Ce paramètre contrôle le modèle utilisé pour les sessions de sous-agent lancées par Devin, avec trois options : | Option | Comportement | | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | | **Routeur de sous-agent (par défaut)** | Devin choisit automatiquement un modèle en utilisant le routage par défaut en fonction de la tâche et du modèle parent. | | **Un modèle spécifique** | Force chaque sous-agent à utiliser le modèle sélectionné, quelle que soit la tâche ou le modèle parent. | | **Aucun** | Désactive complètement les sous-agents — Devin ne lancera aucun sous-agent. | ***
## Profils de sous-agent
Chaque sous-agent utilise un profil spécifique qui détermine ses capacités. Il existe deux profils intégrés : | Profil | Description | Accès aux outils | | ------------------ | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `subagent_explore` | Exploration de la base de code et recherche en lecture seule | Outils de la base de code en lecture seule, plus recherche web ; ne peut pas modifier de fichiers ni récupérer des URL arbitraires (au premier plan comme en arrière-plan) | | `subagent_general` | Tâches générales, y compris les modifications de code | Accès complet aux outils (premier plan) ou uniquement aux outils préapprouvés (arrière-plan) | L’agent choisit automatiquement le profil approprié en fonction de la tâche. Les sous-agents d’exploration sont idéaux pour la recherche et la compréhension, tandis que les sous-agents généraux peuvent apporter des modifications. Vous pouvez également définir vos propres profils de sous-agent personnalisés — voir [Sous-agents personnalisés](#custom-subagents) ci-dessous. ***
## Autorisations des outils
La manière dont les autorisations des outils fonctionnent dépend du fait que le sous-agent s’exécute au premier plan ou en arrière-plan : * **Les sous-agents au premier plan** se comportent comme l’agent principal -- vous êtes invité à autoriser ou refuser les appels aux outils comme d’habitude. * **Les sous-agents en arrière-plan** héritent de toutes les autorisations d’outils que vous avez déjà accordées au cours de la session actuelle. Tout outil qui n’a pas été préautorisé est automatiquement refusé. Les sous-agents en arrière-plan ne peuvent pas vous demander de nouvelles autorisations. Si un sous-agent en arrière-plan échoue parce qu’un outil requis a été refusé, vous pouvez le reprendre au premier plan afin d’accorder les autorisations nécessaires. Voir [Reprise des sous-agents](#resuming-subagents) ci-dessous. ***
## Suivi des sous-agents
### Indicateur de sous-agent
Lorsque des sous-agents s’exécutent en arrière-plan, un indicateur apparaît sous la zone de saisie pour indiquer leur statut. Vous pouvez accéder à l’indicateur en appuyant sur ↓ depuis la zone de saisie, puis sur Enter pour ouvrir le panneau des sous-agents. Lorsqu’un sous-agent s’exécute au premier plan, l’indicateur de chargement affiche **"Sous-agent en cours d’exécution · Ctrl+B pour l’exécuter en arrière-plan"**.
### Panneau des sous-agents
Le panneau des sous-agents vous permet de voir et de gérer tous les sous-agents actifs et terminés. Il affiche, pour chaque sous-agent, le profil, le titre, le statut, le temps écoulé et le nombre d’appels d’outils. ***
## Basculer entre le premier plan et l’arrière-plan
Vous pouvez déplacer des sous-agents entre le premier plan et l’arrière-plan pendant leur exécution : * **Mettre en arrière-plan un sous-agent au premier plan :** Appuyez sur Ctrl+B pendant l’exécution d’un sous-agent au premier plan. Le sous-agent continue de travailler en arrière-plan, et l’agent parent reprend. * **Mettre au premier plan un sous-agent en arrière-plan :** Ouvrez le panneau des sous-agents et appuyez sur f sur un sous-agent en arrière-plan en cours d’exécution. La sortie du sous-agent s’affichera directement dans le fil. Lorsque vous déplacez un sous-agent en arrière-plan, l’appel d’outil de l’agent parent a déjà renvoyé son résultat ; l’agent parent continue donc indépendamment. Le résultat du sous-agent ne sera pas réinjecté dans le pipeline actuel du parent, mais vous serez averti lorsqu’il aura terminé. ***
## Annulation des sous-agents
Vous pouvez annuler un sous-agent en cours d’exécution de deux façons : 1. **Depuis le panneau des sous-agents :** Ouvrez le panneau et appuyez sur x sur un sous-agent en cours d’exécution. 2. **Sous-agent au premier plan :** Appuyez sur Ctrl+C ou Esc pour annuler le sous-agent au premier plan en cours d’exécution. ***
## Reprendre des sous-agents
Les sous-agents annulés, ayant échoué ou terminés peuvent être repris avec un nouveau prompt. Vous pouvez demander à l'agent de reprendre un sous-agent, et il continuera là où il s'était arrêté. Les sous-agents repris s'exécutent toujours au **premier plan**, afin que vous puissiez approuver les appels à des outils qui avaient été refusés précédemment. C'est particulièrement utile dans les cas suivants : * Un sous-agent en arrière-plan a échoué parce qu'un outil requis a été refusé -- reprenez-le au premier plan pour accorder les autorisations nécessaires. * Un sous-agent s'est terminé, mais vous souhaitez qu'il effectue un travail de suivi supplémentaire en fonction de ses résultats. * Un sous-agent a été annulé prématurément et vous souhaitez qu'il continue. ***
## Profondeur d’imbrication
Par défaut, les sous-agents ne peuvent pas créer leurs propres sous-agents — seul l’agent racine le peut. Les outils de sous-agent (`run_subagent` et `read_subagent`) sont désactivés au sein d’un sous-agent afin d’éviter une imbrication sans limite. Cependant, les **profils de sous-agent personnalisés** peuvent autoriser l’imbrication en définissant le champ `max-nesting` dans leur frontmatter. Cette valeur déroge à la profondeur maximale par défaut et permet aux sous-agents de créer des agents enfants tant que l’arborescence reste dans cette limite. Par exemple, `max-nesting: 3` autorise la chaîne suivante : ``` Root agent (depth 0) └── Custom subagent (depth 1) — peut créer des sous-agents └── Child subagent (depth 2) — peut créer des sous-agents └── Grandchild subagent (depth 3) — ne peut pas créer de sous-agents (limite de profondeur atteinte) ``` Les sous-agents imbriqués peuvent faire grimper considérablement les coûts. Chaque niveau d’imbrication crée des agents supplémentaires, chacun avec sa propre fenêtre de contexte et ses propres appels d’inférence. Utilisez cette fonctionnalité avec discernement. ***
## Sous-agents personnalisés
Les sous-agents personnalisés sont **expérimentaux**. Leur format, leur comportement et leurs options de configuration peuvent changer dans de futures versions. En plus des profils intégrés `subagent_explore` et `subagent_general`, vous pouvez définir vos propres profils de sous-agents personnalisés. Les sous-agents personnalisés vous permettent de créer des agents spécialisés avec leurs propres prompts système, restrictions d’outils, dérogations de modèle et autorisations, adaptés à des tâches spécifiques dans votre workflow.
### Création d’un sous-agent personnalisé
Les sous-agents personnalisés prennent la forme de fichiers `AGENT.md` placés dans un répertoire nommé sous `agents/`. Le nom du répertoire devient l’identifiant du profil. ```text theme={null} .devin/agents/ └── reviewer/ └── AGENT.md ``` Également pris en charge : ```text theme={null} .agents/agents/ └── reviewer/ └── AGENT.md ``` ```text theme={null} # Linux/macOS ~/.config/devin/agents/ └── reviewer/ └── AGENT.md # Windows %APPDATA%\devin\agents\ └── reviewer\ └── AGENT.md ```
### Format d’AGENT.md
Un fichier `AGENT.md` utilise le même frontmatter YAML que les skills, suivi du prompt système du sous-agent : ```markdown theme={null} --- name: reviewer description: Reviews code changes for correctness and style model: sonnet allowed-tools: - read - grep - glob - exec permissions: allow: - Exec(git diff) - Exec(git log) deny: - write - edit --- You are a code review subagent. Your job is to review code changes thoroughly and report findings back to the parent agent. Focus on: 1. Correctness — logic errors, edge cases, off-by-one mistakes 2. Security — potential vulnerabilities 3. Style — consistency with the rest of the codebase 4. Performance — obvious inefficiencies Always cite specific file paths and line numbers in your findings. ```
### Champs du frontmatter
| Champ | Type | Par défaut | Description | | --------------- | ------ | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | `name` | chaîne | nom du répertoire | Identifiant du profil (ne doit pas entrer en conflit avec les profils intégrés) | | `description` | chaîne | aucune | Affiché à l'agent lors de la sélection d'un profil | | `model` | chaîne | modèle de sous-agent par défaut | Redéfinit le modèle utilisé par ce sous-agent | | `allowed-tools` | liste | tous les outils | Restreint les outils que le sous-agent peut utiliser. Il n'est pas possible d'accorder `ask_user_question`, qui est toujours refusé aux sous-agents. | | `permissions` | objet | hériter | Dérogations aux autorisations (`allow`, `deny`, `ask`) | | `max-nesting` | entier | aucune | Redéfinit la profondeur d'imbrication maximale, ce qui permet à ce sous-agent de créer ses propres sous-agents |
### Comment sont utilisés les sous-agents personnalisés
Une fois définis, les profils de sous-agents personnalisés apparaissent aux côtés des profils intégrés. L’agent voit une description de chaque profil disponible et choisit le plus approprié lorsqu’il crée un sous-agent. Vous pouvez aussi demander à l’agent d’utiliser un profil spécifique en le nommant (par ex., « examine ce code à l’aide du sous-agent reviewer »). Les profils de sous-agents personnalisés dont le nom entre en conflit avec celui d’un profil intégré (par ex., `subagent_explore`, `subagent_general`) sont ignorés, avec un avertissement.
### Importation depuis d’autres outils
Les sous-agents personnalisés peuvent aussi être importés à partir du format d’agent de Claude Code : | Source | Modèle de fichier | | --------------------- | ---------------------------------------------------- | | `.claude/agents/*.md` | Chaque fichier `.md` devient un profil de sous-agent | Les fichiers d’agent de Claude Code utilisent `tools` au lieu de `allowed-tools` dans leur frontmatter. Les deux formats sont pris en charge automatiquement.
### Exemples
#### Agent de recherche en mode lecture seule
```markdown theme={null} --- name: researcher description: Deep codebase research and architecture analysis model: sonnet allowed-tools: - read - grep - glob --- You are a research subagent specializing in codebase exploration. Your job is to thoroughly investigate a topic and report back with: - Relevant files and their purposes - Architecture patterns and dependencies - Code flow traces with specific line references Be exhaustive — search broadly and follow references. ```
#### Agent d’exécution des tests
```markdown theme={null} --- name: test-runner description: Runs tests and reports results allowed-tools: - read - grep - glob - exec permissions: allow: - Exec(npm run test) - Exec(cargo nextest) - Exec(pytest) --- You are a test runner subagent. Run the relevant test suites and report: - Which tests passed and failed - Failure messages and stack traces - Suggestions for fixing failures ```