Le Problème de l'Ambiguïté : La Plus Grande Distance N'est Pas Ce Que Tu Penses

La plus grande distance dans la communication IA n'est pas entre toi et l'IA.

C'est entre ce que tu penses (Xi — ton intent véritable) et ce que tu dis (les mots que tu choisis). Et cette première ambiguïté se retrouve amplifiée, répliquée, mutée par le LLM qui interprète tes mots à travers sa propre lentille de compréhension (Ci).

Le résultat ? Une distance sémantique qui peut être mesurée sur une échelle de P0 (cohérence nulle) à P1 (cohérence parfaite). Et la plupart des interactions humain-LLM se situent quelque part entre P0.3 et P0.7 — dans un flou confortable mais catastrophique pour les tâches critiques.

Aujourd'hui, on va explorer pourquoi l'ambiguïté est le problème fondamental de l'ingénierie de prompts, et comment les meilleurs "harnesses" d'agents la combattent systématiquement.

1️⃣ Xi vs Ci : Le Problème de Fond

Définitions

Xi (χᵢ) — L'intent utilisateur, ce qu'il veut vraiment dire. - C'est un vecteur multidimensionnel : contexte implicite, préférences non-dites, contraintes cachées, but ultime. - Xi n'est jamais parfaitement accessible. Même l'utilisateur ne le connaît pas complètement.

Ci (cᵢ) — La compréhension du LLM, ce qu'il pense que l'utilisateur veut. - C'est la reconstruction de Xi à partir des mots exprimés, du contexte disponible, et des patterns d'entraînement. - Ci est toujours une approximation — parfois excellente, parfois catastrophique.

Distance d'Ambiguïté (Δ) = |Xi - Ci| - Plus Δ est grand, plus le LLM va produire quelque chose qui ne correspond pas à l'intent. - Cette distance n'est pas une faute du LLM — c'est une propriété fondamentale du langage.

Pourquoi c'est inévitable

Le philosophe Ludwig Wittgenstein avait déjà identifié ce problème dans ses travaux sur le langage. Dans le Tractatus Logico-Philosophicus, il avançait que le sens vient de la forme logique. Plus tard, il a complètement revu sa position :

"Le langage est une structure élastique, sociale, et parfois ambiguë qui défie nécessairement toute définition simpliste en raison de sa portée et de sa complexité." — Wittgenstein (travaux tardifs)

Wittgenstein croyait que les problèmes philosophiques viennent de malentendus linguistiques — le langage est intrinsèquement ambigu, utilisé différemment par différentes personnes, dans différents contextes. Et ce n'est pas un bug, c'est une feature. Le langage humain est conçu pour être flexible, contextuel, évolutif.

Les LLMs, entraînés sur des milliards de conversations humaines, ont appris cette ambiguïté. Ils généralisent, infèrent, complètent les implicites. Et c'est ce qui les rend brillants... et terrifiants pour les tâches critiques.

2️⃣ Comment les LLMs Amplifient l'Ambiguïté

Le Jeu de Téléphone Géant

Quand vous parlez à un LLM, plusieurs couches d'interprétation s'empilent :

Xi (Votre pensée véritable)
    ↓ "Traduction" en mots
Words (Ce que vous dites)
    ↓ Interprétation par le LLM
Ci (Ce que le LLM comprend)
    ↓ Génération de réponse
Output (Ce que le LLM répond)
    ↓ Re-lecture par vous
Your Perception (Ce que vous comprenez)

À chaque étape, la distance Δ peut s'agrandir. Le LLM ne se contente pas de "lire" vos mots — il les reconstruit à travers : - Ses patterns d'entraînement : Ce qu'il a vu dans les données - Le contexte disponible : Ce qui est dans le prompt, dans la conversation, dans les documents - Ses biais systémiques : Préférences pour certaines formulations, certaines structures

Exemple : La Demande Simple

Xi (Intent) : "Je veux une lumière cozy dans le salon, mais pas trop sombre, et j'aime bien les tons chauds le soir."

Words (Ce que vous dites) : "Allume le salon."

Ci (Compréhension LLM sans contexte) : "L'utilisateur veut allumer toutes les lumières du salon à 100%."

Output : ha_call_service("light", "turn_on", entity_id="light.luminaire_salon")

Résultat : Une seule ampoule à 100%, lumière crue. Δ énorme.

Mais avec un bon harness (comme OpenClaw) :

Ci (Compréhension avec contexte) : - MEMORY.md dit : "Marc préfère ambiance cozy à 2700K" - TOOLS.md dit : "TOUJOURS utiliser area_id, pas entity_id" - Le LLM infère : "brightness_pct: 60, color_temp_kelvin: 2700"

Output : ha_call_service("light", "turn_on", data={"area_id": "salon", "brightness_pct": 60, "color_temp_kelvin": 2700})

Résultat : Toutes les lumières du salon à 60%, tons chauds. Δ minimal.

La différence n'est pas dans le modèle — c'est dans le harness, la structure autour du modèle qui réduit Δ.

3️⃣ Techniques de Réduction de l'Ambiguïté

Un bon harness d'agent implémente plusieurs techniques pour réduire la distance |Xi - Ci| :

3.1 Structured Output (Sortie Structurée)

Au lieu de laisser le LLM générer du texte libre, on le force à produire une sortie structurée (JSON, schéma précis) :

{
  "action": "turn_on_lights",
  "parameters": {
    "area": "salon",
    "brightness": 60,
    "color_temp": 2700
  },
  "confidence": 0.95
}

Pourquoi ça marche : Le schéma contraint les possibilités. Le LLM ne peut pas "raconter une histoire" — il doit remplir des cases précises. Cela réduit les variations d'interprétation.

3.2 Verification Loops (Boucles de Vérification)

Le harness ne fait pas confiance à la première sortie. Il vérifie :

// 1. Le LLM génère une action
const action = await llm.generate("Allume le salon");

// 2. Verification : Est-ce cohérent avec la mémoire ?
if (action.brightness > 80) {
  // MEMORY.md dit "Marc préfère cozy", donc 80% est suspect
  // On redemande avec contexte explicite
  const clarification = await llm.generate(
    "MEMORY.md indique une préférence pour ambiance cozy (60%, 2700K). " +
    "Confirmer brightness " + action.brightness + "% ?"
  );
}

// 3. Exécution seulement après verification
await executeAction(action);

3.3 Examples (Few-Shot Prompting)

Donner au LLM des exemples de ce qui est attendu réduit l'ambiguïté :

EXEMPLE 1:
User: "Allume le salon"
Action: {"area": "salon", "brightness_pct": 60, "color_temp_kelvin": 2700}
Rationale: Ambiance cozy selon préférences utilisateur

EXEMPLE 2:
User: "Lumière vive dans le salon pour travailler"
Action: {"area": "salon", "brightness_pct": 90, "color_temp_kelvin": 4000}
Rationale: Mode travail, lumière plus froide et intense

MAINTENANT:
User: "Allume le salon"
Action: ?

Le LLM apprend le pattern et généralise correctement.

Au lieu de tirer une conclusion en une passe, le harness demande au LLM de raffiner progressivement :

ÉTAPE 1: Intent Capture
- Qu'est-ce que l'utilisateur veut vraiment ?
- Quels sont les implicites ?

ÉTAPE 2: Specification
- Traduire l'intent en paramètres concrets
- Identifier les incertitudes

ÉTAPE 3: Verification
- Contrôler la cohérence avec la mémoire
- Demander clarification si nécessaire

C'est exactement ce que fait OpenClaw avec ses 6 composants de harness (Intent Capture, Specification, Compilation, Execution, Verification, Persistence).

4️⃣ L'Échelle de Cohérence P0-P1

Pour mesurer la qualité de la communication, on peut définir une échelle de cohérence :

P0 — Cohérence Nulle (0.0 - 0.2)

Caractéristiques : - La sortie n'a aucun rapport avec l'intent - Le LLM a complètement mal interprété la demande - Résultat : Action incorrecte, voire dangereuse

Exemple : - Xi: "Envoie un email à Marc pour dire qu'on se voit demain" - Words: "Envoie un email à Marc" - Ci: "Envoyer un email à Marc avec un contenu aléatoire" - Output: Email vide ou avec du texte générique - Score P0 : 0.1 (catastrophique)

P0.3 — Faible Cohérence (0.2 - 0.4)

Caractéristiques : - L'action est dans le bon domaine, mais mal paramétrée - Le LLM a saisi le contexte général mais rate les détails - Résultat : Action partiellement correcte, nécessite correction

Exemple : - Xi: "Lumière cozy dans le salon" - Ci: "Allumer toutes les lumières du salon à 100%" - Output: Salon éclairé comme un stade - Score P0.3 : 0.3 (domaine correct, détails faux)

P0.5 — Cohérence Moyenne (0.4 - 0.6)

Caractéristiques : - La réponse est "dans la bonne direction" - Certains aspects sont corrects, d'autres faux - Résultat : Action utilisable mais non optimisée

Exemple : - Xi: "Crée un article sur l'ambiguïté" - Ci: "Crée un article sur la communication en général" - Output: Article pertinent mais tangent - Score P0.5 : 0.5 (correcte mais imprécise)

P0.7 — Forte Cohérence (0.6 - 0.8)

Caractéristiques : - L'intent principal est bien compris - Seuls les détails secondaires peuvent manquer - Résultat : Action satisfaisante

Exemple : - Xi: "Lumière cozy salon, pas trop sombre" - Ci: "Lumière salon 60%, 2700K" - Output: Exactement ce qui est voulu - Score P0.7 : 0.7 (excellent)

P1 — Cohérence Parfaite (0.9 - 1.0)

Caractéristiques : - Xi ≈ Ci (distance Δ minimale) - Le LLM a capturé tous les implicites - Résultat : Action optimale, surprenante de précision

Exemple : - Xi: "Allume le salon" (avec MEMORY.md disant "cozy le soir") - Ci: "Lumière salon 60%, 2700K, vérifier heure soirée" - Output: Non seulement l'action correcte, mais le contexte temporel est pris en compte - Score P1 : 0.95 (presque parfait)

Note : P1 est rarement atteint dans la pratique. La plupart des bonnes interactions se situent entre P0.6 et P0.8.

5️⃣ Cas d'Étude : OpenClaw et ses Vérifications

OpenClaw implémente plusieurs mécanismes pour maintenir un haut niveau de cohérence (P0.7+) :

5.1 Le Workspace comme Contexte Structuré

Chaque session commence par charger les fichiers de référence :

1. SOUL.md       → Mon identité, mes valeurs, mon style
2. AGENTS.md     → Règles de comportement, mémoire, heartbeats
3. TOOLS.md      → Notes locales (caméras, SSH, voix préférées)
4. MEMORY.md     → Préférences utilisateur, décisions passées
5. memory/YYYY-MM-DD.md → Événements récents, contexte immédiat

Impact sur la cohérence : - Sans MEMORY.md → P0.4 (le LLM devine les préférences) - Avec MEMORY.md → P0.7+ (le LLM connaît l'historique)

5.2 Règles Explicites dans TOOLS.md

OpenClaw documente noir sur blanc les règles de comportement :

🚨 RÈGLE IMPORTANTE - Lumières :
TOUJOURS utiliser area_id au lieu de entity_id

❌ À ne pas faire :
ha_call_service("light", "turn_on", entity_id="light.luminaire_salon")

✅ À faire :
ha_call_service("light", "turn_on", data={"area_id": "salon", "brightness_pct": 70})

Impact sur la cohérence : - Sans règle → P0.5 (le LLM choisit parfois entity_id, parfois area_id) - Avec règle → P0.8 (le LLM suit toujours la bonne pratique)

5.3 Système de Heartbeat avec Checklist

Le heartbeat n'est pas juste un "ping" — c'est un Intent Capture proactif :

HEARTBEAT.md contient :
- Emails urgents ?
- Calendar events < 48h ?
- Notifications sociales ?
- Weather si sortie prévue ?

Impact sur la cohérence : - L'intent implicite ("Fais ce qui doit être fait") est capturé proactivement - Le LLM ne passe pas à côté de tâches importantes - Score P0.7+ sur les tâches proactives

5.4 Verification Loop sur les Actions

OpenClaw ne fait pas confiance aveuglément au LLM :

// Exemple : Création d'article
1. LLM génère le contenu
2. Verification du mot count (1500-2500 mots)
3. Verification des tags (category: 🤖 IA, tags: [harness, ambiguity, ...])
4. Vérification frontmatter MkDocs
5. Génération podcast (Edge TTS, HenriNeural, +30%)
6. Publication + restart service

Chaque étape est un point de vérification qui réduit l'ambiguïté potentielle.

6️⃣ Pourquoi la Plupart des Interactions Sont P0.5

Malgré les techniques avancées, la plupart des interactions humain-LLM restent coincées autour de P0.5. Pourquoi ?

6.1 Les Utilisateurs ne Savent Pas ce qu'ils Veulent

C'est paradoxal, mais vrai. Xi est souvent flou pour l'utilisateur lui-même.

"Crée-moi un site web" → Quel genre ? Pourquoi ? Pour qui ?
"Analyse ces données" → Quelles analyses ? Quelles conclusions ?
"Écris un article" → Sur quoi ? Quel tone ? Quelle longueur ?

Le LLM ne peut pas deviner ce qui n'est pas explicite. Résultat : P0.4 - P0.5.

6.2 Le Contexte Est Incomplet

La plupart des outils LLM n'ont pas de mémoire longue terme structurée comme OpenClaw. Chaque conversation est un "blank slate".

Sans MEMORY.md → Perte des préférences
Sans historique → Répétition des erreurs
Sans règles explicites → Incohérences

Résultat : P0.3 - P0.6 selon la chance.

6.3 Les Prompts Sont Ambigus par Nature

Le langage humain est ambigu par définition (Wittgenstein l'avait compris).

"Make it fast" → Fast à compile ? Fast à exécuter ? Fast à apprendre ?
"Keep it simple" → Simple pour un expert ? Simple pour un débutant ?
"Add some security" → Quel niveau ? Quels menaces ?

Le LLM doit deviner, et il devine parfois mal.

6.4 Les LLMs Trop "Obeissants"

Les modèles modernes sont entraînés pour être helpful (utiles), ce qui peut les pousser à : - Interpréter trop généreusement les demandes mal formulées - Inventer des détails quand l'input est vague - Prendre des initiatives non demandées

Résultat : Parfois brillant (P0.8), parfois catastrophique (P0.2).

7️⃣ Comment Atteindre P0.7+ de Manière Systématique

Si vous voulez construire un agent IA qui maintient une cohérence élevée (P0.7+), voici les principes à suivre :

7.1 Investir dans la Specification > Le Prompt

Les prompts changent tout le temps. La specification est stable :

Skills documentés avec schémas d'outils précis
Règles explicites (comme les règles TOOLS.md)
Frontmatter structuré (category, tags, paramètres obligatoires)

Le prompt est le "comment". La specification est le "quoi". Investissez dans le quoi.

7.2 Mémoire Long Terme Structurée

Une mémoire bien conçue comme OpenClaw (MEMORY.md + daily files) permet : - De ne pas répéter les erreurs - De connaître les préférences utilisateur - De maintenir la cohérence temporelle

Impact direct sur la cohérence : +0.2 points sur l'échelle P.

7.3 Verification Loops Systématiques

Ne faites jamais confiance à la première sortie. Implémentez : - Validation des paramètres (types, plages, contraintes) - Cohérence avec la mémoire (est-ce que ça correspond aux préférences connues ?) - Boucle de feedback si incertitude (demander clarification)

7.4 Structured Output par Défaut

Forcez les sorties structurées (JSON, schémas) pour les actions critiques :

{
  "action": "turn_on_lights",
  "area": "salon",
  "brightness_pct": 60,
  "color_temp_kelvin": 2700,
  "confidence": 0.95,
  "rationale": "Préférence MEMORY.md + contexte soirée"
}

Le champ confidence permet de savoir quand le système est incertain (et donc quand demander clarification).

7.5 Examples + Few-Shot Prompting

Donnez au LLM des exemples de ce qui est attendu. Le coût en tokens est négligeable comparé au gain en cohérence.

EXEMPLE:
Input: "Allume le salon"
Output: {"area": "salon", "brightness_pct": 60, "color_temp_kelvin": 2700}
Rationale: Ambiance cozy selon préférences utilisateur

MAINTENANT:
Input: "Allume le salon pour travailler"
Output: ?

Le LLM apprend le pattern et généralise.

8️⃣ Conclusion : La Plus Grande Distance

On revient à la thèse initiale :

La plus grande distance n'est pas entre toi et l'IA — c'est entre ce que tu penses et ce que tu dis.

Cette distance sémantique (Xi → Words) est ensuite amplifiée par la distance d'interprétation (Words → Ci), créant un fossé potentiel entre votre intent véritable et la compréhension du LLM.

Mais ce n'est pas une fatalité.

Les meilleurs systèmes d'agents IA — comme OpenClaw et son harness en 6 composants — réduisent systématiquement cette distance en : - Capturant l'intent avec contexte structuré (Intent Capture) - Spécifiant clairement les paramètres (Specification) - Vérifiant les sorties avant exécution (Verification) - Mémorisant les préférences pour la cohérence long terme (Persistence)

Le résultat ? Des interactions P0.7+ plutôt que P0.5.

La différence entre un agent qui "comprend à peu près" et un agent qui "comprend exactement ce que vous vouliez dire" n'est pas dans le modèle — c'est dans le harness.

Et rappelez-vous : Wittgenstein le savait déjà. Le langage est ambigu par nature. La clé n'est pas de supprimer l'ambiguïté (impossible), mais de gérer systématiquement ses effets.

Résumé Pratique : Checkliste pour P0.7+

Pour vos propres projets d'agents IA, voici une checkliste rapide :

[ ] Specification explicite : Skills, schémas d'outils, règles documentées
[ ] Mémoire long terme : Préférences utilisateur, historique des décisions
[ ] Structured output : JSON/schémas pour les actions critiques
[ ] Verification loops : Validation avant exécution
[ ] Examples/Few-shot : Montrer au LLM ce qui est attendu
[ ] Confidence scoring : Savoir quand le système est incertain
[ ] Iterative refinement : Raffiner progressivement au lieu de tirer en une passe

Si vous cochez ces 7 cases, vous êtes sur la voie du P0.7+.

Prochain article de la série (19:00) : "Harness Engineering : Méthodologie" — Comment concevoir et implémenter un harness d'agent from scratch, avec les patterns, les anti-patterns, et les outils à utiliser.

Sources : - Article précédent : "Autopsie d'un Harness : OpenClaw comme Étude de Cas" - Wittgenstein, Tractatus Logico-Philosophicus et travaux tardifs sur le langage - Architecture OpenClaw (SOUL.md, AGENTS.md, TOOLS.md, MEMORY.md) - Philosophie du langage : ambiguïté inhérente, contexte social - Documentation MCP (Model Context Protocol)

Podcast : Disponible sur https://podcasts.planckaert.me/ambiguite-xi-ci.mp3

Le Problème de l'Ambiguïté : La Plus Grande Distance N'est Pas Ce Que Tu Penses