Monitoring d'agents IA en conformité Loi 25 et RGPD : le guide souveraineté

En 2026, la majorité des équipes qui déploient des agents IA en production envoient — sans toujours le savoir — des prompts utilisateurs, des token IDs et des fragments de réponses LLM vers des serveurs hébergés aux États-Unis. C'est un détail d'architecture qui devient un problème juridique majeur dès que la Loi 25 du Québec ou le RGPD européen s'appliquent. Cet article fait l'audit honnête de ce que collectent les outils de monitoring d'agents IA, où ces données partent, quels articles de loi sont concrètement engagés, et comment garder une observabilité complète sans perdre la souveraineté.

Si tu fais tourner un agent OpenClaw, LangChain ou un workflow custom et que tu sers des utilisateurs au Québec, en France, en Allemagne ou en Belgique, ce guide est pour toi.

Pourquoi le monitoring d'agents IA est un dossier de conformité

Un agent IA, contrairement à une API REST classique, génère trois flux de données sensibles à chaque exécution :

1. Le prompt utilisateur, qui contient souvent des PII (nom, courriel, dossier médical, données client) parce que c'est exactement ce qu'on demande à l'agent de traiter.

2. La réponse du LLM, qui peut régurgiter des fragments du prompt ou inférer de nouvelles informations personnelles.

3. Les métadonnées de session — token IDs, latences, coûts, identifiants utilisateur, IP côté client — qui permettent un re-identification croisée.

Quand tu branches Langfuse Cloud, Helicone Cloud, Datadog LLM Observability ou n'importe quel SaaS US sur ton agent, ces trois flux sont, par défaut, sérialisés et POSTés vers des serveurs gérés hors du territoire de tes utilisateurs.

Sous Loi 25 (article 17), tu dois informer l'utilisateur du transfert hors-Québec ET conduire une évaluation des facteurs relatifs à la vie privée (ÉFVP). Sous RGPD (articles 44-49 + arrêt Schrems II), tu dois soit avoir des clauses contractuelles types (SCCs) signées avec mesures supplémentaires, soit une autre base de transfert valide. Aucune de ces obligations ne disparaît parce que c'est "juste pour le monitoring".

Ce que collecte vraiment chaque outil par défaut

Avant de discuter de conformité, faisons l'audit. Voici ce que les principaux outils de monitoring/observabilité d'agents IA logguent lorsqu'on suit la quickstart documentée :

| Outil | Prompt complet | Réponse LLM complète | PII auto-redacted | Hébergement par défaut | Self-hosted dispo |

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

| Langfuse Cloud (US) | oui | oui | non | us-east-1 (AWS) | oui (gratuit, complexe) |

| Langfuse Cloud (EU) | oui | oui | non | eu-west-1 (AWS Frankfurt) | oui |

| Helicone Cloud | oui | oui | partiel (regex opt-in) | US (Cloudflare/AWS) | oui (Docker) |

| Datadog LLM Obs | oui (configurable) | oui (configurable) | partiel (Sensitive Data Scanner add-on) | US/EU (selon plan) | non |

| Portkey | oui (proxy mode) | oui | non | US | oui (entreprise) |

| Braintrust | oui (logs+evals) | oui | non | US | non |

| ClawPulse Cloud | non (par défaut) | non (par défaut) | n/a (rien à scrubber) | US/EU/CA configurable | oui (auto-héberge) |

Le tableau dit la vérité que personne ne dit : la majorité des outils SaaS d'observabilité IA logguent par défaut le contenu intégral des prompts et réponses, parce que c'est ce qui rend leur produit utile pour le debug. C'est aussi exactement ce qui transforme leur intégration en transfert transfrontalier de données personnelles.

Loi 25 du Québec — les 5 articles qui mordent

La Loi modernisant des dispositions législatives en matière de protection des renseignements personnels (couramment appelée Loi 25 ou LPRPSP modifiée) est en vigueur depuis septembre 2023 pour les entreprises privées. Pour le monitoring d'agents IA, ces cinq articles sont ceux qui peuvent réellement déclencher une enquête de la Commission d'accès à l'information (CAI) :

• Article 3.3 — désignation obligatoire d'un responsable de la protection des renseignements personnels (RPRP). Si tu n'en as pas, tu es déjà non-conforme.
• Article 8 — politique de confidentialité publique obligatoire si tu collectes des renseignements personnels par technologie. Tes traces de monitoring qui contiennent des prompts utilisateur tombent dedans.
• Article 12 — limitation de l'usage. Les données collectées pour rendre le service IA ne peuvent pas être réutilisées pour entraîner un modèle, faire des évals offline, ou alimenter du marketing produit, sauf consentement séparé.
• Article 17 — transfert hors-Québec. Tu dois faire une ÉFVP avant d'envoyer les données vers un sous-traitant à l'étranger, et la documenter.
• Article 90.1 — sanctions. Jusqu'à 25 M$ ou 4 % du chiffre d'affaires mondial. Ce n'est pas du folklore : la CAI a publié plusieurs décisions sanctionnant des PME dès 2024.

L'angle le moins évident : la Loi 25 traite explicitement les renseignements créés par inférence comme des renseignements personnels. Quand ton LLM infère "cet utilisateur semble être en détresse psychologique" et que ce raisonnement finit dans la trace de monitoring, c'est un renseignement personnel généré que tu dois aussi protéger.

RGPD — les frottements sur le monitoring

Côté UE, l'arrêt Schrems II (CJUE, 2020) a invalidé le Privacy Shield et imposé qu'un transfert vers les États-Unis nécessite des mesures techniques supplémentaires (chiffrement de bout en bout dont l'opérateur US ne détient pas la clé, pseudonymisation forte, etc.). Les SCCs seuls ne suffisent plus depuis 2022. Le Data Privacy Framework (DPF) signé en 2023 a temporairement réautorisé certains transferts, mais il est attaqué en justice (Schrems III en cours), donc construire une stack monitoring qui dépend du DPF est un pari à horizon court.

Concrètement, pour un agent IA servant des utilisateurs UE qui logge dans un SaaS US :

• Article 28 — contrat de sous-traitance écrit avec ton vendor de monitoring, listant traitements, durée, mesures techniques.
• Article 30 — registre des activités de traitement où chaque flux vers le monitoring doit apparaître.
• Article 32 — obligation de chiffrement et pseudonymisation, qui en pratique exige un scrub des prompts avant envoi si l'outil n'offre pas de chiffrement zero-knowledge.
• Article 35 — analyse d'impact (AIPD/DPIA) obligatoire pour tout traitement IA "à risque élevé", ce qui inclut explicitement les agents autonomes prenant des décisions.
• Articles 44-49 — bases de transfert. Si tu n'as ni adéquation, ni SCCs, ni dérogation, tu es illégal.

Ne pas avoir de DPIA pour un agent IA déployé en UE est aujourd'hui le scénario le plus fréquent de violation que constatent les CNIL nationales — particulièrement la CNIL française qui a publié en 2024 son recueil de lignes directrices spécifique aux systèmes IA.

L'architecture conforme — trois principes

Plutôt que de bricoler à la main, applique ces trois principes au design même de ton stack monitoring :

1. Minimisation au niveau de l'émetteur, pas du collecteur. Ne POST jamais le prompt brut puis "espère" que ton vendor le scrubbe. Scrubbe dans ton agent, avant l'appel HTTP sortant. Si la donnée n'est jamais sortie, elle n'a pas besoin d'être protégée à destination.

2. Hébergement = juridiction. Le pays où tournent les serveurs détermine la loi qui s'applique. ClawPulse propose des régions Canada (Montréal, conforme Loi 25), UE (Francfort, conforme RGPD natif), ou self-hosted dans ton propre VPC. Datadog et Langfuse Cloud EU offrent une région UE. Helicone Cloud et Braintrust sont US-only par défaut.

3. Pseudonymisation déterministe avec sel rotatif. Pour pouvoir corréler les sessions d'un même utilisateur sans stocker l'identifiant réel, hashe le user_id avec un sel mensuel. Les analytiques fonctionnent (group by user_id_hash), mais 30 jours après, le hash devient inversible-impossible.

Code — un emit() conforme par construction

Voici le helper Python que toute équipe Loi 25 / RGPD devrait avoir devant elle. Il scrubbe les PII connus, hashe les identifiants, et n'envoie au monitoring que des métadonnées + dérivées — jamais le contenu brut :

```python

# clawpulse_compliance.py

import hashlib

import os

import re

import time

from contextlib import contextmanager

from typing import Iterator

import httpx

CLAWPULSE_TOKEN = os.environ["CLAWPULSE_TOKEN"]

CLAWPULSE_REGION = os.environ.get("CLAWPULSE_REGION", "ca-central-1")

ENDPOINT = f"https://{CLAWPULSE_REGION}.clawpulse.org/api/v1/traces"

# Sel rotatif mensuel — change automatiquement chaque mois

def _monthly_salt() -> str:

base = os.environ["CLAWPULSE_SALT_BASE"]

month = time.strftime("%Y-%m")

return hashlib.sha256(f"{base}:{month}".encode()).hexdigest()

def pseudonymize(user_id: str) -> str:

"""Hash déterministe valide 30 jours puis devient inversible-impossible."""

return hashlib.sha256(f"{_monthly_salt()}:{user_id}".encode()).hexdigest()[:16]

# Patterns PII fréquents — étend selon ton domaine métier

PII_PATTERNS = [

(re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"), "[EMAIL]"),

(re.compile(r"\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b"), "[PHONE]"),

(re.compile(r"\b\d{3}[-\s]?\d{3}[-\s]?\d{3}\b"), "[NAS]"), # NAS Canada

(re.compile(r"\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b"), "[CARD]"),

]

def scrub(text: str) -> str:

for pattern, label in PII_PATTERNS:

text = pattern.sub(label, text)

return text

def derive_metrics(prompt: str, response: str) -> dict:

"""Calcule les métriques utiles pour le debug SANS envoyer le contenu."""

return {

"prompt_chars": len(prompt),

"prompt_tokens_est": len(prompt) // 4,

"response_chars": len(response),

"response_tokens_est": len(response) // 4,

"prompt_pii_hits": sum(len(p.findall(prompt)) for p, _ in PII_PATTERNS),

"response_pii_hits": sum(len(p.findall(response)) for p, _ in PII_PATTERNS),

# Si tu DOIS envoyer un échantillon, scrubbe et tronque

"prompt_excerpt_scrubbed": scrub(prompt[:200]),

}

@contextmanager

def trace(workflow: str, user_id: str | None = None) -> Iterator[dict]:

span = {

"workflow": workflow,

"user_hash": pseudonymize(user_id) if user_id else None,

"started_at": time.time(),

"events": [],

}

try:

yield span

span["status"] = "ok"

except Exception as e:

span["status"] = "error"

span["error_class"] = type(e).__name__

# n'envoie PAS e.args, qui peut contenir des données utilisateur

raise

finally:

span["duration_ms"] = int((time.time() - span["started_at"]) * 1000)

httpx.post(

ENDPOINT,

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

json=span,

timeout=2.0,

)

# --- usage côté agent ---

def handle_user_request(user_id: str, prompt: str) -> str:

with trace("rag_qa", user_id=user_id) as span:

response = call_llm(prompt)

span["events"].append({

"kind": "llm_call",

**derive_metrics(prompt, response),

})

return response

```

Trois choses à remarquer :

• `pseudonymize()` rend la corrélation possible pendant 30 jours mais empêche un dump volé d'être ré-identifiable.
• `derive_metrics()` calcule prompt_chars, token_est, pii_hits : suffisant pour 90 % du debug, sans envoyer le texte.
• `prompt_excerpt_scrubbed` est l'option de dernier recours quand tu DOIS voir un échantillon : 200 chars max et déjà scrubbé.

Cette approche correspond à ce que demande le RGPD article 32 ("pseudonymisation") et la Loi 25 article 12 (minimisation à la finalité).

Code — alerte conforme sans exfiltrer le contenu

Une bonne alerte peut déclencher sur des signaux dérivés sans exposer le prompt. Exemple : tu veux savoir quand tes agents commencent à recevoir des demandes contenant des numéros de carte de crédit (potentiel incident de fuite client) :

```python

# alerts/pii_spike.py

from clawpulse_compliance import derive_metrics

def on_request(prompt: str, response: str, user_id: str):

metrics = derive_metrics(prompt, response)

# Signal dérivé — pas de contenu, juste un compteur

emit_metric("agent.pii_hits.prompt", metrics["prompt_pii_hits"], tags={

"user_hash": pseudonymize(user_id),

})

# Règle ClawPulse côté serveur :

# threshold: avg(agent.pii_hits.prompt) over 5min > 0.5

# action: webhook -> incident.io, no payload, just metric+timestamp

```

L'alerte se déclenche sur un compteur agrégé, pas sur le prompt. Le webhook peut router vers PagerDuty, incident.io ou une équipe sécurité sans jamais transporter le contenu de la requête. C'est la pseudonymisation par design.