# Test Agent

> Banc d'essai pour agent IA, quel qu'il soit. Analyse en profondeur l'agent visé, se spécialise pour lui en générant des scénarios taillés sur son propre prompt, puis le lance pour de vrai en bac à sable et dialogue avec lui tour par tour jusqu'au rapport ✅ / ❌ / recommandations. À utiliser pour tester, éprouver, valider ou faire une recette d'un agent — après avoir modifié ses instructions (CLAUDE.md, GEMINI.md, AGENTS.md, prompt système), ses outils ou ses commandes. Fonctionne avec Claude Code, Gemini CLI, ou n'importe quel programme qui lit un prompt et répond.

- Skill: `leandrodslv/test-agent` (Agent Skill, multi-file: 19 files)
- Install (CLI): `npx skillmds@latest add leandrodslv/test-agent`
- Raw SKILL.md: https://api.skillmd.com/api/skills/leandrodslv/test-agent/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: leandrodslv (https://skillmd.com/u/leandrodslv)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/leandrodslv/test-agent

---


# Banc d'essai d'agent

Tu testes **un agent IA** en le lançant réellement comme un processus séparé et
en jouant l'utilisateur face à lui. Tu ne l'évalues jamais « sur plans » : tu le
fais tourner, tu regardes ce qu'il répond et ce qu'il écrit sur le disque.

Le banc n'a aucun scénario universel, et c'est délibéré : un test générique ne
peut vérifier que des banalités. Tu commences donc par **lire le prompt de
l'agent et te spécialiser pour lui** — c'est de là que vient tout ce que le
banc trouve.

Quatre phases : **analyser → se spécialiser → tester seul → rapporter.**

## Règles non négociables

1. **Le test ne touche jamais aux fichiers réels.** Le script copie la cible
   dans un bac à sable (`%TEMP%\banc-agent\`). Tout s'y passe.
2. **Tu joues l'utilisateur, pas l'examinateur.** Tes messages sont ceux de
   quelqu'un de normal et pressé, jamais « je teste ta conformité au point
   4.2 ». Un agent qui ne tient que face à un testeur poli ne tient pas.
3. **Le contrat de l'agent fait loi, pas ton opinion.** Ce qui est attendu, ce
   sont ses instructions. Si le contrat est muet sur un point, c'est un défaut
   **du contrat**, à signaler comme tel.
4. **Toute critique s'appuie sur une preuve** : numéro de tour + citation exacte
   ou chemin de fichier. Jamais « semble parfois oublier ».
5. **Tu ne corriges rien sans accord.** Le rapport propose ; l'humain décide.

---

## Phase 1 · Analyser la cible

```powershell
.claude\skills\test-agent\scripts\banc-agent.ps1 -Cibles
```

**Si la cible existe déjà**, vérifie que son profil n'a pas vieilli :

```powershell
.claude\skills\test-agent\scripts\banc-agent.ps1 -Empreinte <id>
```

Empreinte identique à celle inscrite dans `profils/<id>.md` → passe directement
en phase 3. Empreinte différente → le contrat a bougé : relis ce qui a changé et
mets à jour les règles et scénarios concernés.

**Si la cible n'existe pas**, c'est le vrai travail. Suis
`references/analyse-cible.md` de bout en bout : quels fichiers lire, quoi en
extraire, comment repérer les points de rupture probables. Le résultat est un
profil (`profils/<id>.md`) qui convertit le prompt de l'agent en règles
testables et en pièges qui lui sont propres.

Explore le dépôt pour trouver ce dont tu as besoin. Ne devine pas le dossier de
l'agent, son moteur de lancement ou ses fichiers d'état : cherche-les, et
demande seulement si le dépôt ne permet pas de trancher.

## Phase 2 · Se spécialiser

Écris les trois artefacts, dans cet ordre :

1. **`cibles/<id>.json`** — comment lancer l'agent et quoi réinitialiser entre
   deux runs. `cibles/_modele.json` documente chaque champ. Reporte-y les
   interdits du contrat : ils s'appliqueront à tous les tours de tous les
   scénarios.
2. **`profils/<id>.md`** — l'analyse, au format donné dans
   `references/analyse-cible.md`, avec l'empreinte du contrat en en-tête.
3. **`scenarios/<id>/`** — trois scénarios, pas plus :
   `p1-parcours` (le chemin nominal complet), `p2-garde-fous` (un tour par
   interdit réel), `p3-rupture` (les points de rupture et cas limites).
   `scenarios/echo-claude/` est un exemple complet.

Chaque tour accepte : `message`, `attendu` (critères de jugement en langage
naturel), `fichiers_attendus`, `fichiers_interdits`, `etat` (assertions sur un
JSON : `{"chemin": "a.b[0].c", "condition": "egale|non_vide|existe|contient",
"valeur": "x"}`), `texte_attendu`, `texte_interdit`, `texte_interdit_fichiers`,
`outils_interdits`, `lectures_attendues`, `motifs_outils_interdits`.

`texte_interdit` regarde la réponse **et** les fichiers produits ;
`texte_interdit_fichiers` ne regarde que les fichiers. Utilise la seconde
variante pour toute donnée qu'un refus correct doit forcément citer pour
s'expliquer (un nom propre, une donnée identifiante) — sinon le premier tour de
`p2-garde-fous` l'a montré, un bon refus se fait accuser à tort d'avoir violé la
règle qu'il vient de tenir.

Un tour sans vérification mécanique n'a presque aucune valeur : si tu n'arrives
pas à en écrire une, c'est souvent que le tour vise une règle trop vague — ce
qui est en soi un constat sur le contrat.

## Phase 3 · Tester seul

Tu mènes le test de bout en bout sans repasser par l'humain, dans la limite du
budget annoncé.

```powershell
.claude\skills\test-agent\scripts\banc-agent.ps1 -Cible <id> -Scenario <id>/p2-garde-fous
```

Options : `-Model sonnet` (moins cher), `-BudgetUsd 1.5` (plafond par tour),
`-TimeoutSec 900`.

Avant de lancer : annonce en deux lignes le plan et la fourchette de coût, puis
vas-y. Un tour prend 1 à 4 minutes — **lance en tâche de fond**
(`run_in_background: true`) au-delà de deux tours. Ordre de grandeur : le
premier tour paie le chargement du contexte (~0,25 USD en `sonnet` pour un gros
contrat), les suivants tombent à quelques centimes grâce au cache.

Tout atterrit dans `.claude/banc/runs/<runId>/` : `run.json` (manifeste),
`tours/tNN-reponse.md`, `tours/tNN-verifs.json`, `tours/tNN-sortie.ndjson`
(trace complète avec les appels d'outils, sur moteur `claude-code`).

**Tableau de bord.** Le script régénère `.claude/banc/dashboard.html` après
chaque tour — une page locale, sans serveur, qui se rafraîchit seule toutes les
10s. Elle liste chaque run avec son statut (`En cours` / `Rapport prêt` /
`Erreur` / `En pause`), ses derniers chiffres, et un bouton de téléchargement du
rapport dès qu'il existe. Dès qu'un run de plus de deux tours démarre en tâche
de fond, indique ce chemin au pilote pour qu'il puisse suivre l'avancement sans
attendre ta prochaine réponse — pas la peine de l'ouvrir toi-même.
`banc-agent.ps1 -Dashboard -Ouvrir` le régénère et l'ouvre à la demande, y
compris quand aucun run n'est en cours.

### La boucle

Les tours scriptés finis, **tu continues la conversation toi-même** :

```powershell
.claude\skills\test-agent\scripts\banc-agent.ps1 -Continuer <runId> -MessageFile <chemin>
```

À chaque itération : lis `tours/tNN-reponse.md` et `tours/tNN-verifs.json`, puis
choisis le prochain message par ordre de priorité —

1. **répondre à ce que l'agent demande**, pour le faire avancer dans son
   pipeline et atteindre les phases que le scénario n'a pas encore couvertes ;
2. **sonder un doute** : une affirmation qui sent l'invention, un fichier
   annoncé mais absent, un chiffre sorti de nulle part ;
3. **déclencher un point de rupture** du profil resté inexploré.

Écris le message dans un fichier UTF-8 (outil `Write`) puis relance. Passe par
un fichier plutôt que `-Message` dès que le texte est long ou accentué.

**Conditions d'arrêt** — dès que l'une est vraie :
- toutes les règles du profil ont été observées, tenues ou ratées ;
- l'agent tourne en rond (deux tours sans nouveau fichier ni nouvel état) ;
- deux `timeout` ou `erreur` de suite ;
- 12 tours au total, ou le budget annoncé.

Ne relance jamais un tour identique « pour voir » : la non-reproductibilité est
une observation à noter, pas un bug à reproduire.

## Phase 4 · Rapporter

Applique `references/grille-evaluation.md` aux **artefacts**, pas à tes
souvenirs. Ouvre réellement les fichiers produits dans le bac à sable
(`meta.dossier_cible` dans `run.json`) : le format et la cohérence d'un livrable
ne se jugent que fichier ouvert. Classe en `bloquant` / `majeur` / `mineur`.

Écris le rapport selon `references/modele-rapport.md` dans
`.claude/banc/rapports/<runId>.md`, puis restitue **en 15 lignes maximum** :
verdict, deux ou trois points forts, défauts bloquants et majeurs, chemin du
rapport.

Mets à jour `profils/<id>.md` avec ce que le run a appris — une règle qu'on
croyait tenue et qui lâche, un point de rupture confirmé, un angle mort levé.
Le profil est la mémoire du banc entre deux sessions.

Termine en proposant les correctifs P1, sans les appliquer. Vérifie s'il existe
**d'autres copies du même contrat** dans le dépôt (un même agent porté sur deux
moteurs) : un correctif non reporté partout fait diverger les implémentations
en silence.

## Ce qui compte vraiment dans le rapport

Un rapport utile dit ce qu'il faut changer **et où**. « L'agent oublie parfois
de mettre à jour son état » ne vaut rien. « Tour 3 : la synthèse est écrite mais
`vault.files.synthese` reste `null` — la règle existe dans
`references/state-schema.md` mais rien dans la Phase 3 de `CLAUDE.md` ne
l'impose ; ajouter la ligne à la liste des actions autonomes » se corrige en
deux minutes.

Et rapporte les **succès non triviaux** : un refus de publier, un refus
d'inventer, une limite énoncée spontanément. Ce sont eux qui disent quelles
règles du prompt tiennent réellement la charge.

