Accueil › Blog › Planifier ses agents IA

Faut-il faire planifier vos agents IA ? 39 runs mesurés sur du vrai code

Par — éditeur OutilsIA, apps Rust, labo Dragon

Publié le 16 novembre 2026 · ~9 min de lecture · Agents et orchestration

L'essentiel

Nous avons fait coder 7 tâches, dont trois dans de vraies bibliothèques Rust (glob, semver et csv, jusqu'à 12 000 lignes), de trois façons : Claude Sonnet 5.5 seul, Claude Opus 5.5 seul, et un plan écrit par un grand modèle puis exécuté tâche par tâche avec relecture. La note vient de tests cachés que personne n'a vus. Résultat sur 39 runs : Sonnet seul réussit 100 % des tests à chaque fois. Le plan fait le même score en 2,7 à 4,5 fois plus de temps et environ 2 fois plus de jetons ; une fois, il a même échoué avant d'écrire une ligne.

La question : un grand modèle qui planifie, ça aide ?

L'idée est séduisante : un modèle puissant découpe l'objectif en tâches, un modèle moins cher exécute chaque morceau, un troisième relit. C'est la promesse de beaucoup d'outils multi-agents, et c'est ce que nous avons construit dans Maestro : un planificateur sans outils, au plafond de jetons vérifié, dont le plan est contrôlé par le code avant d'être exécuté.

Avant de le mettre par défaut, nous l'avons mesuré. Les publications sérieuses vont plutôt dans l'autre sens : Anthropic mesure qu'un système multi-agent consomme environ 15 fois plus de jetons qu'un chat, et OpenAI recommande de pousser d'abord un agent seul au maximum. Il fallait savoir ce qu'il en est sur du code, avec nos propres tâches.

Le protocole

Les résultats

TâcheRuns par brasTests cachésDurée : Sonnet / Opus / planJetons lus : Sonnet / Opus / plan
Durées (parse_duration)118/18 partout16 s / 29 s / 43 s68 k / 70 k / 96 k
Chiffres romains + binaire116/16 partout25 s / 37 s / 101 s69 k / 71 k / 168 k
Moteur cron + binaire120/20 partout38 s / 74 s / 137 s74 k / 108 k / 256 k
JSON strict (RFC 8259, 6901, 7386)126/26 partout61 s / 116 s / 273 s112 k / 121 k / 626 k
glob : accolades {a,b}322/22 partout74 s / 186 s / 276 s (médianes)325 k / 477 k / 811 k
semver : plages npm316/16, sauf un plan à 089 s / 171 s / 303 s237 k / 327 k / 580 k
csv : quatre fonctions (12 000 lignes)326/26 partout117 s / 219 s / 364 s491 k / 967 k / 1 086 k

Les jetons lus comprennent le cache : un exécutant relit son contexte à chaque étape, c'est ce poste qui domine. Le coût du plan lui-même est faible (environ 5 000 jetons lus et autant générés) ; ce qui coûte, c'est l'exécution découpée : chaque tâche relit le dépôt, chaque relecture aussi.

Ce que nous en concluons

Sur un objectif clair qui tient dans une session, même long et même dans un dépôt de 12 000 lignes, un seul exécutant bien choisi fait aussi bien qu'un plan, deux à quatre fois moins cher. Le plus gros modèle n'apporte rien non plus : Opus seul fait le même score que Sonnet, en deux fois plus de temps. Le bon réglage est le modèle le moins cher qui atteint le score, et ce sont les tests qui décident.

Ce que cela a changé dans Maestro

Nous avions construit maestro construire pour planifier d'abord. Les mesures nous ont fait inverser l'ordre :

  1. Exécuter directement. L'objectif part en une seule tâche, sur le modèle choisi pour le domaine « code » (Sonnet 5.5 par défaut), avec vos tests comme juge et un plafond de jetons vérifié avant chaque tour.
  2. Planifier en recours. Si l'exécutant épuise ses tours sans faire passer les tests, le planificateur reprend avec la sortie des tests pour dossier et découpe le travail, deux fois au plus.
  3. Planifier d'emblée sur demande (--planifier), pour les chantiers dont vous savez qu'ils dépassent une session.

Chaque construction se termine par un reçu : le plan s'il y en a un, le modèle demandé et le modèle réellement servi à chaque tour, les jetons lus et générés, la durée. Aucun prompt n'y figure.

Ce que les essais ont cassé dans notre propre harness

Mesurer en réel a surtout servi à trouver nos défauts, avant vous :

Les limites de cette mesure

FAQ

Faut-il un modèle planificateur pour coder avec des agents ?

Pas sur un objectif clair qui tient dans une session. Sur nos 39 runs, un exécutant seul (Claude Sonnet 5.5) a réussi 100 % des tests cachés ; le plan a fait le même score pour 2 à 4 fois plus de temps et environ 2 fois plus de jetons.

Un plus gros modèle code-t-il mieux ?

Pas sur ces tâches : Opus 5.5 seul a fait le même score que Sonnet 5.5 seul, en environ deux fois plus de temps et avec plus de jetons. Le bon choix est le modèle le moins cher qui atteint le score, vérifié par vos tests.

Quand un plan peut-il servir ?

Quand un exécutant seul échoue : objectif flou, chantier qui dépasse une session, plusieurs parties vraiment indépendantes. C'est pourquoi Maestro garde le planificateur en recours, avec la sortie des tests comme point de départ, et sur demande.

Comment les résultats ont-ils été notés ?

Par des tests cachés, écrits à part, vérifiés sur une implémentation de référence et copiés dans le dépôt seulement après le run. Aucun modèle ne les a vus.

Sources

Mesurez sur votre propre code Maestro 0.8.0 exécute vos objectifs avec le modèle choisi par domaine, vos tests comme juge, des plafonds vérifiés avant chaque tour et un reçu qui mesure chaque jeton. Gratuit. Découvrir Maestro