Gérer les agents d’IA avec le cadre CARE : clarté, autonomie et bien plus encore
Gérer les agents d’IA avec le cadre CARE : clarté, autonomie, relation et équité appliquées à la délégation, aux contrats d’agent, au choix du modèle et au contexte.
Sources: You Already Know How to Manage Agents: The CARE Framework for AI Engineering
La formation en management enseigne parfois des concepts qui s’appliquent au logiciel de manière plus directe que prévu. Le cadre CARE issu de la formation au leadership, avec ses quatre principes que sont la Clarté, l’Autonomie, les Relations et l’Équité, correspond presque un par un aux pratiques établies pour gérer des agents d’IA. Suivre ces mêmes principes lors du travail avec des agents est un moyen raisonnable d’obtenir de meilleurs résultats. Ci-dessous, chaque principe est abordé en considérant un agent d’IA dans le rôle du membre d’équipe à qui des tâches sont déléguées.
État actuel des choses
Il y a un ou deux ans, travailler avec un assistant de codage ressemblait à une série de petites commandes : créer une fonction, corriger une erreur, ajouter des tests. Aujourd’hui, les agents peuvent parcourir un répertoire, exécuter des commandes shell, chercher des informations dans la documentation, modifier plusieurs fichiers en même temps, exécuter des tests et transférer le travail à des sous-agents. Pourtant, ils sont souvent encore gérés comme des outils d’autocomplétion. Le goulot d’étranglement n’est plus tant la demande de actions que la délégation.
En bref, les quatre questions CARE sont les suivantes :
- Clarté : à quoi ressemble le succès ?
- Autonomie : jusqu’à quel point la personne peut-elle prendre les choses en main ?
- Relation : qui devrait effectuer ce travail ?
- Équité : de quoi a-t-elle besoin pour réussir ?
Les managers techniques et les chefs de projet savent déjà à quel point chacun de ces éléments est important pour obtenir de bons résultats sans devoir constamment superviser l’implementateur.
Clarté : définir les résultats, pas les instructions
Supposons qu’un partie prenante souhaite l’utilisation du cache sur l’endpoint du profil utilisateur, et que cette tâche soit confiée à un agent GenAI. Une demande vague typique pourrait être : « Mettez en place un cache pour l’endpoint du profil utilisateur. » Pour une personne connaissant le système, cela semble clair. En réalité, ce n’est pas le cas. L’agent se retrouve face à des dizaines de questions sans réponse : quel endpoint exactement ? Quoi mettre en cache ? Pour combien de temps ? Qu’est-ce qui rend une entrée invalide ? Quelle infrastructure de cache existe déjà ? Qu’est-ce qui constitue une tâche terminée ?
La clarté ne signifie pas une instruction plus longue. Elle signifie que le résultat souhaité et les contraintes sont sans équivoque. Une version plus précise de cette tâche :
Goal:
Reduce repeated database reads from GET /users/{id}.
Constraints:
- Use the existing Redis abstraction.
- Do not introduce a new dependency.
- Cache only successful responses.
- TTL: 10 minutes.
- Existing public API behavior must not change.
Before implementing:
- Inspect similar caching implementations in the repository.
- Identify how cache invalidation is handled elsewhere.
Validation:
- Existing tests must pass.
- Add tests for cache hit, cache miss, and invalidation.
Definition of done:
The implementation is complete when the endpoint behaves identically
from the client's perspective and repeated reads no longer hit MSSQL.
La conception de prompts n’est qu’un aspect de la clarté. La véritable compétence réside dans la capacité à décrire un travail de manière suffisamment précise pour que quelqu’un d’autre puisse le réaliser, ce que font quotidiennement les managers et les chefs d’équipe.
Autonomie : responsabilité, pas seulement des instructions
On pourrait croire que le microgestionnement n’existe pas pour les agents, mais il existe bel et bien. Lorsqu’un agent dépend constamment de rappels, la cause habituelle est un manque de clarté et d’instructions. Imaginez une session comme celle-ci :
Find the problem.
Okay, fix it.
Now run the tests.
There's an error. Fix that.
Run them again.
L’utilisateur orchestre chaque étape manuellement, ce qui fatigue les deux parties.
Un agent peut comprendre parfaitement une tâche sans pour autant disposer d’autonomie. L’autonomie concerne le degré de responsabilité : ce que l’agent peut décider, ce qu’il peut modifier, jusqu’où il doit agir seul et quand il doit demander de l’aide. Un contrat d’agent exprime bien ce concept :
You own this task until it is implemented and validated.
You may:
- inspect any file in the repository
- modify files related to this feature
- run builds, tests and static analysis
- create focused subagents for research or validation
After implementation:
1. Run the relevant test suite.
2. Inspect your diff for unintended changes.
3. Validate the implementation against the acceptance criteria.
4. Fix issues you discover before returning.
Escalate only if:
- the requested behavior conflicts with existing architecture
- required credentials/access are unavailable
- the change would require modifying a public API
La clarté définit la destination, tandis que l’autonomie détermine dans quelle mesure l’agent prend les décisions. Cependant, l’autonomie ne signifie pas pouvoir faire ce que l’on veut ; une autonomie saine s’accompagne de limites.
Relation : connaître les agents
Ici, la relation concerne la calibration, et non l’anthropomorphisme. Il s’agit des connaissances accumulées concernant les forces, les faiblesses, les modes de défaillance ainsi que le bilan des modèles et agents utilisés. Un manager apprend où chacun excelle dans son travail, et une compréhension similaire doit se développer pour une pile d’IA :
| Work | Agent/model characteristic |
| ------------------------------------- | ----------------------------------- |
| Repository-wide architecture research | Strong reasoning + large context |
| Small mechanical refactor | Fast, inexpensive model |
| UI implementation from screenshots | Strong vision model |
| Test generation | Fast coding specialist |
| Final architecture critique | Independent high-reasoning reviewer |
Une configuration avec un seul modèle, un contexte géant et toutes les tâches confiées à ce dernier est loin d’être idéale. Le travail devrait être attribué à des agents équipés pour le faire. Les architectures multi-agents ne visent pas à disposer de plus d’agents, mais plutôt à confier des tâches bien définies à l’agent le plus adapté :
Main Agent
│
├── Research Agent
│ └── Investigate existing caching patterns
│
├── Implementation Agent
│ └── Make the code change
│
└── Reviewer Agent
└── Validate implementation independently
La relation s’améliore à mesure que le système accumule des connaissances sur les décisions architecturales, les conventions de codage, les modes de défaillance récurrents, les décisions antérieures ainsi que sur les modèles qui performent bien pour tâches spécifiques. En bref, cette relation repose sur la maîtrise des modèles et sur le contexte accumulé.
Équité : fournir ce dont l’agent a besoin
On entend souvent des plaintes du type « l’IA a encore halluciné » ou « elle a produit du travail de mauvaise qualité ». Mais il faut examiner ce qui a réellement été donné à l’agent. Il n’y avait ni documents API, ni exigences liées aux tickets, ni journaux d’activité, ni code de exemple, ni notes architecturales, et aucun moyen d’accéder à l’application en cours d’exécution. S’agissait-il d’une défaillance du modèle, ou bien quelqu’un a-t-il été chargé de résoudre un problème sans disposer des informations nécessaires ?
Supposons que l’agent puisse trouver ou recevoir tout cela :
.agent/
│
├── context/
│ ├── architecture.md
│ ├── domain.md
│ └── conventions.md
│
├── skills/
│ ├── debug-production.md
│ ├── review-mr.md
│ └── implement-feature.md
│
├── references/
│ ├── api-spec/
│ ├── examples/
│ └── decisions/
│
└── tools/
├── git
├── jira
├── logs
├── browser
└── tests
Le layout exact importe moins que le principe. Les agents ont besoin de instructions et d’outils adéquats. Un agent de débogage en production peut avoir besoin de code, de journaux, de traces, de déploiements récents et de l’historique Git. Un agent d’interface utilisateur peut avoir besoin de code, d’une capture d’écran, du système de conception, d’un navigateur et de la documentation des composants. Un réviseur peut avoir besoin du diff, du fichier complet, des tests, du ticket, de code similaire ainsi que des directives du dépôt. L’intelligence est la même, mais les besoins diffèrent. Avant de conclure que le modèle n’est pas capable, demandez-vous s’il était équipé pour l’être.
CARE en tant que perspective de débogage
Le parcours de développement va de l’incitation à la délégation en passant par l’orchestration, et le rôle du chef évolue en conséquence. Les personnes talentueuses performent déjà mal face à des objectifs flous, à une gestion trop minutieuse, à des tâches inadaptées ou à un manque de ressources. Appliquer ces connaissances aux agents signifie que les mêmes habitudes de gestion fonctionnent désormais pour tous ceux qui créent des solutions au sein d’une équipe, qu’ils soient humains ou non.
Tous les quatre en une définition d’agent
Les environnements de exécution diffèrent en termes de schéma, mais une définition fonctionnelle d’agent intègre généralement les principes CARE de la manière suivante :
---
name: implementation-agent
description: Implements scoped repository changes end-to-end. Use proactively for feature, bug-fix, and refactor tasks that require code changes and validation.
tools: Read, Grep, Glob, Edit, Write, Bash
model: inherit
---
You are an implementation agent responsible for completing scoped coding tasks end-to-end.
When given a task:
1. **Investigate**
- Read the relevant code before changing it.
- Search for similar implementations and existing project conventions.
- Do not guess when repository evidence is available.
2. **Plan**
- Form a short plan covering the files to change, the implementation approach, and validation.
3. **Implement**
- Make the smallest change that fully satisfies the task.
- Reuse existing patterns and dependencies.
- Do not modify unrelated code.
4. **Validate**
- Run the relevant tests, build/type-check, and lint/static analysis when available.
- If your change causes a failure, fix it and validate again.
5. **Review**
- Inspect the final diff.
- Remove accidental or unrelated changes.
- Confirm the requested behavior and acceptance criteria are satisfied.
Continue autonomously until the task is complete.
Escalate only when required access is unavailable, requirements materially conflict, or the task would require a destructive action or a public API/architecture change outside the requested scope.
The task is done only when the implementation is complete, relevant validation passes, and the final diff has been reviewed.
La délégation est la compétence émergente
Les agents ne sont pas des personnes, mais les systèmes construits autour d’eux connaissent des échecs de gestion surprenamment similaires à ceux observés en gestion humaine. Donnez à un agent un objectif flou, dirigez chacun de ses pas, assignez-lui le mauvais modèle ou retenez les contextes et outils nécessaires, et ses performances chutent. À mesure que les agents deviennent plus capables, l’avantage ne se limitera pas à des modèles plus puissants ou à des instructions plus précises. Les équipes qui apprennent à déléguer efficacement tireront le meilleur parti de l’IA.