9 novembre 2026

Claude Code, Codex et sous-agents : quand déléguer, quand garder un seul agent

Un agent unique ou des sous-agents ? Une grille de décision pour les équipes qui utilisent Claude Code ou Codex : séquence fixe ou délégation, choix du modèle, budgets, limites et validation humaine.

Les outils d'agents de codage comme Claude Code ou Codex posent une question que beaucoup d'équipes découvrent en pratique : faut-il laisser un seul agent dérouler la tâche de bout en bout, ou découper le travail et déléguer des sous-tâches à d'autres agents, éventuellement avec des modèles différents ? La tentation est de tout déléguer parce que c'est possible. La bonne réponse dépend de la nature de la tâche, et le raisonnement n'est pas spécifique au code.

Le guide d'architecture RAG de Microsoft formule cette distinction très clairement, même s'il parle de recherche documentaire plutôt que de génération de code. Dans un pipeline RAG standard, l'orchestrateur suit une séquence fixe : il reçoit la requête, lance une recherche, assemble le contexte et appelle le modèle. Il ne décide ni s'il doit chercher, ni dans quel index, ni combien d'étapes de récupération effectuer : ces décisions sont prises à la conception. Le passage à une approche « agentique », où l'agent traite la récupération comme un outil qu'il invoque à la demande, n'est recommandé que lorsque le scénario dépasse ce qu'une séquence fixe peut gérer : raisonnement en plusieurs étapes, sélection dynamique des sources, décomposition de la requête à l'exécution, combinaison de récupération et d'actions (source).

Cette grille se transpose assez directement au travail d'un agent de codage, avec une réserve honnête : le document source décrit des pipelines RAG, pas le fonctionnement interne de tel ou tel outil. Ce qu'on en retient, c'est une méthode de décision, pas une garantie sur les comportements de Claude Code ou de Codex.

Séquence fixe : le cas par défaut

Si la tâche se résume à une action connue sur un périmètre connu — corriger un test identifié, mettre à jour une dépendance, appliquer un pattern déjà présent dans le dépôt — vous êtes dans l'équivalent de « une seule recherche sur un seul index ». Un agent unique, avec des instructions explicites et un ordre d'opérations décidé par vous, suffit. Ajouter des sous-agents n'apporte rien au résultat mais ajoute des points de défaillance, du coût et de la latence qu'il faudra ensuite surveiller.

L'avantage d'une séquence fixe est aussi qu'elle se mesure facilement. Le guide insiste sur l'évaluation de chaque étape indépendamment, tout en gardant à l'esprit que c'est le résultat final que l'utilisateur voit (source). Avec un agent unique, les étapes sont peu nombreuses et vous savez exactement où regarder quand quelque chose dérive.

Délégation : quand la tâche exige des décisions à l'exécution

Les critères donnés par le guide pour basculer vers un agent qui décide lui-même sont de bons marqueurs pour la délégation à des sous-agents :

  • Raisonnement en plusieurs étapes : un refactoring qui touche plusieurs modules et dont le plan ne peut pas être écrit à l'avance.
  • Sélection dynamique des sources : l'agent doit choisir quels fichiers, quelle documentation ou quel historique consulter selon ce qu'il découvre.
  • Décomposition à l'exécution : la tâche ne devient claire qu'après une phase d'exploration du code.
  • Récupération combinée à des actions : lire, modifier, exécuter des tests, relire, dans une boucle dont le nombre d'itérations n'est pas connu.

Dans ces cas, un sous-agent dédié à l'exploration, un autre à l'édition et un troisième à la vérification permettent d'isoler les responsabilités. Mais chaque délégation est une décision que vous ne prenez plus à la conception : elle est déplacée vers l'exécution, et doit donc être encadrée.

Choisir le modèle selon quatre axes

Que vous ayez un agent ou plusieurs, le choix du modèle derrière chacun se fait sur des axes que vous devez mesurer plutôt qu'estimer :

  • Complexité : la sous-tâche demande-t-elle des décisions ou une exécution mécanique ? Une étape d'exploration et une étape de reformatage n'ont pas le même besoin.
  • Coût : mesurez la consommation par classe de tâche sur votre propre jeu de test, pas sur des chiffres génériques.
  • Latence : une interaction en direct avec un développeur et un job de nuit n'ont pas les mêmes contraintes.
  • Risque : la réversibilité de l'action compte plus que sa difficulté. Écrire sur une branche isolée et toucher à une configuration de production ne méritent pas le même modèle ni la même autonomie.

La méthode d'évaluation proposée pour le RAG s'applique telle quelle : constituer un jeu de tâches représentatif de votre dépôt, y compris des cas que vos conventions actuelles ne couvrent pas, évaluer chaque étape, documenter les paramètres et les résultats, puis agréger pour comparer les configurations (source). Sans ce jeu de test, un changement de modèle est une opinion.

Automatiser le switch sans perdre le contrôle

Une fois les axes mesurés, le passage d'un modèle à l'autre ou d'un agent unique à une délégation peut être automatisé, à condition que les garde-fous soient des décisions de conception et non des choix laissés à l'agent. L'exemple ci-dessous est purement illustratif, indépendant de la syntaxe réelle d'un outil :

## Exemple illustratif, non testé
task_class: multi_module_refactor
budget:
  max_tokens_total: <à définir>
  max_steps: <à définir>
delegation:
  explore: { model: <modèle A>, max_steps: <n> }
  edit:    { model: <modèle B>, write_scope: branch_only }
  verify:  { model: <modèle A>, run: tests }
retry:
  max_attempts: <n>
  on_failure: pause_for_review
human_gate:
  before_merge: required

Trois règles rendent ce type de configuration utile. Les budgets et limites d'étapes par sous-agent évitent qu'une boucle d'exploration consomme ce qui était prévu pour toute la tâche. Les reprises contrôlées remplacent la relance infinie par un nombre d'essais borné, puis une pause. La validation humaine se place là où l'action devient irréversible, pas partout : l'exploration peut être libre, la fusion ne l'est pas.

Mesurer le bénéfice avant de l'affirmer

Le guide propose pour les réponses de modèles des métriques comme l'ancrage, la complétude, l'utilisation du contexte et la pertinence (source). Pour du code, vous définirez vos propres critères d'acceptation par étape — tests passés, diff relu sans correction, absence de modification hors périmètre — mais la discipline est la même : comprendre toutes les étapes avant de fixer les critères, puis comparer les configurations sur le même jeu de tâches.

C'est ce travail de cadrage et de mesure, plus que le choix d'un outil, qui détermine si les sous-agents vous font gagner du temps ou en coûtent. Si vous souhaitez structurer cette évaluation sur votre propre base de code, nos services couvrent ce type d'accompagnement, et vous pouvez nous écrire pour en discuter.

Sources

Partager cet article

Lire aussi