Francais·3/28/2026·surveillance agents IA OpenClaw

Surveillance des agents IA OpenClaw : Suivez leurs mouvements avec ClawPulse

La surveillance des agents IA OpenClaw est essentielle pour garantir leur bon fonctionnement et leur sécurité. Découvrez comment ClawPulse peut vous aider à suivre leurs mouvements en temps réel.

L'importance de la surveillance des agents IA OpenClaw

Les agents IA OpenClaw sont des outils puissants qui peuvent grandement améliorer l'efficacité de vos processus. Cependant, leur utilisation doit être encadrée et supervisée attentivement. En effet, ces agents autonomes peuvent parfois se comporter de manière inattendue, voire potentiellement dangereuse, s'ils ne sont pas correctement contrôlés.

La surveillance de ces agents IA est donc primordiale pour s'assurer de leur bon fonctionnement et de la sécurité de votre environnement de travail. Elle permet de détecter tout comportement anormal, de résoudre rapidement les problèmes éventuels et de garantir la fiabilité de vos processus automatisés.

Comment ClawPulse facilite la surveillance des agents IA OpenClaw

ClawPulse est une plateforme de monitoring conçue spécifiquement pour faciliter la surveillance des agents IA OpenClaw. Grâce à ses fonctionnalités avancées, vous pouvez suivre en temps réel les activités de vos agents et réagir rapidement en cas de problème.

Surveillance en temps réel

ClawPulse vous permet de visualiser les mouvements de vos agents IA OpenClaw en temps réel, grâce à un tableau de bord intuitif. Vous pouvez ainsi suivre leurs actions, leurs déplacements et leur statut opérationnel à tout moment.

Alertes intelligentes

Le système d'alertes de ClawPulse vous permet d'être immédiatement informé en cas de comportement suspect ou de dysfonctionnement d'un agent IA. Vous pouvez définir des seuils personnalisés et recevoir des notifications par e-mail, SMS ou dans votre application mobile.

Analyses approfondies

ClawPulse vous fournit des analyses détaillées sur les performances et le comportement de vos agents IA OpenClaw. Vous pouvez ainsi identifier les tendances, les problèmes récurrents et optimiser leur utilisation pour gagner en efficacité.

Historique et traçabilité

Grâce à l'enregistrement des activités de vos agents IA, ClawPulse vous permet de consulter un historique complet de leurs actions. Cela facilite grandement les investigations en cas d'incident et la mise en place de procédures de contrôle.

Sécuriser vos processus automatisés avec ClawPulse

La surveillance des agents IA OpenClaw est essentielle pour garantir la sécurité de vos processus automatisés. ClawPulse vous offre les outils nécessaires pour suivre en détail leurs activités et réagir rapidement en cas de problème.

Que vous soyez une petite entreprise ou une grande organisation, ClawPulse s'adapte à vos besoins et vous permet de tirer le meilleur parti de vos agents IA OpenClaw tout en assurant leur sécurité.

Optimiser la conformité et la traçabilité de vos agents IA

Au-delà du monitoring opérationnel, la surveillance des agents IA OpenClaw répond à des enjeux réglementaires et de conformité de plus en plus stricts. Les organisations doivent désormais documenter chaque action automatisée pour respecter les normes de gouvernance des données et de responsabilité algorithmique.

ClawPulse génère automatiquement des rapports d'audit complets qui enregistrent toutes les opérations effectuées par vos agents IA. Cette traçabilité complète vous permet de démontrer la conformité lors d'audits internes ou externes, tout en facilitant l'identification des responsabilités en cas d'incident.

La fonctionnalité de journalisation détaillée capture les paramètres d'exécution, les décisions prises et les résultats obtenus. Cela s'avère particulièrement utile pour les secteurs réglementés comme la finance, la santé ou les services. En disposant d'une source de vérité centralisée sur le comportement de vos agents, vous renforcez la confiance envers vos processus automatisés et facilitez la gouvernance de l'IA au sein de votre organisation.

Inscrivez-vous dès maintenant sur ClawPulse pour commencer à surveiller vos agents IA OpenClaw et sécuriser vos processus !

Les 5 signaux de surveillance que vous ne pouvez pas vous permettre d'ignorer

La théorie de la "surveillance d'agents IA" se concrétise par cinq signaux mesurables. Si l'un de ces cinq sort de sa plage normale, votre agent OpenClaw est en train de dériver — silencieusement.

|--------|-------------|--------------------|----------------|

ClawPulse instrumente ces cinq signaux nativement dès la première connexion d'un agent (voir l'agent.sh). Aucun outil concurrent — qu'il s'agisse de Datadog, Helicone ou Langfuse — ne couvre les cinq d'un seul coup pour des agents OpenClaw.

Détecter un agent qui dérive : exemple concret

Voici un agent OpenClaw bien instrumenté avec ClawPulse, qui détecte qu'il commence à boucler sur lui-même :

```python

# extrait simplifié d'un agent OpenClaw multi-tour

import os, time, requests

CLAWPULSE_TOKEN = os.environ["CLAWPULSE_TOKEN"]

def cp_event(name, payload):

requests.post(

"https://www.clawpulse.org/api/dashboard/telemetry",

json={"type": "event", "name": name, "payload": payload},

headers={"Authorization": f"Bearer {CLAWPULSE_TOKEN}"},

timeout=2

)

def run_agent_loop(task, max_steps=15):

history = []

for step in range(max_steps):

action = decide_next_action(task, history)

# détection "boucle" : 3 fois la même action en 5 tours

recent = [h["action"] for h in history[-5:]]

if recent.count(action) >= 3:

cp_event("agent.loop_detected", {

"task": task[:80], "action": action, "step": step

})

return {"status": "aborted", "reason": "loop_detected"}

result = execute(action)

history.append({"action": action, "result": result})

return {"status": "ok", "steps": len(history)}

```

L'événement `agent.loop_detected` apparaît dans le tableau de bord /dashboard/alerts et déclenche une alerte Slack en moins de 5 secondes. Cette mécanique simple — instrumentation + règle d'alerte — a permis à plusieurs équipes de couper court à des agents qui auraient sinon brûlé des centaines de dollars d'API en quelques heures.

Pour des patterns plus avancés (boucles multi-agents, échecs cascadés), voir notre guide d'orchestration multi-agents.

Surveillance et conformité RGPD : ce qu'il faut prévoir

Surveiller un agent IA en production en Europe implique de gérer correctement les données personnelles qui transitent dans les prompts. Trois règles de base :

1. Hasher les identifiants utilisateur avant de les pousser dans les logs (pas de PII en clair). ClawPulse accepte un champ `user_hash` qui remplace l'`user_id` brut.

2. Échantillonner les prompts plutôt que tout logger. Un échantillon de 5 % suffit pour le débogage et réduit drastiquement la surface RGPD. Voir le paramètre `sample_rate` dans la doc agent.

3. Définir une durée de rétention : 14 jours (Starter), 90 jours (Growth), 1 an (Agency). Au-delà, les snapshots sont purgés.

Pour les organisations qui ne peuvent pas envoyer leurs données sur un cloud SaaS, l'option self-hosted du plan Agency permet un déploiement Docker on-prem avec les mêmes fonctionnalités de surveillance.

Comparer ClawPulse à une solution maison

Beaucoup d'équipes commencent par bricoler une solution maison à base de Prometheus + Grafana + Loki. Voici la dette qu'elles découvrent au bout de quelques mois :

| Aspect | Stack maison | ClawPulse |

|--------|--------------|-----------|

| Setup initial | 1–2 semaines | 2 minutes (`curl agent.sh`) |

| Dashboards LLM-spécifiques | À construire | Pré-configurés |

| Heartbeat agent natif | À écrire | Built-in |

| Calcul coût/modèle | Tables manuelles | Automatique |

| Alertes Slack/PagerDuty | Templates manuels | 1 clic |

| Coût total mensuel | $200+ (compute + ops + temps) | $29 (Starter) |

| Mise à jour des prix LLM | Manuelle | Automatique |

La stack maison reste pertinente pour des cas très spécifiques (volumes massifs, exigences réglementaires extrêmes). Pour 95 % des équipes, ClawPulse fait gagner plusieurs semaines d'ingénierie. C'est exactement le pari que Helicone ou Langfuse ont fait sur le créneau LLM-only ; ClawPulse étend cette logique à l'écosystème OpenClaw + agents autonomes.

FAQ — surveillance des agents IA OpenClaw

Quelle est la fréquence de heartbeat optimale pour un agent OpenClaw ?

15 secondes par défaut. C'est le compromis entre détection rapide (un agent down est repéré en moins de 60 s) et coût réseau négligeable (4 requêtes/min/agent).

Que se passe-t-il si l'agent perd la connexion à ClawPulse ?

L'agent bufferise jusqu'à 1000 événements localement dans `/opt/clawpulse/state/queue.jsonl` et les rejoue à la reconnexion. Aucune perte de signal sur des coupures < 4 h.

Peut-on surveiller des agents IA non-OpenClaw (LangChain, AutoGen, CrewAI) ?

Oui. Toute application qui peut appeler un endpoint HTTP peut pousser ses signaux dans ClawPulse. Voir le guide LangChain.

Comment détecter une fuite de prompt confidentiel ?

Activez la règle d'alerte "prompt contient PII" dans /dashboard/alerts. ClawPulse scan les prompts (sur l'échantillon configuré) avec un détecteur regex + ML léger. Voir notre article sur la sécurité des agents IA.

Quelle est la latence ajoutée par l'instrumentation ClawPulse ?

Moins de 5 ms en moyenne. Les événements sont poussés en mode fire-and-forget (timeout 2 s, non-bloquant pour l'agent).

Start monitoring your OpenClaw agents in 2 minutes

Free 14-day trial. No credit card. Just drop in one curl command.

Prefer a walkthrough? Book a 15-min demo.

Mettre en place la surveillance en 2 minutes

```bash

curl -sS https://www.clawpulse.org/agent.sh | sudo bash -s

```

Cette unique commande installe l'agent comme service systemd et démarre le push de signaux vers votre tableau de bord. Récupérez votre token dans /dashboard/instances, ou voyez la démo en direct pour comprendre l'expérience avant inscription.

Lectures complémentaires : Tableau de bord OpenClaw · Métriques temps réel pour vos agents · Sécurité des agents IA · Tarifs ClawPulse

Matrice de surveillance par profil d'agent OpenClaw (mai 2026)

Tous les agents OpenClaw ne demandent pas la même surveillance. Voici les cinq profils que nous voyons en production chez les équipes québécoises et la rigueur d'instrumentation associée.

|---|---:|---:|---:|---|---|---|

| Chatbot interne | 1k–10k | < 1.8 s | $5–$25 | TTFT (latence ressentie) | cache_read sur system prompt | TTFT z-score > 3 sur 15 min |

| RAG (questions docs) | 5k–80k | < 3.0 s | $40–$220 | input_tokens (taille corpus injecté) | dédup chunks + cache_read | input_tokens z-score > 3.5 (boucle d'embed) |

Le mode opératoire ClawPulse : on instrumente la même primitive (un wrapper d'appel LLM + heartbeat agent), puis on déclare la règle de surveillance correspondante au profil dans `/dashboard/alerts`. Pas de configuration différente par agent. Voir le guide complet du monitoring des agents IA pour la décomposition fine.

Wrapper d'instrumentation OpenClaw — 90 lignes Python (cache-aware)

L'instrumentation est volontairement minimale. Elle expose quatre dimensions de billing (input billable, output, cache_read, cache_write), un `prompt_hash` SHA-256 16-car pour la détection des retry storms, et un push fire-and-forget qui n'ajoute jamais plus de 5 ms à votre agent.

```python

# clawpulse_instrumentation.py — vendor-neutral OTel GenAI semconv

import hashlib, json, os, threading, time, urllib.request

from contextlib import contextmanager

from anthropic import Anthropic

CLAW_URL = "https://www.clawpulse.org/api/dashboard/telemetry"

CLAW_TOKEN = os.environ["CLAWPULSE_TOKEN"]

CLAW_TENANT = os.environ.get("CLAWPULSE_TENANT", "default")

# Tarifs Anthropic mai 2026 (USD / 1M tokens) — Sonnet 4.6

PRICE = {"in": 3.0, "out": 15.0, "cache_read": 0.30, "cache_write": 3.75}

def _hash(prompt: str) -> str:

return hashlib.sha256(prompt.encode()).hexdigest()[:16]

def _fire(payload: dict):

def _send():

try:

req = urllib.request.Request(

CLAW_URL, data=json.dumps(payload).encode(),

headers={"Authorization": f"Bearer {CLAW_TOKEN}",

"Content-Type": "application/json"})

urllib.request.urlopen(req, timeout=0.25) # non-bloquant 250 ms

except Exception:

pass # ne JAMAIS faire échouer l'agent à cause du monitoring

threading.Thread(target=_send, daemon=True).start()

@contextmanager

def claw_call(route: str, user_id: str = "anon", session_id: str | None = None):

started = time.time()

rec = {"route": route, "tenant": CLAW_TENANT, "user_id": user_id,

"session_id": session_id or "", "started_at": started}

try:

yield rec

finally:

rec["duration_ms"] = int((time.time() - started) * 1000)

rec["prompt_hash"] = _hash(rec.get("prompt", ""))

u = rec.get("usage", {})

cache_r = u.get("cache_read_input_tokens", 0)

cache_w = u.get("cache_creation_input_tokens", 0)

billable_in = max(0, u.get("input_tokens", 0) - cache_r - cache_w)

rec["billable_input_tokens"] = billable_in

rec["cache_read_tokens"] = cache_r

rec["cache_write_tokens"] = cache_w

rec["output_tokens"] = u.get("output_tokens", 0)

rec["cost_usd"] = round(

(billable_in PRICE["in"] + rec["output_tokens"] PRICE["out"]

+ cache_r PRICE["cache_read"] + cache_w PRICE["cache_write"]) / 1e6, 6)

_fire(rec)

# Utilisation

client = Anthropic()

with claw_call("legal.precedent_search", user_id="u_4127", session_id="s_a13") as ctx:

ctx["prompt"] = "Trouve les jugements pertinents pour ce dossier..."

msg = client.messages.create(

model="claude-sonnet-4-6",

max_tokens=1024,

messages=[{"role": "user", "content": ctx["prompt"]}],

extra_headers={"anthropic-beta": "prompt-caching-2024-07-31"})

ctx["usage"] = msg.usage.model_dump()

ctx["text"] = msg.content[0].text

```

Trois propriétés non négociables :

1. Soustraire `cache_read_input_tokens` du `input_tokens` sinon vous facturez le client trois fois pour des tokens déjà mis en cache (Anthropic facture le cache_read à 0.30 $/1M, pas 3 $/1M).

2. `prompt_hash` SHA-256 16-car sans le contenu en clair : on peut détecter les retry storms sans stocker les prompts (Loi 25 art.18 — minimisation).

3. `timeout=0.25` sur l'envoi télémétrie : on ajoute au pire 250 ms en cas de panne réseau côté ClawPulse, jamais une erreur à l'agent.

Voir aussi notre wrapper équivalent en TypeScript et la sémantique OTel GenAI officielle.

Postmortem : 9 400 $ CAD de tokens fantômes en 6 jours (cabinet juridique de Toronto)

Un cabinet juridique de Toronto utilisait OpenClaw + Claude Sonnet 4.6 pour un agent RAG de recherche jurisprudentielle. Le 14 avril 2026, après un déploiement banal, la facture quotidienne a quintuplé silencieusement.

| Jour | Coût | Ce qui se passait |

|---|---:|---|

| J0 | 312 $ | baseline 7 jours stable |

| J1 | 1 484 $ | un bug front : `Date.now()` injecté dans le prefix de cache → cache_read tombé à 0 |

| J3 | 1 492 $ | dashboard fournisseur ne montre rien ; aucune alerte côté Anthropic |

| J6 | 1 487 $ | détection manuelle par audit comptable. Total : 9 414 $ CAD |

Avec ClawPulse en place, le z-score sur `cache_read_ratio` aurait signalé l'effondrement (de 0.78 → 0.03) en 18 minutes — un coût d'exposition de 312 $ × (18/1440) ≈ 4 $. ROI : 2 350× sur un abonnement Growth à 49 $/mois.

Détail technique : la règle d'alerte écrite dans `/dashboard/alerts` était :

```

WHEN cache_read_ratio_5min < (cache_read_ratio_baseline_24h * 0.5)

AND total_cost_5min > 5

THEN page on-call

```

Pourquoi le dashboard Anthropic n'a rien vu : il agrège par jour avec un retard de 4 à 7 jours, ce qui rend impossible la détection en moins d'une journée.

Quatre recettes SQL pour la surveillance proactive

Toutes ces requêtes tournent sur la table `TaskEntry` (1 ligne par appel LLM, alimentée par le wrapper ci-dessus). Voir la structure du dashboard ClawPulse.

1. Z-score input_tokens par route, sur fenêtre 1 h vs baseline 24 h (détection de boucle d'embed) :

```sql

WITH baseline AS (

SELECT route, AVG(billable_input_tokens) AS mu, STDDEV(billable_input_tokens) AS sigma

FROM TaskEntry

WHERE started_at >= NOW() - INTERVAL 24 HOUR AND started_at < NOW() - INTERVAL 1 HOUR

GROUP BY route HAVING COUNT(*) >= 50

last_hour AS (

SELECT route, AVG(billable_input_tokens) AS recent

FROM TaskEntry WHERE started_at >= NOW() - INTERVAL 1 HOUR GROUP BY route

)

SELECT b.route, b.mu, b.sigma, l.recent,

ROUND((l.recent - b.mu) / NULLIF(b.sigma, 0), 2) AS z_score

FROM baseline b JOIN last_hour l ON b.route = l.route

WHERE b.sigma > 0 AND (l.recent - b.mu) / b.sigma > 3.5

ORDER BY z_score DESC;

```

2. Retry storm par `prompt_hash` (>50 appels même hash en 5 min = boucle non bornée) :

```sql

SELECT prompt_hash, route, COUNT(*) AS calls, SUM(cost_usd) AS burnt_usd

FROM TaskEntry

WHERE started_at >= NOW() - INTERVAL 5 MINUTE

GROUP BY prompt_hash, route HAVING calls > 50

ORDER BY calls DESC;

```

3. Dégradation `cache_hit_ratio` par route (signal de prefix cassé) :

```sql

SELECT route,

ROUND(SUM(cache_read_tokens) / NULLIF(SUM(cache_read_tokens + billable_input_tokens), 0), 3) AS cache_ratio,

SUM(cost_usd) AS cost_usd

FROM TaskEntry

WHERE started_at >= NOW() - INTERVAL 1 HOUR

GROUP BY route HAVING cache_ratio < 0.30 AND cost_usd > 5

ORDER BY cost_usd DESC;

```

4. Équité multi-tenant (un client mange-t-il > 5× la moyenne ?) :

```sql

WITH t AS (

SELECT tenant, SUM(cost_usd) AS spend, COUNT(*) AS calls

FROM TaskEntry WHERE started_at >= NOW() - INTERVAL 1 HOUR GROUP BY tenant

)

SELECT tenant, spend, calls,

ROUND(spend / (SELECT AVG(spend) FROM t), 2) AS spend_ratio_to_mean

FROM t WHERE spend > (SELECT AVG(spend) * 5 FROM t)

ORDER BY spend DESC;

```

Comparaison honnête de 7 outils pour la surveillance OpenClaw

|---|:-:|:-:|:-:|:-:|:-:|:-:|:-:|

| ClawPulse | ✅ | ✅ | ✅ | ✅ par tenant | ✅ Toronto (Aiven) | < 5 min | ✅ |

| Helicone | ✅ | ❌ | partiel | ❌ | US | < 10 min | ✅ |

| Braintrust | partiel | ❌ | ❌ | partiel | US | 1 h+ | ✅ trial |

| LangSmith | ❌ (input brut) | ❌ | ❌ | ✅ | US | < 15 min | ✅ |

| Datadog LLM Obs | ❌ | partiel APM | ❌ | ✅ | multi | 1 h+ | ❌ |

| Arize Phoenix (self-host) | partiel | ❌ | ❌ | ✅ | self-host | 2 h+ | ✅ open-source |

Voir la comparaison ClawPulse vs Langfuse et la liste des meilleures alternatives à Helicone pour les détails fonctionnels.

Conformité Loi 25 (Québec) et RGPD pour la surveillance d'agents IA

ClawPulse est conçu pour les organisations qui doivent répondre à la Loi 25 (Québec, art. 17 — minimisation, art. 18 — pseudonymisation, art. 28.1 — droit à l'effacement) et au RGPD (art. 28 — sous-traitant, art. 32 — sécurité du traitement, art. 17 — droit à l'oubli).

Hébergement : base de données chez Aiven Toronto (région `ca-central-1`). Aucun donnée ne quitte le Canada par défaut. Voir notre politique d'hébergement self-hosted pour les déploiements 100 % on-premise.
Pseudonymisation : `prompt_hash` SHA-256 16-car au lieu du prompt en clair (option par route). Le contenu en clair n'est conservé que sur les routes explicitement marquées `redact=false`.
Droit à l'effacement : endpoint `DELETE /api/dashboard/erase` qui supprime toutes les `TaskEntry` d'un `user_id` donné en moins de 60 secondes (réponse synchrone). Conforme à l'art. 28.1 Loi 25.
Allowlist PII pour les arguments d'outils : par défaut, les arguments des appels MCP/tool sont redactés. Vous activez champ par champ dans `/dashboard/settings/redaction`.
Sous-traitant : nous sommes sous-traitant au sens du RGPD art. 28. Le DPA est disponible sur demande à /contact.

Liste de contrôle avant la mise en production

À cocher avant de pousser un agent OpenClaw en prod surveillé par ClawPulse :

1. [ ] Le wrapper instrumente les quatre dimensions (`billable_input`, `output`, `cache_read`, `cache_write`).

2. [ ] Le `prompt_hash` SHA-256 16-car est calculé côté client (pas de prompt brut envoyé).

3. [ ] Le push télémétrie a `timeout=0.25 s` et est en `daemon` thread (jamais bloquant).

4. [ ] Une règle d'alerte sur z-score input_tokens > 3.5 par route est active.

5. [ ] Une règle sur cache_read_ratio < 30 % est active sur les routes RAG.

6. [ ] Une règle sur MTD > 90 % budget par tenant est active (`CustomerBudget` 4-tier).

7. [ ] Un canary synthétique tourne toutes les 60 s sur chaque agent critique.

8. [ ] Le runbook de réponse aux alertes est lié dans la description de la règle.

9. [ ] L'option `redact=true` est activée sur toutes les routes traitant des données nominatives.

10. [ ] Le DPA Loi 25 / RGPD est signé (si organisation québécoise/européenne).

Pour aller plus loin : comment gérer les alertes critiques et déployer un agent IA en production.

FAQ étendue — surveillance OpenClaw

Quelle est la différence entre une surveillance "métriques" et une surveillance "comportementale" pour un agent OpenClaw ?

Les métriques (CPU, RAM, p95 latence) vous disent que l'agent fonctionne. La surveillance comportementale — `cache_read_ratio`, `prompt_hash` répétés, dérive du `tools/list` — vous dit qu'il fait ce qu'il devrait. Pour un agent autonome, la deuxième est strictement plus utile : un agent peut consommer 5× son budget sans qu'aucune métrique système ne bouge.

Combien de temps de rétention pour la `TaskEntry` ?

30 jours par défaut sur le plan Growth, 90 jours sur Agency. Les données plus anciennes sont agrégées en moyennes horaires. Configurable dans `/dashboard/settings/retention`.

ClawPulse remplace-t-il Datadog ou New Relic pour mes agents OpenClaw ?

Non. Datadog/New Relic monitorent l'infrastructure (host, container, DB). ClawPulse monitore la couche d'agent IA : appels LLM, coût par tenant, retry storms, cache_read. Les deux cohabitent — vos métriques d'infra restent dans Datadog, vos métriques d'agent vivent dans ClawPulse.

Comment surveiller un agent qui n'utilise pas l'API Anthropic mais OpenAI ou Mistral ?

Le wrapper est vendor-neutral (sémantique OTel GenAI). Adaptez le mapping `usage` : `prompt_tokens_details.cached_tokens` côté OpenAI, `usage.prompt_tokens` simple côté Mistral (pas de cache disponible). Le reste du pipeline est identique. Voir le comparatif des coûts API LLM.

Combien d'agents puis-je surveiller sur le plan gratuit ?

1 agent + 1 instance, rétention 7 jours. Suffisant pour un POC ou un bot personnel. Au-dessus, le plan Starter (5 instances, 30 j) couvre un projet pilote ; voir les tarifs.

Que faire si mon agent tourne dans un environnement air-gapped (pas d'Internet sortant) ?

Mode self-hosted disponible : container Docker qui pousse vers une instance ClawPulse on-premise. Détails dans le guide self-hosted.

Le `prompt_hash` SHA-256 est-il rétro-utilisable pour reconstituer le prompt ?

Non. SHA-256 est une fonction à sens unique. Avec un `prompt_hash` 16-car (64 bits), un attaquant doit faire ~2^64 essais pour retrouver un prompt — coût astronomique. Suffisant pour la Loi 25 art.18 (pseudonymisation) tant que vous ne stockez pas une table de correspondance hash → prompt.

Comment instrumenter un agent OpenClaw qui parle à plusieurs MCP servers ?

Wrappez la couche `client.request` du transport MCP avec le même pattern que `claw_call`. Capturez `duration_ms`, `rpc_error_code`, `tool_hash`. Voir le guide MCP server monitoring.