# Business Applications : des agents qui travaillent dans vos processus, sous contrôle

> Un agent métier commence petit : une tâche, quelques outils. Le piège, c’est de lui en ajouter jusqu’à ce qu’il ne s’y retrouve plus. La réponse : des agents spécialisés, coordonnés et isolés.

Source : https://dasein-ai.com/fr/articles/business-applications · Dasein · Mis à jour le 1er octobre 2026

## En bref

- Un agent unique qui accumule les outils devient fragile, confus et coûteux.
- L’approche qui se généralise : un agent principal qui planifie, prend des notes et délègue à des sous-agents, comme Deep Agents de LangChain.
- Les contrôles se branchent sur la boucle de l’agent, via des middlewares et des hooks : validation humaine, masquage des données, plafonds, journal. Dasein aide à les concevoir et à les mettre en place.

## 1. Un agent commence petit

Prenons la comptabilité fournisseurs. Un premier agent lit les factures, les rapproche des bons de commande, signale les écarts et propose une validation. Quatre outils, un périmètre clair, un résultat facile à vérifier : c’est un bon départ.

Puis viennent les demandes : gérer les litiges, relancer les fournisseurs, consulter les paiements, appliquer la politique achats, produire le reporting. Chaque ajout est raisonnable. Leur somme ne l’est plus.

Exemple simplifié : un agent qui a grandi un outil à la fois.

```
agent: assistant-factures-fournisseurs
outils:
  # le périmètre de départ
  - lire-facture
  - rapprocher-commande
  - signaler-ecart
  - proposer-validation
  # ajoutés au fil des mois
  - ouvrir-litige
  - relancer-fournisseur
  - consulter-paiements
  - planifier-paiement
  - chercher-politique-achats
  - mettre-a-jour-fournisseur
  - generer-reporting
  # ...
```

## 2. Quand un seul agent en fait trop

- **Il devient fragile** : Les instructions s’allongent pour limiter les erreurs, chaque petit changement oblige à tout retester, et plus personne n’ose y toucher.
- **Il se trompe** : Il appelle le mauvais outil, lui passe les mauvais paramètres, et répond différemment à la même question.
- **Il coûte plus cher** : Il lui faut les modèles les plus puissants, ses instructions grossissent à chaque appel et il recommence des étapes. Selon Anthropic, 58 outils occupent à eux seuls environ 55 000 tokens avant la première question.

## 3. Découper en agents spécialisés

La réponse est la même qu’en logiciel : découper. Un agent pour les factures, un pour les litiges, un pour les paiements. Chacun a peu d’outils, des instructions courtes et des droits limités à son domaine.

- Chaque agent est plus simple à écrire, à tester et à faire évoluer.
- Chaque agent est plus fiable : il a moins de choix possibles, donc moins d’occasions de se tromper.
- Les tâches indépendantes peuvent tourner en parallèle, ce qui raccourcit les délais.

> Ce n’est pas gratuit. Anthropic mesure qu’un système multi-agents consomme environ 15 fois plus de tokens qu’une simple conversation. Leur conseil : chercher la solution la plus simple possible, et n’ajouter de la complexité que lorsqu’elle est nécessaire.

## 4. Un agent principal qui planifie et délègue

Découper en agents indépendants a un défaut : chacun ne voit qu’une partie du contexte, et leurs décisions peuvent se contredire. D’où l’approche qui se généralise depuis 2025, popularisée par Deep Agents de LangChain et inspirée de Claude Code, Manus ou Deep Research : un agent principal garde la main sur le contexte et s’appuie sur quatre ingrédients.

- **Des instructions détaillées** : Un prompt système long et précis, qui décrit le métier, les étapes attendues et les règles à respecter.
- **Un plan** : Une liste de tâches que l’agent tient à jour : elle l’oblige à structurer son travail et permet de suivre où il en est.
- **Un espace de notes** : Un système de fichiers où l’agent dépose les résultats intermédiaires, au lieu de tout garder dans sa mémoire de travail.
- **Des sous-agents** : Des tâches précises confiées à des sous-agents au contexte isolé ; ils rendent un résultat, l’agent principal décide.

> Le principe : une seule tête qui décide, des mains qui exécutent. On garde les avantages du découpage sans perdre le fil du contexte.

## 5. Les modèles de coordination

L’agent principal qui délègue est une forme de superviseur. Mais selon le processus, d’autres façons de faire travailler des agents ensemble restent pertinentes. Les frameworks et les éditeurs utilisent des noms différents, mais on retrouve partout les mêmes familles.

*Schéma : Les schémas de coordination entre plusieurs agents.*

| Modèle | Principe | Quand l’utiliser | Point de vigilance |
| --- | --- | --- | --- |
| Workflow | Des étapes fixes, définies à l’avance ; les tâches indépendantes tournent en parallèle. | Processus connu et répétitif : rapprochement, contrôle, clôture. | Rigide face aux cas imprévus. |
| Superviseur | Un agent reçoit la demande et appelle des agents spécialisés comme des outils. | Demandes variées dans un même domaine. | Le superviseur doit bien connaître chaque agent ; c’est un point de passage unique. |
| Hiérarchique | Un agent planificateur découpe la demande et confie chaque partie à un superviseur de domaine. | Processus qui traversent plusieurs services. | Les délais et les coûts s’additionnent à chaque niveau. |
| Graphe | Des agents reliés par des transitions explicites ; le modèle choisit la branche, avec des allers-retours possibles. | Processus avec embranchements : contrôle, correction, nouvelle vérification. | Borner les boucles pour éviter qu’elles tournent sans fin. |
| Essaim | Des agents qui se passent la main d’eux-mêmes, avec une mémoire partagée. | Recherche ouverte, exploration d’un problème mal défini. | Le moins prévisible : la traçabilité est indispensable. |

Dans la vraie vie, on les combine : un workflow pour la colonne vertébrale du processus, un superviseur à l’étape qui demande du jugement, et une validation humaine avant toute écriture.

## 6. Middlewares et hooks : là où se branche la gouvernance

Un agent tourne en boucle : il interroge le modèle, appelle un outil, relit le résultat, recommence. Les frameworks récents permettent d’intervenir à chaque étape de cette boucle, sans toucher au cœur de l’agent : ce sont les middlewares et les hooks. C’est là que se posent les contrôles.

*Schéma : Les points de la boucle de l’agent où se branchent les middlewares et les hooks.*

| Moment | Ce qu’on y branche |
| --- | --- |
| Avant l’agent | Vérifier la demande et les droits de l’utilisateur, charger le bon contexte. |
| Avant chaque appel au modèle | Masquer les données personnelles, résumer un contexte trop long, choisir les outils utiles. |
| Autour de l’appel au modèle | Plafond d’appels, nouvelle tentative, repli sur un autre modèle en cas d’erreur. |
| Autour de chaque appel d’outil | Validation humaine avant une écriture, contrôle des droits, plafond d’appels, blocage ou correction des paramètres. |
| Après l’agent | Journaliser l’exécution, évaluer la réponse, déclencher une revue. |

Le modèle est désormais le même chez tous les grands acteurs, sous des noms différents :

| Framework | Mécanisme |
| --- | --- |
| LangChain et Deep Agents | Middlewares (avant et après l’agent ou le modèle, autour des appels au modèle et aux outils), dont des middlewares prêts à l’emploi : validation humaine, données personnelles, plafonds, repli de modèle, résumé du contexte |
| Claude Agent SDK (Anthropic) | Hooks : avant et après chaque outil (pour autoriser, refuser, demander ou modifier), à l’envoi d’une demande, à l’arrêt d’un sous-agent |
| OpenAI Agents SDK | Garde-fous d’entrée, de sortie et d’outil qui stoppent l’exécution, et hooks de cycle de vie |
| Strands Agents (AWS) | Hooks, par exemple avant un appel d’outil pour l’annuler ou en réécrire les paramètres |
| Google ADK | Callbacks avant et après l’agent, le modèle et chaque outil |

> La gouvernance devient du code : une même bibliothèque de middlewares validés, réutilisée par tous les agents, plutôt que des règles réécrites dans chaque prompt.

## 7. Ce que nous construisons

- **Agents autonomes** : Des agents qui enchaînent plusieurs étapes d’un processus : lire, analyser, préparer, mettre à jour, en s’arrêtant aux points de validation.
- **Talk to my data** : Poser des questions en langage courant sur les données de l’entreprise (Snowflake, Databricks, applications métiers) et obtenir des réponses chiffrées, sourcées, dans la limite des droits de chacun.
- **Aide à la décision** : Des recommandations argumentées, avec leurs sources et leur niveau de confiance, prêtes à être validées par un expert.
- **Isolation des runtimes** : Chaque agent s’exécute dans son propre environnement, avec ses propres droits : une erreur ou un abus reste contenu dans son périmètre.
- **Connecteurs métiers** : ERP, CRM, ITSM, outils financiers : les agents agissent dans les applications existantes, via des serveurs MCP gouvernés par l’AI Platform.

## 8. Les garde-fous propres aux agents métiers

- Des droits limités au domaine de chaque agent, jamais un compte « qui peut tout faire ».
- Une validation humaine avant toute écriture dans un système de gestion.
- Des sources de référence validées et versionnées : politiques, barèmes, procédures.
- Une trace complète de chaque exécution : quelles données, quels outils, quelle décision.
- Une évaluation sur des cas réels avant chaque mise à jour d’un agent ou d’un modèle.
- Un plafond de coûts par agent et par processus.
- La possibilité de suspendre un agent en une seule opération.

## 9. Par où commencer

- Choisir un processus fréquent, mesurable, où l’erreur se détecte facilement.
- Commencer par un seul agent, avec peu d’outils, en lecture seule.
- Brancher dès le départ les middlewares de contrôle : validation humaine, données personnelles, plafonds, journal.
- Quand l’agent grossit, passer à un agent principal qui planifie et délègue à des sous-agents.
- Choisir le modèle de coordination le plus simple qui fonctionne, souvent un workflow.
- Ajouter l’écriture dans les systèmes seulement après validation humaine et mesure de la qualité.

## Pour aller plus loin

- [Anthropic: Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)
- [Anthropic: How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Anthropic: advanced tool use (tool search)](https://www.anthropic.com/engineering/advanced-tool-use)
- [Microsoft: AI agent orchestration patterns](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns)
- [Strands Agents: multi-agent patterns](https://strandsagents.com/docs/user-guide/sdk/multi-agent/multi-agent-patterns/)
- [Strands Agents: agents as tools](https://strandsagents.com/docs/user-guide/sdk/multi-agent/agents-as-tools/)
- [Strands Agents: swarm](https://strandsagents.com/docs/user-guide/sdk/multi-agent/swarm/)
- [Strands Agents: graph](https://strandsagents.com/docs/user-guide/sdk/multi-agent/graph/)
- [Strands Agents: workflow](https://strandsagents.com/docs/user-guide/sdk/multi-agent/workflow/)
- [A2A: specification](https://a2a-protocol.org/latest/specification/)
- [LangChain: Deep Agents](https://www.langchain.com/blog/deep-agents)
- [LangChain: Deep Agents documentation](https://docs.langchain.com/oss/python/deepagents/overview)
- [LangChain: Deep Agents harness](https://docs.langchain.com/oss/python/deepagents/harness)
- [LangChain: LangChain and LangGraph 1.0](https://www.langchain.com/blog/langchain-langgraph-1dot0)
- [LangChain: built-in middleware](https://docs.langchain.com/oss/python/langchain/middleware/built-in)
- [LangChain: custom middleware (hooks)](https://docs.langchain.com/oss/python/langchain/middleware/custom)
- [Claude Agent SDK: hooks](https://code.claude.com/docs/en/agent-sdk/hooks)
- [OpenAI Agents SDK: guardrails](https://openai.github.io/openai-agents-python/guardrails/)
- [OpenAI Agents SDK: lifecycle hooks](https://openai.github.io/openai-agents-python/ref/lifecycle/)
- [Strands Agents: hooks](https://strandsagents.com/docs/user-guide/concepts/agents/hooks/)
- [Google ADK: callbacks](https://adk.dev/callbacks/)
- [Cognition: Don’t build multi-agents](https://cognition.com/blog/dont-build-multi-agents)
- [LangChain: How and when to build multi-agent systems](https://blog.langchain.com/how-and-when-to-build-multi-agent-systems)
