Essence du pattern
Task Decomposition est un pattern qui permet a un agent de decouper une tache complexe en sous-taches plus petites avant execution.
Quand l'utiliser : quand une tache complexe ne peut pas etre executee de maniere fiable en une seule etape et qu'il faut la decouper en sous-taches.
Au lieu de tout resoudre d'un coup, il :
- analyse la tache
- definit les etapes
- les execute dans l'ordre
Chaque etape est une sous-tache separee.
Probleme
Imagine que l'agent recoit une tache :
"Prepare un rapport mensuel de ventes."
En pratique, ce n'est pas une seule etape, mais une sequence de sous-taches :
- collecter les donnees
- les nettoyer et les valider
- calculer les metriques
- formuler la conclusion
Sans plan explicite, une tache complexe devient vite opaque : des etapes se perdent et la logique se casse.
Si l'agent essaie de tout faire "en un seul passage", le chaos apparait souvent :
- etapes intermediaires manquantes
- ordre d'execution incorrect
- melange entre planification et execution
- controle des erreurs faible
Voila le probleme : sans structure, une tache complexe est facile a executer de maniere instable et avec des erreurs.
Solution
Task Decomposition ajoute une phase de planification separee avant l'execution.
Analogie : c'est comme monter un meuble avec une notice. Sans notice, il est facile d'inverser l'ordre ou d'oublier une piece. Avec une notice, chaque etape est transparente et une erreur est plus facile a trouver.
Principe cle : D'abord le plan, puis les actions. C'est ce qui rend le processus controlable.
Pour eviter que l'agent saute directement a la reponse finale, decomposition-policy fixe :
- quelles sous-taches sont obligatoires
- dans quel ordre elles doivent etre executees
- quand il faut faire un
re-plan
Le processus controle ressemble a ceci (comme sur le schema) :
- Goal : clarifier l'objectif et les contraintes
- Plan : decomposer la tache en sous-taches et dependances
- Execution des etapes (Step 1..N / Execute) : executer les sous-taches selon le plan
- Combine Results : assembler les resultats des etapes en un tout
- Done : produire le resultat final
La capture intermediaire des resultats (checkpoint) se fait dans la phase d'execution.
Task Decomposition aide a :
- augmenter la predictibilite
- ne pas perdre des etapes importantes
- localiser les erreurs sur une etape precise
- obtenir des resultats plus stables sur des taches longues
Cela fonctionne le mieux si :
- il existe des limites claires entre etapes et dependances
- chaque etape a un critere de fin
- des regles de re-plan sont definies quand les conditions changent
- la phase d'execution ne contourne pas le plan valide
Meme si le modele "veut" donner tout de suite une reponse finale, decomposition-policy ramene le processus vers des etapes structurees.
Comment ca fonctionne
Task Decomposition n'execute pas les etapes lui-meme.
Il definit seulement quelles sous-taches doivent etre executees, et chacune peut etre executee via une boucle ReAct separee.
Donc l'agent construit d'abord un plan, puis resout generalement les sous-taches de maniere sequentielle, etape par etape.
Description du flow complet : Plan → Execute
Planification (Plan)
L'agent determine quelles etapes sont necessaires pour accomplir la tache.
Execution (Execute)
Le systeme execute chaque etape en s'appuyant sur le plan de l'agent, souvent via une boucle ReAct separee, puis assemble le resultat.
En code, cela ressemble a ceci
steps = plan(goal)
for step_no, step in enumerate(steps, start=1):
result = execute(step, context=context) # chaque etape voit les resultats des etapes precedentes
if not result.ok:
return stop_or_replan(step_no=step_no, reason=result.error)
context.append(result.data)
return build_final_output(context)
L'agent decoupe la tache en sous-taches et les execute dans l'ordre.
A quoi cela ressemble pendant l'execution
Goal: preparer un rapport mensuel de ventes
Plan:
1. collecter les donnees de ventes
2. nettoyer les donnees
3. calculer les metriques cles
4. construire des graphiques
5. ecrire une conclusion
Execute step 1: le systeme appelle fetch_sales_data(month)
Observe: donnees brutes recues
Entre les etapes : raw_data devient l'entree pour le nettoyage
Execute step 2: le systeme appelle clean_sales_data(raw_data)
Observe: donnees nettoyees et validees
Entre les etapes : clean_data devient l'entree pour le calcul des metriques
Execute step 3: le systeme appelle calculate_metrics(clean_data)
Observe: metriques calculees
Execute step 4: le systeme appelle build_charts(metrics)
Observe: graphiques construits
Execute step 5: le systeme compose le resume
Observe: rapport final pret
Stop: apres l'etape finale, la boucle se termine
Chaque etape est executee separement, et le resultat intermediaire devient l'entree de la phase suivante.
Exemple complet d'agent Task Decomposition
Quand c'est adapte - et quand ca ne l'est pas
Adapte
| Situation | Pourquoi Task Decomposition est adapte | |
|---|---|---|
| ✅ | La tache a plusieurs etapes | Le pattern decoupe un grand objectif en sous-taches claires, executables l'une apres l'autre. |
| ✅ | L'ordre des actions est important | Le plan fixe l'ordre des etapes et reduit le risque de rater une phase critique. |
| ✅ | Le resultat depend des etapes intermediaires | Chaque sous-tache a son propre resultat, qui devient l'entree de la suivante. |
Non adapte
| Situation | Pourquoi Task Decomposition n'est pas adapte | |
|---|---|---|
| ❌ | La tache est simple | La decomposition ajoute des etapes inutiles la ou la tache peut etre resolue directement. |
| ❌ | Une reponse rapide est necessaire | Construire et executer un plan augmente la latence par rapport a une execution en une fois. |
| ❌ | Le plan ne peut pas etre construit a l'avance | Si la structure de la tache change en permanence, un plan rigide perd vite sa pertinence. |
Parce que le plan peut etre inexact ou inutile.
Quand utiliser Task Decomposition (vs autres patterns)
Utilisez Task Decomposition quand il faut d'abord decouper un grand objectif en sous-taches plus petites et executables.
Test rapide :
- si vous avez besoin de "d'abord decomposer une tache complexe en sous-taches" -> Task Decomposition
- si vous avez besoin de "apres chaque etape, decider quoi faire ensuite" -> ReAct Agent
Comparaison avec d'autres patterns et exemples
Aide-memoire rapide :
| Si la tache ressemble a ca... | Utilisez |
|---|---|
| Apres chaque etape, il faut decider quoi faire ensuite | ReAct Agent |
| Il faut d'abord decouper un grand objectif en taches plus petites et executables | Task Decomposition Agent |
| Il faut executer du code, verifier les resultats et iterer en securite | Code Execution Agent |
| Il faut analyser des donnees et rendre des conclusions basees sur cette analyse | Data Analysis Agent |
| Il faut faire de la recherche sur plusieurs sources avec des preuves structurees | Research Agent |
Exemples :
ReAct : "Trouve la cause d'une panne API : verifie les logs -> regarde les erreurs -> lance la verification suivante selon le resultat".
Task Decomposition : "Prepare le lancement d'une nouvelle offre : decoupe la tache en sous-taches pour le contenu, la technique, la QA et le support".
Code Execution : "Calcule la retention sur 12 mois en Python et verifie la validite des formules sur des donnees reelles".
Data Analysis : "Analyse un CSV de ventes : trouve les tendances, les anomalies et donne des conclusions courtes".
Research : "Collecte des donnees sur 5 concurrents depuis plusieurs sources et fais un resume comparatif".
Comment combiner avec d'autres patterns
- Task Decomposition + ReAct - chaque sous-tache est executee etape par etape pour mieux controler les erreurs.
- Task Decomposition + Routing - pour chaque sous-tache, l'executant le plus adapte est selectionne automatiquement.
- Task Decomposition + Orchestrator - l'Orchestrator gere les dependances et le parallelisme pour que le plan s'execute sans blocages.
Difference avec ReAct
| ReAct | Task Decomposition | |
|---|---|---|
| Ce qui est decide | Que faire ensuite | Quelles etapes sont necessaires |
| Niveau | Execution | Planification |
| Comment ca marche | Execute une etape | Decoupe une tache en sous-taches |
| Utilise | Des outils pour l'execution | Des boucles ReAct pour executer les sous-taches |
ReAct aide a executer une etape.
Task Decomposition definit quelles etapes doivent etre executees tout court.
En bref
Agent Task Decomposition :
- analyse la tache
- la decoupe en etapes
- execute dans l'ordre
Avantages et Inconvenients
Avantages
decoupe une grande tache en etapes claires
plus facile d'estimer delais et risques
plus facile de deleguer et tester les sous-taches
reduit le chaos dans l'execution
Inconvenients
la decomposition prend aussi du temps
le plan peut devenir trop detaille
si le plan initial est faux, la suite devient plus difficile
FAQ
Q : Un plan est-il toujours necessaire ?
A: Non. Pour des taches simples, il peut etre superflu.
Q : L'agent peut-il changer le plan ?
A: Oui. Si de nouvelles donnees apparaissent pendant l'execution ou si une etape echoue, l'agent peut revoir le plan initial : ajouter de nouvelles sous-taches, changer l'ordre, ou creer un nouveau plan avant les actions suivantes.
Q : Task Decomposition fonctionne-t-il sans ReAct ?
A: Oui. La planification des sous-taches peut etre faite separement, par exemple si chaque etape a un Workflow fixe. Mais dans des taches plus complexes, chaque sous-tache est souvent executee via une boucle ReAct.
Et ensuite
Task Decomposition permet de decouper une tache en etapes.
Mais que faire s'il faut choisir entre plusieurs agents ?