Les agents IA sont prêts à agir. La plupart des entreprises ne sont pas prêtes à les laisser faire.

Pendant la majeure partie de l’ère de l’IA générative, nous nous sommes concentrés sur ce que les modèles disent et ce que nous leur injectons. Nous inspectons les invites, filtrons les réponses, soumettons les modèles à des tests d’attaque (red‑team) et mettons en place des contrôles autour des entrées et des sorties. Ces protections restent importantes, mais elles ont été conçues pour un monde où l’IA générait principalement quelque chose à consommer par un humain.

Les agents modifient cette équation. Ils ne se contentent pas de consommer ou de générer de l’information. Ils agissent.

Un agent peut exécuter des outils, invoquer des sous‑agents, collaborer avec d’autres agents, appeler des API, accéder aux données, utiliser des identifiants, appeler des serveurs MCP, générer et exécuter du code, et prendre une série de décisions de façon autonome dans le but d’atteindre un objectif. Une poursuite implacable. Une fois cela arrivé, la question centrale n’est plus simplement de savoir si le modèle a produit une réponse sûre. Il s’agit de savoir si les actions qu’il entreprend sont sûres à exécuter.

Les récentes divulgations d’OpenAI rendent cette distinction de plus en plus importante. OpenAI a commencé rapporter systématiquement des comportements inattendus ou préoccupants du modèle, tandis que son travail plus large en matière de sécurité s’attaque de plus en plus aux risques qui apparaissent à mesure que les modèles gagnent en autonomie et en accès aux outils.

La leçon n’est pas que les agents sont intrinsèquement dangereux. C’est que la frontière de sécurité a bougé.

Les systèmes agentiques nécessitent un modèle opérationnel différent

L’IA agentique n’est pas simplement une autre architecture d’application. Le logiciel lui‑même détermine de plus en plus la façon dont le travail est réalisé.

Un agent peut rencontrer un obstacle, interpréter ce qui s’est passé et choisir une autre voie. Il peut combiner des outils de manières qui n’avaient pas été explicitement conçues à l’avance. Il peut générer du code et exécuter ce code dans le cadre du même flux de travail. La séquence d’actions peut changer à chaque exécution de l’agent.

En même temps, la population qui crée ce logiciel s’étend de façon spectaculaire. Comme nous l’avons écrit à propos de l’essor du développeur citoyen, l’IA transforme des personnes qui ne se sont jamais considérées comme développeurs en créateurs de logiciels. Un marketeur, un analyste financier ou un responsable des opérations peut désormais décrire ce qu’il souhaite et créer un agent capable d’interagir avec de véritables systèmes d’entreprise.

C’est une expansion extraordinaire de qui peut créer des logiciels et de ce que ces logiciels peuvent faire. Cela signifie également que les organisations disposeront de logiciels beaucoup plus autonomes opérant dans de nombreuses parties de l’entreprise.

La réponse ne peut pas simplement consister à appliquer les contrôles d’hier à ce nouvel environnement. Si les entreprises ne peuvent pas exploiter ces systèmes en toute sécurité, l’alternative sera de les contraindre et, en fin de compte, de ralentir les gains de productivité qu’elles cherchent à obtenir.

Le contrôle doit exister là où les agents agissent

À mesure que l’IA devient plus autonome, le défi passe du contrôle de ce qui entre dans un modèle au contrôle de ce qui se produit lorsque ses décisions se transforment en actions.

Un agent peut démarrer avec un utilisateur approuvé, une invite acceptable, des identifiants légitimes et un accès autorisé à un outil. Aucun de ces éléments ne garantit que chaque action subséquente doit être exécutée.

C’est à ce moment que le temps d’exécution devient crucial. Les organisations doivent comprendre non seulement qui est l’agent, mais aussi se poser des questions sur ce qu’il fait actuellement :

• Quels outils il invoque,
• Quelles ressources il accède, quel code il tente d’exécuter, 
• Quels sous‑agents et quelles communications d’agents ont lieu,
• Ce qui s’est passé immédiatement avant cette action et si son comportement reste dans les limites acceptables,
• Ce que l’agent fait en coulisses pendant l’exécution.

Et lorsqu’il ne le fait pas, le système doit pouvoir intervenir en temps réel avant l’exécution.

Il s’agit d’une distinction importante. L’observabilité vous indique ce qui s’est passé. Le contrôle en temps d’exécution vous permet de contenir la couche d’exécution de l’agent.

Cela devient particulièrement important parce que le comportement agentique est à la fois non déterministe et multidimensionnel. Une action bloquée incitera un agent à essayer une autre approche pour atteindre son objectif. Un appel d’outil apparemment bénin peut devenir risqué en raison de ce qui le précède. Simplement observer ou « détecter et répondre » arrive trop tard pour réellement contrôler l’accès et l’exécution de l’agent.  

Le temps d’exécution doit être en ligne et synchrone afin de pouvoir suivre la vitesse de l’IA.  Le défi fondamental pour adopter de telles approches repose sur une pensée d’avant l’IA qui s’appuie sur une méthodologie d’analyse et de détection plus longue.  Ces principes ne s’appliquent plus dans le monde d’aujourd’hui..

La sécurité en temps d’exécution nécessite du contexte, pas seulement des contrôles

Il y a une tendance à répondre aux risques émergents de l’IA en réduisant l’autonomie : accorder aux agents moins d’autorisations, exiger plus fréquemment une approbation humaine ou restreindre les environnements dans lesquels ils fonctionnent. Ces contrôles seront parfois appropriés, en particulier pour les actions à haut risque.

Mais ils ne peuvent pas constituer le modèle opérationnel à long terme.

Si un humain doit approuver chaque décision significative, nous avons retiré une grande partie de la valeur d’un agent autonome. En nous appuyant sur des interactions humaines strictes en boucle, nous avons transformé certains des individus les plus talentueux en « presseurs de boutons ». Cela a un impact direct sur la capacité à comprendre l’étendue et les interdépendances de la base de code sur laquelle les organisations agentiques s’appuient.

La promesse économique de l’IA agentique provient précisément du fait de permettre aux logiciels d’accomplir un travail significatif de façon indépendante et continue – 24 h/24, 7 j/7. L’objectif ne doit donc pas être d’éliminer l’autonomie, mais de rendre une plus grande autonomie sûre à exploiter.

Cela nécessite des contrôles indépendants en dehors du processus de raisonnement propre à l’agent. La recherche d’Anthropic sur désalignement agentique, menée dans des simulations délibérément construites, illustre pourquoi cela importe. À mesure que les systèmes deviennent plus autonomes, leur comportement peut diverger de ce que leurs opérateurs attendent, même lorsque l’objectif initial semble clair.

L’implication pratique est simple : les organisations ne peuvent pas se fier uniquement à la compréhension de ce que l’on a demandé à un agent de faire. Elles doivent comprendre et contrôler ce qu’il fait réellement.

L’agent n’est plus la partie difficile

L’industrie a consacré d’énormes efforts à rendre les agents plus performants. Nous approchons rapidement du moment où la capacité n’est plus la contrainte principale à l’adoption en entreprise.

La contrainte est le contrôle.

À mesure que les agents deviennent plus autonomes, les conséquences de leurs actions augmentent – et les contrôles conçus pour des logiciels prévisibles deviennent moins efficaces. Les entreprises ont besoin d’une visibilité continue sur ce que font les agents, du contexte pour comprendre pourquoi ces actions sont importantes et de la capacité d’intervenir sans placer un humain au centre de chaque décision.

Cela change ce que signifie exploiter un logiciel.

• Les développeurs doivent comprendre comment les agents se comportent réellement, pas seulement comment ils ont été conçus pour se comporter.
• Les équipes de plateforme et de sécurité doivent établir des limites qui restent applicables lorsque les agents agissent à travers les systèmes et les outils.
• Les dirigeants d’entreprise ont besoin de la certitude qu’une plus grande autonomie ne signifie pas abandonner le contrôle.

C’est fondamentalement différent de sécuriser une autre application ou de gouverner un autre modèle. Nous introduisons des acteurs autonomes dans les environnements d’entreprise : des systèmes capables de raisonner, de prendre des décisions et d’agir. Si les organisations ne peuvent pas voir et contrôler ces actions en temps réel, elles devront finalement restreindre ce que les agents peuvent faire, limitant ainsi une grande partie de la valeur que l’autonomie était censée créer.

La réponse n’est pas de supposer que nous pouvons empêcher chaque mauvaise décision. À mesure que les systèmes deviennent plus autonomes et non déterministes, il devient de plus en plus difficile de le garantir.

L’objectif est de s’assurer qu’une action mauvaise ou destructrice ne se traduise pas par un résultat défavorable.

Cela nécessite une nouvelle couche opérationnelle autour des agents : une qui puisse observer le comportement en continu, comprendre les actions dans leur contexte, appliquer des limites tout au long de la pile d’exécution agentique et intervenir avant qu’une action non intentionnelle ou inacceptable ne devienne un résultat irréversible.

La prochaine phase de l’IA en entreprise ne sera pas définie uniquement par le niveau de capacité des agents. Elle sera définie par la quantité d’autonomie que les organisations peuvent leur accorder en toute sécurité.