Aller plus loin

Protection des agents IA

Sécuriser le code, le modèle et le runtime.

Du prompt au runtime, observez ce que vos agents font réellement, bloquez les actions dangereuses et gardez la trace de chaque incident.

Un agent IA ne se contente pas de produire une réponse. Il consulte des données, choisit des outils, appelle des API, utilise des serveurs MCP et peut exécuter des actions dans votre système d'information.

Ariovis vous aide à découvrir cette surface, protéger chaque couche et neutraliser les comportements dangereux avant qu'ils ne deviennent des incidents métier.

Une chaîne protégée de bout en bout

  1. Code
  2. Modèle
  3. Données
  4. Prompt
  5. Outil
  6. MCP
  7. API
  8. Workload
  9. Action
  10. Preuve

Un agent IA est une surface d'action

Le même composant joue simultanément plusieurs rôles dans votre système d'information. Chacun apporte sa propre surface de risque.

  • Application

    Du code, des dépendances, des images et une configuration qui se déploient comme n'importe quel service.

  • Identité machine

    Des secrets, des tokens et des droits qui existent en dehors de toute session humaine.

  • Modèle

    Un modèle, ses versions, ses artefacts et ses templates de prompts, avec leur provenance.

  • Client API

    Des appels sortants vers des endpoints internes et externes, parfois non déclarés.

  • Orchestrateur d'outils

    Des serveurs MCP et des outils dont les descriptions, les permissions et les appels sont inspectés avant exécution.

  • Consommateur de données

    Un retrieval, des index RAG et des documents dont le contenu devient instruction.

  • Mémoire

    Un état persistant qui conserve, propage et réutilise ce qu'il a rencontré.

  • Workload

    Des processus, des fichiers, des appels système et des flux réseau bien réels.

  • Acteur semi-autonome

    La capacité de lire, écrire, transmettre, modifier ou exécuter — donc de produire un effet.

Protéger uniquement les prompts laisse sans contrôle le code, les dépendances, les données, les outils, les API et l'effet réel de l'agent.

Voir, comprendre, empêcher, prouver

Quatre verbes structurent l'offre. Ils se déploient dans cet ordre : la découverte précède la compréhension, la compréhension conditionne le blocage, et la preuve rend l'ensemble vérifiable.

01

Voir

Découvrir la surface réelle, y compris ce qui n'a jamais été déclaré.

  • Découvrir les agents autorisés et non autorisés
  • Détecter le Shadow AI
  • Inventorier modèles, données, RAG, mémoires, outils, MCP, API et workloads
  • Identifier les propriétaires et les finalités
  • Construire la lineage
  • Représenter les dépendances et les chemins d'exposition

On ne protège pas ce que l'on ne connaît pas.

02

Comprendre

Relier chaque objet à son contexte métier pour hiérarchiser ce qui compte.

  • Relier l'agent à son code, son modèle, ses outils, ses données et son environnement
  • Calculer le risque selon l'impact métier
  • Analyser l'exposition, les privilèges et les données sensibles
  • Identifier le blast radius
  • Distinguer une alerte isolée d'une chaîne d'attaque

Le risque ne dépend pas seulement de la vulnérabilité, mais de ce que l'agent peut réellement atteindre et exécuter.

03

Empêcher

Agir sur l'entrée, sur l'appel d'outil, sur le flux ou sur le workload.

  • Masquer, transformer ou bloquer une entrée ou une sortie
  • Empêcher un tool call dangereux
  • Limiter les outils, paramètres et destinations
  • Bloquer une API ou un flux réseau
  • Restreindre les fichiers et les processus
  • Isoler ou arrêter un workload
  • Demander une validation humaine avant une action sensible

Une protection utile agit avant l'effet, pas uniquement après l'incident.

04

Prouver

Reconstituer l'intention, le cheminement et l'effet, pour l'audit comme pour le SOC.

  • Conserver l'intention et le contexte
  • Retracer les prompts et les tool calls
  • Relier les données consultées et les effets produits
  • Documenter les blocages et les exceptions
  • Produire une chronologie d'incident
  • Exporter les preuves vers le SOC, l'audit ou la conformité

Chaque incident doit pouvoir être expliqué, corrigé et vérifié.

La surface d'attaque agentique

Autour d'un même agent se superposent sept surfaces distinctes. Un incident réel emprunte presque toujours plusieurs d'entre elles.

Agent IA

Chaque surface est traitée par des contrôles distincts, mais analysée dans un même graphe.

  • Prompts et réponses

    • Prompt injection
    • Jailbreak
    • Détournement d'objectif
    • Fuite de données
    • Sortie dangereuse
  • Outils et MCP

    • Tool poisoning
    • Description trompeuse
    • Paramètre détourné
    • Outil trop puissant
    • Chaîne d'actions excessive
    • Action irréversible
  • Données, RAG et mémoires

    • RAG poisoning
    • Mémoire contaminée
    • Fuite de secrets ou de données personnelles
    • Accès entre tenants
    • Conservation excessive
    • Exfiltration
  • Modèles et supply chain

    • Modèle altéré
    • Package malveillant
    • Dépendance vulnérable
    • Plugin non signé
    • Image compromise
    • Prompt template modifié
    • Dataset empoisonné
  • API

    • Shadow API
    • Endpoint orphelin
    • Schéma non respecté
    • Abus de volume ou de coût
    • Payload sensible
    • Destination inconnue
  • Runtime et cloud

    • Processus inattendu
    • Accès fichier
    • Reverse shell
    • Mouvement latéral
    • Élévation de privilège
    • Egress caché
    • Contournement de l'isolation
  • Gouvernance

    • Shadow AI
    • Absence de propriétaire
    • Dérive de version
    • Environnement non approuvé
    • Impossibilité d'expliquer l'action

Une protection du code au runtime

Les contrôles ne commencent pas en production : ils se posent dès la conception et se vérifient à chaque exécution.

  1. 01Design

    Cadrer l'intention

    • Finalité de l'agent
    • Threat model
    • Criticité métier
    • Autonomie maximale
    • Outils et données nécessaires
    • Scénarios nécessitant une validation humaine
  2. 02Build

    Sécuriser la fabrication

    • Analyse du code
    • Dépendances
    • SBOM ou nomenclature adaptée
    • Secrets
    • Infrastructure as code
    • Images
    • Templates de prompts
    • Configuration de l'agent
    • Manifests MCP
    • Provenance des modèles
    • Quality gates
  3. 03Deploy

    Enregistrer et encadrer

    • Inventaire et enregistrement
    • Propriétaire
    • Environnement
    • Baseline des outils
    • Attestation des composants
    • Analyse de l'exposition
    • Premières politiques en mode observation
  4. 04Run

    Observer et contenir

    • Prompts et réponses
    • Tool calls
    • MCP
    • API
    • Données et retrieval
    • Mémoire
    • Processus
    • Fichiers
    • Flux réseau
    • Coûts et volumes
    • Dérive comportementale
  5. 05Respond

    Corriger et vérifier

    • Corrélation
    • Révocation
    • Confinement
    • Isolation
    • Blocage réseau
    • Passage en lecture seule
    • Gel ou restauration de la mémoire
    • Ticket
    • Correction
    • Vérification runtime

La cognition devient une couche du runtime. Elle doit pouvoir être observée, limitée et arrêtée avec la même rigueur qu'un processus, un fichier ou un flux réseau.

Les capacités de l'offre

Quatre familles de capacités, mobilisées selon la maturité de vos cas d'usage et la criticité des actions concernées.

Découvrir et prioriser

  • Inventaire des agents et actifs IA
  • AI-SPM
  • Shadow AI
  • Owners et finalités
  • AI-BOM
  • Lineage
  • Graphe des actifs
  • Graphe d'exposition et d'attaque
  • Scoring contextualisé
Ce qu'elle voit
Les agents, modèles, index, outils, MCP, API et workloads réellement présents.
Ce qu'elle détecte
Les usages non déclarés, les composants sans propriétaire et les expositions inattendues.
Ce qu'elle empêche
La mise en production d'un agent inconnu ou hors périmètre approuvé.
Valeur produite
Une cartographie exploitable et une file de priorités fondée sur l'impact métier.

Sécuriser avant la production

  • Code et dépendances
  • Secrets
  • Images et conteneurs
  • IaC
  • Modèles et artefacts
  • Provenance
  • Prompts-as-code
  • Manifests MCP
  • Tests automatisés
  • Red team
  • Évaluations de régression
  • Quality gates CI/CD
Ce qu'elle voit
Ce qui compose réellement l'agent : code, artefacts, prompts, manifests, modèles.
Ce qu'elle détecte
Vulnérabilités, secrets exposés, composants non signés, régressions de comportement.
Ce qu'elle empêche
La livraison d'une version qui échoue aux tests de sécurité ou aux évaluations.
Valeur produite
Des défauts corrigés avant qu'ils n'atteignent un environnement où l'agent peut agir.

Protéger l'exécution

  • Prompt & Response Firewall
  • Tool & MCP Guard
  • Sécurité des API agentiques
  • Protection des données
  • Protection du RAG
  • Protection des mémoires
  • Sandbox runtime
  • Processus, fichiers, syscalls et réseau
  • Limitations de fréquence, de volume et de coût
  • Blocage, isolation ou révocation
Ce qu'elle voit
Chaque entrée, chaque tool call, chaque appel d'API et chaque comportement du workload.
Ce qu'elle détecte
Instructions injectées, paramètres détournés, retrieval anormal, activité runtime suspecte.
Ce qu'elle empêche
L'action dangereuse elle-même : appel bloqué, flux coupé, workload isolé, validation exigée.
Valeur produite
Un effet maîtrisé, sans dépendre uniquement de la vigilance du modèle.

Détecter, répondre et prouver

  • AI Detection & Response
  • Détection des prises de contrôle
  • Exfiltration
  • Contamination de mémoire
  • Altération de modèle
  • Propagation entre agents
  • Intégration SIEM et SOAR
  • Tickets et runbooks
  • Chronologies
  • Preuves continues
  • Conformité et audit
Ce qu'elle voit
La séquence complète, du contenu déclencheur jusqu'à l'effet produit.
Ce qu'elle détecte
Détournement d'agent, propagation, exfiltration lente, dérive de comportement.
Ce qu'elle empêche
La répétition : la cause est corrigée, puis la correction est vérifiée à l'exécution.
Valeur produite
Un incident explicable, une remédiation tracée et des preuves exploitables en audit.

Comprendre comment une action devient un incident métier

Une alerte isolée n'explique rien. Ce qui compte, c'est le chemin : d'où vient l'instruction, ce qu'elle a déclenché et ce qu'elle a atteint.

  • Pourquoi l'agent a-t-il pu agir ?
  • D'où venait l'instruction ?
  • Quelles données a-t-il consultées ou transmises ?
  • Quels outils, API et ressources pouvait-il atteindre ?
  • Comment corriger durablement la cause ?
  1. 01Contenu externe
  2. 02Contexte RAG
  3. 03Prompt
  4. 04Modèle
  5. 05Choix d'outil
  6. 06Appel MCP ou API
  7. 07Workload
  8. 08Donnée ou ressource
  9. 09Effet
  10. 10Incident
  11. 11Correction
  12. 12Vérification

Ce chemin est reconstitué à partir des signaux collectés à chaque couche, et non déduit d'un seul journal applicatif.

Trois cas d'usage phares

Trois situations fréquentes, traitées de la découverte jusqu'à la preuve.

01

Sécuriser MCP

  1. Découvrir les serveurs et outils
  2. Vérifier leur propriétaire, version et provenance
  3. Limiter les outils visibles par agent
  4. Contrôler les schémas et paramètres
  5. Contraindre les destinations et montants
  6. Simuler une action
  7. Imposer une validation humaine
  8. Observer le processus, le fichier et le réseau
  9. Filtrer le résultat
  10. Conserver la preuve

Le Prompt Firewall protège le langage. Le MCP Guard protège l'action. La protection runtime maîtrise l'effet réel.

02

Protéger un agent de code

  1. Limiter les dépôts accessibles
  2. Scanner le code et les dépendances
  3. Détecter les secrets
  4. Contrôler les packages
  5. Vérifier les images
  6. Isoler les tests
  7. Limiter l'accès réseau
  8. Empêcher l'accès à la production
  9. Imposer une revue avant fusion
  10. Vérifier chaque nouvelle version
03

Protéger un agent de service client

  1. Isoler les dossiers clients
  2. Contrôler le retrieval RAG
  3. Détecter les instructions cachées dans les documents
  4. Masquer les données sensibles
  5. Contrôler les API appelées
  6. Limiter les montants et actions
  7. Exiger une validation humaine
  8. Empêcher l'exfiltration
  9. Conserver le détail des données consultées et actions exécutées

Observer sans bloquer. Bloquer avant l'impact.

Le niveau de contrôle suit la criticité de l'action, pas une posture uniforme appliquée à tous les agents.

  1. Observer
  2. Recommander
  3. Simuler
  4. Alerter
  5. Bloquer de manière ciblée
  6. Automatiser
  • Le déploiement peut commencer par la découverte, sans toucher au comportement des agents.
  • Les comportements normaux observés permettent de construire une baseline.
  • Les politiques sont testées en simulation avant d'être appliquées.
  • Le mode de contrôle dépend de la criticité de l'action concernée.
  • Une action à faible risque peut seulement être journalisée.
  • Une action sensible ou irréversible peut être bloquée ou soumise à validation humaine.

Les projets IA continuent d'avancer pendant la mise en place des protections.

Modes de déploiement

L'architecture se qualifie selon vos contraintes de souveraineté, de latence et d'exploitation.

SaaS régional

Mise en route rapide, hébergement dans une région choisie.

Hybride

Analyse centralisée, contrôles exécutés au plus près de vos environnements.

On-premises

Déploiement dans votre infrastructure, sous votre exploitation.

Isolé ou air-gapped

Environnements sans connectivité sortante, avec mises à jour maîtrisées.

La découverte peut être agentless lorsque possible. Les contrôles qui doivent arrêter une action restent proches du runtime, des gateways, des API ou des workloads.

La disponibilité de chaque capacité selon le mode retenu est validée lors du cadrage technique.

Prouver la protection sur un cas d'usage réel

Un périmètre volontairement restreint, choisi pour être représentatif et démontrable.

  • Deux agents
  • Un environnement
  • Trois outils sensibles
  • Un workflow métier
  • Plusieurs scénarios d'attaque
  • Un chemin de risque prioritaire à fermer
  1. 1Cadrer
  2. 2Découvrir
  3. 3Cartographier
  4. 4Protéger
  5. 5Attaquer
  6. 6Décider de la trajectoire de production

Le format de référence sur six semaines est indicatif : il dépend de la disponibilité des environnements, des intégrations, de la maturité du cas d'usage et des prérequis de sécurité.

Une technologie intégrée à votre réalité

Ariovis conçoit et intègre une couche de protection agentique adaptée à votre environnement, puis l'articule avec vos capacités IAM, cloud, API, DevSecOps et SOC.

  • Cadrer le cas d'usage
  • Construire le threat model
  • Cartographier les agents et dépendances
  • Concevoir l'architecture
  • Intégrer les sources et capteurs
  • Configurer les contrôles
  • Organiser les simulations et tests
  • Accompagner l'enforcement progressif
  • Connecter le SOC, le SIEM et le ticketing
  • Produire les procédures et runbooks
  • Former les équipes
  • Accompagner la mise en production
  • Exploiter et améliorer les protections dans la durée

Vous restez propriétaire de vos environnements, de vos données et de vos décisions de sécurité.

La protection agentique complète votre chaîne de sécurité

Elle ne remplace pas vos briques IAM : elle s'y appuie et leur ajoute la maîtrise de l'effet réel.

  • Autorisation fine

    Déterminer si une action précise est légitime selon l'identité, la ressource et le contexte.

    Découvrir l'offre
  • PAM

    Protéger les secrets, comptes techniques et accès privilégiés utilisés par l'agent.

    Découvrir l'offre
  • Access Management et CIAM

    Sécuriser les tokens, les sessions et les accès aux API.

    Découvrir l'offre
  • Sécurité des identités et Active Directory

    Identifier les groupes, délégations et chemins d'attaque accessibles par l'agent.

    Découvrir l'offre
  • Stratégie IAM et Zero Trust

    Définir la gouvernance, le niveau d'autonomie et la trajectoire.

    Découvrir l'offre
  • Run et services managés

    Traiter les alertes, maintenir les contrôles et améliorer les protections.

    Découvrir l'offre

Questions fréquentes

Pourquoi un filtre de prompts ne suffit-il pas ?

Un filtre agit sur le langage, pas sur l'effet. Il ne voit ni le code de l'agent, ni ses dépendances, ni les outils qu'il appelle, ni les API qu'il atteint, ni les processus et flux réseau qu'il génère. Une instruction malveillante peut arriver par un document indexé, un résultat d'outil ou une mémoire contaminée, puis produire une action réelle que seul un contrôle proche du runtime peut interrompre.

Comment découvrir les agents et outils non déclarés ?

En combinant plusieurs sources : trafic vers les fournisseurs de modèles, appels d'API, workloads en exécution, dépôts de code, manifests MCP et configurations. Ces signaux sont recoupés pour construire un inventaire, identifier les propriétaires et faire apparaître le Shadow AI, y compris les usages lancés hors du cadre habituel des projets.

Comment sécuriser les serveurs MCP ?

En inventoriant les serveurs et leurs outils, en vérifiant propriétaire, version et provenance, puis en restreignant les outils visibles par agent. Les schémas et paramètres sont contrôlés, les destinations et les montants contraints, les actions sensibles simulées ou soumises à validation humaine, et le résultat filtré avant retour à l'agent.

Comment protéger le RAG et les mémoires ?

En contrôlant ce qui entre dans les index et dans la mémoire, en détectant les instructions dissimulées dans les documents, en cloisonnant le retrieval par tenant ou par dossier, en masquant les données sensibles et en permettant de geler ou restaurer une mémoire contaminée.

Pourquoi protéger le runtime ?

Parce que l'effet réel s'y produit : un processus lancé, un fichier lu ou écrit, un flux réseau sortant. C'est le dernier endroit où une action dangereuse peut encore être arrêtée, et le seul qui permette de vérifier qu'une correction a bien changé le comportement observé.

Peut-on commencer en mode observation ?

Oui, et c'est le mode de démarrage recommandé. La découverte et l'observation permettent de construire une baseline, de tester les politiques en simulation, puis d'activer le blocage uniquement là où l'action est sensible ou irréversible.

Comment détecter un agent compromis ou détourné ?

Par la corrélation entre couches : une instruction inhabituelle, un enchaînement d'outils inattendu, un volume ou un coût anormal, un accès à des données hors périmètre, un processus ou un egress jamais observé. La détection porte sur la séquence, pas sur un événement isolé.

Comment isoler ou révoquer un agent ?

En coupant ce qui produit l'effet : révocation des secrets et tokens, retrait des outils, blocage des destinations réseau, passage en lecture seule, isolation ou arrêt du workload, gel de la mémoire. Ces actions sont préparées à l'avance dans des runbooks pour être exécutables sans improvisation.

Comment intégrer les alertes au SOC existant ?

Les détections, chronologies et preuves sont exportées vers votre SIEM et vos outils SOAR, avec création de tickets et runbooks associés. L'objectif est d'utiliser vos processus de traitement existants, pas d'ouvrir une console de plus.

Comment cette offre s'articule-t-elle avec l'IAM et l'autorisation fine ?

L'autorisation fine répond à la question du droit : cette action est-elle légitime dans ce contexte. Cette offre répond à la question de l'effet : ce que l'agent fait réellement, avec quels outils et quelles données, si son environnement est sain et comment interrompre puis expliquer un incident. Les deux se complètent et s'appuient sur vos briques IAM, PAM et Access Management.

Cas d'usage

Cas d'usage associés

Cette capacité intervient souvent dans des situations plus larges. Découvrez comment elle s'articule avec les autres offres Ariovis pour répondre à des problèmes concrets.

  • IA et automatisation

    Sécuriser les agents IA

    Donner de l'autonomie aux agents IA sans perdre la maîtrise de leurs identités, de leurs outils, de leurs données et de leurs effets réels.

Vos agents peuvent agir. Vous devez pouvoir maîtriser leurs effets.

Partons d'un agent, de ses outils et d'un workflow réel. Ariovis vous aide à découvrir sa surface d'action, tester ses scénarios de risque et appliquer progressivement les protections nécessaires.