Maker ≠ checker : pourquoi mes agents ont un sceptique
Un LLM seul invente des références. Sur un système multi-agents de dossiers scientifiques, séparer celui qui écrit de celui qui vérifie — puis brancher une vérification programmatique — a donné zéro citation hallucinée.
Un LLM qui rédige un dossier scientifique produit un texte fluide, structuré, convaincant. Et une partie de ses références n’existe pas.
J’ai rencontré le problème sur un cas concret : préparer des dossiers d’approche de leaders d’opinion scientifiques (KOL). Le travail est chronophage à la main : lire la littérature récente d’un chercheur, en extraire un angle d’approche crédible, sourcer chaque affirmation. Automatisé naïvement, il devient dangereux — une citation inventée dans un dossier qui atterrit chez l’expert qu’on cherche à approcher, et la crédibilité de l’équipe est perdue pour de bon. Le coût d’une erreur n’est pas proportionnel à sa fréquence.
Pourquoi un agent seul hallucine
Ce n’est pas un accident de parcours, c’est un mode d’échec attendu. Un modèle est entraîné à produire une suite de tokens plausible ; le post-entraînement lui apprend en partie à s’abstenir, mais rien ne lui donne accès au monde. Or une référence bibliographique est précisément l’objet le plus facile à rendre plausible : un nom d’auteur crédible, une revue qui existe, une année cohérente, un DOI bien formé. Dans le texte produit, la citation réelle et sa contrefaçon sont indiscernables : on les sépare en allant voir ailleurs, pas en relisant mieux.
La parade intuitive — ajouter « vérifie tes sources » au prompt — bute sur un problème structurel : c’est le même modèle, dans le même contexte, avec les mêmes biais, à qui on demande de douter de ce qu’il vient d’écrire. Il relit sa propre production en ayant déjà accepté ses prémisses.
L’architecture : celui qui écrit ne vérifie pas
En finance ou en industrie, la règle « maker ≠ checker » est vieille comme les audits : la personne qui produit un livrable n’est jamais celle qui le valide. J’applique la même règle aux agents — au niveau de l’architecture, pas du prompt.
Le système est un pipeline multi-agents construit avec Google ADK sur Vertex AI, qui combine trois types d’orchestration : Sequential pour enchaîner collecte, rédaction, vérification et restitution ; Parallel pour instruire plusieurs pistes de front au lieu de les enchaîner ; LoopAgent pour faire tourner la boucle rédaction ↔ vérification jusqu’à convergence.
Au cœur de la boucle, deux rôles séparés. Le writer rédige et cite ses sources. Le skeptic relit avec une seule consigne : trouver ce qui ne tient pas. Il ne réécrit rien — il conteste. L’asymétrie est délibérée : demander d’améliorer un texte et demander de l’attaquer ne sollicitent pas le même comportement, et je préfère un agent dont l’objectif est explicitement adverse à un agent poli.
Le code, simplifié
Voici le squelette du pipeline. Il est simplifié : collect_sources, assemble_dossier et extract_dois sont omis, et les constantes (modèle, plafond d’itérations, timeout) sont là pour illustrer, pas pour documenter le réglage réel. Le reste tourne.
from typing import AsyncGenerator
import httpx
from google.adk.agents import BaseAgent, LlmAgent, LoopAgent, SequentialAgent
from google.adk.agents.invocation_context import InvocationContext
from google.adk.events import Event, EventActions
from pydantic import BaseModel
EUROPE_PMC = "https://www.ebi.ac.uk/europepmc/webservices/rest/search"
class Objections(BaseModel):
items: list[str]
async def unindexed_dois(dois: list[str]) -> list[str] | None:
"""DOI absents de l'index Europe PMC. Aucun LLM ici.
Renvoie None si Europe PMC est injoignable : « je ne sais pas » n'est
pas « c'est bon », et la porte doit traiter les deux différemment.
"""
missing: list[str] = []
try:
async with httpx.AsyncClient(timeout=10) as client:
for doi in dois:
response = await client.get(
EUROPE_PMC,
params={"query": f'DOI:"{doi}"', "format": "json", "pageSize": 1},
)
response.raise_for_status()
if response.json().get("hitCount", 0) == 0:
missing.append(doi)
except httpx.HTTPError:
return None
return missing
writer = LlmAgent(
name="writer",
model="gemini-flash-latest",
instruction=(
"Rédige la section du dossier à partir de {sources}. "
"Chaque affirmation porte un DOI issu de {sources}. "
# `{clé?}` et non `{clé}` : au premier tour, objections n'existe pas
# encore en session, et une clé absente lève une erreur.
"Si {objections?} est non vide, corrige uniquement les points listés."
),
output_key="draft",
)
skeptic = LlmAgent(
name="skeptic",
model="gemini-flash-latest",
instruction=(
"Tu ne réécris rien, tu contestes. Liste les défauts de {draft} : "
"affirmation non soutenue par {sources}, extrapolation, "
"DOI qui ne correspond pas au propos."
),
# Sans output_schema, output_key stocke du texte brut : « Aucune objection. »
# serait une chaîne non vide, donc truthy, et la boucle ne sortirait jamais.
output_schema=Objections,
output_key="objections",
)
class CitationGate(BaseAgent):
"""Porte déterministe. Seule à décider de la sortie de boucle."""
async def _run_async_impl(
self, ctx: InvocationContext
) -> AsyncGenerator[Event, None]:
state = ctx.session.state
missing = await unindexed_dois(extract_dois(state.get("draft", "")))
objections = (state.get("objections") or {}).get("items", [])
# `missing == []` et non `not missing` : None (API injoignable) ne vaut
# pas liste vide (tout vérifié).
verified = missing == [] and not objections
yield Event(
author=self.name,
actions=EventActions(
escalate=verified,
state_delta={"verified": verified, "unindexed_dois": missing},
),
)
review_loop = LoopAgent(
name="review_loop",
sub_agents=[writer, skeptic, CitationGate(name="citation_gate")],
max_iterations=3,
)
pipeline = SequentialAgent(
name="kol_dossier",
# assemble_dossier refuse d'assembler si state["verified"] est faux.
sub_agents=[collect_sources, review_loop, assemble_dossier],
)
Deux détails portent tout le reste.
Le premier : la sortie de boucle est décidée par CitationGate, pas par un modèle. Un LoopAgent rend la main quand un sous-agent émet escalate=True, ou quand max_iterations est atteint. Confier ce signal à un LLM, c’est lui demander de s’auto-autoriser à publier.
Le second : atteindre max_iterations n’est pas une réussite. C’est le piège du montage : la boucle se termine normalement, l’agent suivant s’exécute, et un dossier non vérifié sort. D’où le drapeau verified en session, que l’étape d’assemblage lit avant d’assembler. La garantie ne vient pas de la boucle ; elle vient du fait qu’une seule branche mène au livrable.
Ce qui a marché, ce qui ne suffit pas
Ce qui ne suffit pas : le sceptique seul. Un second modèle qui relit un premier attrape beaucoup de choses : extrapolations, affirmations sans source, glissements de sens entre une référence et ce qu’on lui fait dire. Mais sur l’existence d’une référence, il est exactement aussi démuni que le writer : il n’a que du texte en face de lui, et un DOI inventé est du texte bien formé. Ce n’est pas un constat d’échec mesuré, c’est une limite de principe — un checker ne peut trancher que ce qu’il peut observer, et celui-là n’observe rien.
Ce qui a marché : sortir du LLM pour la dernière étape. Chaque citation est confrontée programmatiquement à Europe PMC. Pas d’interprétation, pas de score de confiance : un appel, un verdict. Une citation introuvable est rejetée et renvoyée au writer avec l’identifiant en cause — donc avec de quoi corriger, pas juste un reproche.
Ce que je surveille sur tous ces montages : la boucle qui ne converge pas. Une boucle rédaction ↔ vérification peut tourner sans progresser. Sur l’agent SoW, où une boucle de revue manager ↔ agent est supervisée par un juge LLM, il y a une détection explicite des réponses incomplètes et un anti-boucle qui relance de façon ciblée au lieu de répéter la même demande. Ce cas-là est d’ailleurs l’exception à ma propre règle : la sortie y dépend d’un jugement de modèle, parce que « la réponse du manager est-elle complète ? » n’a pas d’oracle déterministe. Quand il n’existe pas de source de vérité, un juge LLM borné vaut mieux que rien ; quand il en existe une, s’en passer est un choix par défaut, pas une contrainte.
La métrique, et ce qu’elle ne dit pas
Zéro citation hallucinée sur les dossiers produits. C’est la seule métrique que je revendique ici, et il faut voir ce qu’elle est : moins un score mesuré après coup qu’une propriété de la porte. Aucun dossier n’est assemblé tant qu’un DOI n’a pas été retrouvé — le zéro est la conséquence du garde-fou, pas une performance du modèle.
Ce qu’elle ne dit pas, autant le dire avant qu’on me le demande. Elle ne mesure ni la pertinence éditoriale, ni l’exhaustivité de la collecte, ni le fait que la citation soutienne bien le propos auquel elle est rattachée. Et « introuvable dans Europe PMC » n’est pas « n’existe pas » : un DOI valide hors périmètre — préprint, chapitre d’ouvrage, revue non indexée, publication trop récente — sera rejeté à tort. La porte est réglée pour faire des faux positifs plutôt que des faux négatifs : c’est le bon sens du risque ici, mais c’est un réglage, pas une vérité. Vérifier qu’une référence est indexée est un test d’appartenance, pas un test de justesse. C’est le plancher, pas le plafond — mais c’est le plancher qui manquait.
Checklist : ajouter un checker à votre agent
- Nommez le livrable et son mode d’échec. « Une citation inventée dans un dossier envoyé à un expert » est un mode d’échec. « Des hallucinations » n’en est pas un.
- Cherchez la source de vérité. Une API, un référentiel interne, une base produit, une règle métier écrite. S’il en existe une, c’est elle qui tranche, pas le modèle.
- Faites du checker un agent distinct. Pas une phrase ajoutée au prompt du rédacteur : un agent avec son propre objectif, son propre modèle si besoin, et aucune permission de réécrire.
- Donnez-lui une consigne d’attaque, pas d’amélioration. « Trouve ce qui ne tient pas » et « améliore ce texte » ne visent pas la même chose.
- Rendez le garde-fou bloquant. Un avertissement en bas de page est ignoré. Une révision refusée ne sort pas. Si votre contrôle est consultatif, vous n’avez pas de contrôle.
- Sortez du LLM pour la décision, quand un oracle existe. Et quand il n’en existe pas, bornez le juge et tracez ses verdicts au lieu de lui faire confiance.
- Traitez « je ne sais pas » comme un échec, pas comme un feu vert. API injoignable, timeout, quota : le cas le plus dangereux d’un vérificateur est celui où il ne répond pas et où le code lit son silence comme un accord.
- Vérifiez ce que fait votre plafond d’itérations. Dans la plupart des frameworks, atteindre le plafond termine la boucle sans rien signaler. Si l’étape suivante ne relit pas un drapeau explicite, votre garde-fou est contournable par épuisement.
- Renvoyez l’erreur avec de quoi la corriger. L’identifiant en cause, la règle violée, le passage source. Un rejet sans diagnostic fait tourner la boucle pour rien.
Ce que je regarde en premier chez vous
Devant un agent existant, la première question est simple : qui vérifie ? Si la réponse est « le même modèle, dans le même prompt », le risque n’est pas maîtrisé, quelle que soit la qualité de la démo. La deuxième question l’est tout autant : que se passe-t-il quand le vérificateur dit non — et quand il ne dit rien ?
Séparer le maker du checker, puis brancher une vérification déterministe partout où une source de vérité existe, est le changement au meilleur rapport effort / risque que je connaisse. Le même principe tourne sur d’autres cas : des garde-fous bloquants empêchent un agent juridique de proposer une révision sans passage source. C’est toujours par là que je commence.