Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Définissez ce que vos agents IA peuvent faire. Appliquer des stratégies au moment de l’exécution. Restez en contrôle sur les frameworks, les plateformes et les clouds.
Les agents IA vont au-delà des conversations. Ils récupèrent des informations sensibles, appellent des outils, exécutent des transactions, interagissent avec les systèmes d’entreprise et prennent de plus en plus de décisions au nom des utilisateurs et des organisations.
Alors que les agents deviennent plus autonomes, une question fondamentale se pose : Comment donner aux agents la liberté d’agir sans renoncer à ce qu’ils sont autorisés à faire ?
Les invites système et les filtres de sécurité IA traditionnels fournissent des protections importantes, mais ils ne sont pas suffisants pour régir chaque action qu’un agent autonome peut entreprendre. Un agent peut générer un texte parfaitement acceptable lors de l’émission d’un remboursement non autorisé, de l’accès aux enregistrements restreints ou de l’appel d’un outil en violation de la politique de l’entreprise.
Les entreprises ont besoin d’un moyen de définir des limites autour du comportement de l’agent, d’évaluer les actions à mesure qu’elles se produisent et d’appliquer des stratégies cohérentes sans coder en dur les règles métier dans chaque agent.
Agent Controls est un service de stratégie managé qui permet aux développeurs et aux organisations de définir, gérer et évaluer de manière centralisée les stratégies régissant le comportement de l’agent IA au moment de l’exécution.
Basé sur la spécification de contrôle de l’agent open source (ACS) et Agent Hooks, Agent Controls apportent une évaluation de stratégie managée aux agents créés sur différents frameworks, plateformes et clouds.
Avec Agent Controls, vous pouvez :
- Contrôler ce que font les agents, pas seulement ce qu’ils disent. Définissez des stratégies pour l’exécution des outils, les transactions métier, l’accès aux informations sensibles et le contenu généré.
- Aller au-delà des filtres de sécurité traditionnels. Combinez des règles métier déterministes, des classifieurs de sécurité de contenu intégrés et des évaluations basées sur LLM prises en charge pour prendre des décisions de politique adaptées au contexte.
- Appliquer des politiques au moment de l’exécution. Évaluez les actions et réponses proposées aux points d’intervention critiques avant de permettre à l’agent de continuer.
- Gérez et réutilisez les stratégies de manière centralisée. Définissez des stratégies une fois, gérez-les indépendamment du code d’application et appliquez-les de manière cohérente entre plusieurs agents et applications.
- Conservez la visibilité sur les décisions de politique. Recevez des reçus d’évaluation identifiant la politique et la version utilisées, afin que les équipes d’application puissent associer des décisions aux résultats d’exécution réels.
Agent Controls sépare les décisions de stratégie de l’exécution de l’agent. Le service évalue les politiques et retourne des décisions telles que allow, deny ou transform. Le runtime ou l’application de l’agent reste responsable de l’application de ces décisions.
Pourquoi les contrôles d’agent ?
Les agents ne génèrent plus simplement du contenu. Ils prennent des mesures.
Les approches traditionnelles de la sécurité de l’IA se concentrent sur les entrées et sorties des modèles IA : détection de contenu dangereux, protection des informations sensibles ou prévention des réponses non sécurisées.
Mais les agents autonomes introduisent une nouvelle classe de risques. Considérez un agent IA responsable de la gestion des demandes de support client. L’agent peut rechercher des informations client, traiter les remboursements, mettre à jour les détails du compte et communiquer avec les clients.
L’agent peut être invité à ne pas émettre de remboursements supérieurs à $100. Mais que se passe-t-il lorsqu’un client le persuade d’émettre un remboursement de 500 $ ?
- Une invite système peut décrire la restriction, mais elle ne peut pas empêcher l’exécution indépendamment si le modèle produit l’appel d’outil interdit.
- Un classifieur de sécurité du contenu peut évaluer si une réponse contient du contenu dangereux ou sensible, mais elle ne sait pas par nature si un remboursement se trouve dans les limites financières de l’entreprise.
- Et un flux de travail d’approbation générique peut nécessiter un examen humain pour chaque remboursement, en sapant l’efficacité et l’autonomie que l’organisation espère atteindre.
Le défi n’est pas simplement de rendre les agents plus sûrs. C’est rendre l’autonomie gouvernable.
Des flux de travail rigides à l’autonomie contrôlée
Les entreprises veulent des agents IA qui peuvent s’adapter, raisonner et agir indépendamment. Mais ils ont également besoin d’assurances que les agents agiront conformément à leurs politiques organisationnelles.
Historiquement, ce besoin a souvent été de choisir parmi trois approches :
- Limiter l’autonomie. Définissez des flux de travail hautement prescriptifs et des règles déterministes pour chaque action possible.
- Introduisez des points de contrôle humains. Exiger que les personnes approuvent des actions potentiellement lourdes de conséquences, ce qui augmente la surcharge opérationnelle.
- Accepter une plus grande incertitude. Donnez aux agents une plus grande autonomie tout en s’appuyant largement sur des prompts et des vérifications spécifiques à l’application pour éviter tout comportement indésirable.
Aucune de ces approches ne répond entièrement au besoin d’agents autonomes opérant dans des limites métier contraignantes.
Les contrôles d’agent introduisent une autre approche : définissez les limites de manière centralisée, évaluez le comportement de l’agent au moment de l’exécution et autorisez les agents à fonctionner de manière autonome dans ces limites. Au lieu d’essayer de prescrire chaque étape qu’un agent doit entreprendre, les organisations peuvent définir les conditions dans lesquelles une action est autorisée.
Par exemple, une stratégie peut permettre à un agent de support d’émettre des remboursements inférieurs à 100 $, de refuser les remboursements au-dessus de ce montant et d’identifier les actions nécessitant un examen humain. L’agent reste libre pour déterminer comment effectuer une tâche, mais l’application applique la politique configurée lorsque des actions pertinentes sont tentées. Cette approche permet d’introduire une plus grande autonomie sans prendre chaque décision métier en fonction de la volonté du modèle de suivre les instructions.
Basé sur une base ouverte : Agent Hooks et ACS
Les développeurs créent des agents IA à l’aide de différents frameworks, modèles, langages de programmation et plateformes cloud. Les entreprises peuvent exploiter des agents dans Microsoft Foundry aux côtés d’agents créés à l’aide d’autres frameworks ou hébergés dans d’autres environnements.
Les contrôles d’exécution ne doivent pas exiger que chaque agent soit réécrit pour une plateforme unique ou que chaque équipe de développement doive inventer un nouveau mécanisme d’application de stratégie.
C'est pourquoi Microsoft introduit deux blocs de construction open source complémentaires.
Agent Hooks : Interceptez les actions au bon moment
Les hooks d’agent définissent des points d’intervention standardisés dans le cycle de vie d’exécution de l’agent.
Ces hooks permettent aux runtimes de l’agent de suspendre l’exécution et de consulter un évaluateur de stratégie avant de continuer.
Par exemple, un runtime d’agent peut intercepter :
- Entrée reçue : Avant qu’une requête utilisateur n’entre dans le flux d’exécution de l’agent.
- Interactions de modèle : Avant qu’une demande de modèle soit envoyée ou après la réception de sa réponse.
- Exécution de l’outil : Avant l’exécution d’un appel d’outil ou après le retour de son résultat.
- Sortie de l’agent : Avant la publication de la réponse finale à l’utilisateur.
- Événements de cycle de vie de l’agent : Lorsqu’une session d’agent démarre ou s’arrête.
Les hooks d’agent fournissent le mécanisme d’interception et d’application. Elle ne détermine pas les règles d’entreprise ou les politiques de sécurité qui doivent s’appliquer. Cette responsabilité appartient à un évaluateur de politiques.
Spécification du contrôle de l’agent (ACS) : Définir ce qui est autorisé
La Agent Control Specification (ACS) fournit un modèle de stratégie commun et un runtime d’évaluation pour régir le comportement de l’agent.
ACS permet aux développeurs de décrire les stratégies indépendamment de l’implémentation de l’agent.
Une stratégie peut spécifier :
- Les actions de l’agent ou les événements du cycle de vie qu’il régit.
- Quel contenu, arguments d’outil ou contexte d’exécution doivent être évalués.
- Quelles règles déterministes ou les évaluateurs pris en charge doivent être appliqués.
- Quelle décision doit être retournée lorsque les conditions de politique sont remplies.
Par exemple, une stratégie ACS peut exprimer qu’une opération de remboursement n’est autorisée que lorsque le montant demandé se trouve dans le seuil configuré de l’organisation. Au lieu d’enterrer cette restriction dans une invite système ou de la dupliquer sur des wrappers d’outils, les développeurs peuvent exprimer l’exigence en tant que stratégie exécutable explicite.
Les stratégies ACS peuvent être évaluées à l’aide du runtime open source au sein d’une application ou via le service de contrôle de l’agent managé.
Ouvert par conception. Portable dans les écosystèmes d’agents.
Les hooks d’agent et ACS sont conçus pour séparer le runtime de l’agent, l’évaluation des stratégies et le mécanisme d’application. Cette séparation est fondamentale pour la gouvernance des agents interplateforme et intercloud. Les développeurs peuvent intégrer les blocs de construction open source à leurs hôtes d’agent choisis tout en conservant une approche commune de la description et de l’évaluation des stratégies.
L'architecture résultante ne nécessite pas que l'agent sous-jacent s'exécute dans Microsoft Foundry ou qu'il utilise un fournisseur de modèle spécifique. Les runtimes de l’agent doivent implémenter les points d’interception pertinents, fournir un contexte d’exécution fiable et appliquer des décisions de stratégie. La fondation open source permet ces intégrations sans exiger que chaque framework d’agent adopte un modèle de politique complètement différent.
Des blocs de construction open source au contrôle à l’échelle de l’entreprise
Les blocs de construction open source donnent aux développeurs la possibilité d’implémenter des contrôles d’exécution au sein de leurs propres applications. Mais les grandes organisations sont confrontées à un défi supplémentaire. Ils ont rarement un seul agent. Ils peuvent avoir des centaines ou des milliers d’agents développés par différentes équipes, à l’aide de différents frameworks et s’exécuter sur plusieurs environnements.
Sans gestion centralisée des stratégies, chaque équipe doit stocker, configurer, distribuer et mettre à jour ses stratégies indépendamment. Cela crée des défis opérationnels :
- Comment les équipes de sécurité et de gouvernance peuvent-elles établir des politiques qui s’appliquent de manière cohérente entre les applications ?
- Comment les développeurs peuvent-ils réutiliser les règles organisationnelles sans dupliquer la logique de stratégie ?
- Comment les responsables des politiques peuvent-ils mettre à jour les exigences sans coordonner les mises en production d’applications sur des dizaines d’équipes ?
- Comment les organisations peuvent-elles comprendre quelle version de politique a été évaluée lorsqu’un agent a effectué une action particulière ?
- Comment peuvent-ils prendre en charge différents frameworks d’agent sans introduire de systèmes de gouvernance distincts pour chacun d’eux ?
C’est là qu’Agent Controls étend la fondation open source. Agent Controls fournit une gestion centralisée des stratégies et une évaluation de stratégie hébergée basée sur ACS. Les propriétaires de stratégie peuvent créer et gérer des stratégies partagées, tandis que les développeurs intègrent leurs applications à une API d’évaluation commune. Au lieu de déployer une copie indépendante de chaque stratégie dans chaque application, les équipes peuvent référencer des stratégies gérées de manière centralisée à l’aide de leur ID.
Lorsqu’un agent doit évaluer une action, son hôte envoie le contexte d’exécution approprié à Agent Controls. Le service évalue la stratégie sélectionnée et retourne une décision que l’hôte applique. Cela fournit une couche de stratégie managée commune pour les environnements d’agent hétérogènes, sans nécessiter que le service lui-même héberge ou exécute ces agents.
Fonctionnement de Agent Controls
Les contrôles d’agent suivent un flux de contrôle d’exécution simple :
- Définissez et publiez des politiques. Les propriétaires de stratégies créent des stratégies ACS décrivant les comportements autorisés et interdits, puis publient les stratégies sur Agent Controls.
- Interceptez une action d’agent. L’environnement d’exécution d’un agent capte une action ou du contenu à un point d’intervention pertinent, par exemple juste avant l’appel à un outil.
- Évaluez la politique applicable. Le runtime appelle Agent Controls, en fournissant l’action proposée, le contexte d’exécution et la politique à évaluer.
- Retourner une décision. Agent Controls évalue la règle, y compris les observations configurées, et retourne un verdict et un reçu d’évaluation.
- Appliquer la décision. Le runtime de l’agent autorise, bloque ou transforme l’opération proposée en fonction du verdict retourné.
Agent Hooks détermine quand vérifier. ACS définit la façon dont les stratégies sont exprimées et évaluées. Agent Controls fournit une gestion centralisée et une évaluation hébergée dans le cloud. Le runtime de l’agent applique la décision.
Exemple : agent de remboursement fonctionnant dans les limites de l’entreprise
Imaginez qu’une entreprise déploie un agent de support client qui peut traiter les remboursements. L’organisation définit les politiques suivantes :
| Policy | Comportement souhaité |
|---|---|
Le montant du remboursement ne doit pas dépasser $100 |
Refuser les demandes de remboursement au-dessus du seuil |
| Les informations client peuvent uniquement être partagées avec des destinations approuvées | Refuser les transferts non autorisés |
| Les réponses ne doivent pas exposer les informations personnelles sensibles | Évaluer le contenu et bloquer ou transformer si nécessaire |
| Certains engagements clients nécessitent une approbation | Refuser l’action immédiate et lancer le processus d’examen de l’hôte |
Imaginez maintenant que l’agent propose l’appel d’outil suivant :
{
"tool": "refund_order",
"arguments": {
"order_id": "demo-001",
"amount": 150
}
}
Avant d’exécuter l’opération, le runtime de l’agent intercepte l’appel d’outil proposé au pre_tool_call point d’intervention. Le runtime envoie l’action proposée et son contexte à Agent Controls. Agent Controls évalue la politique ACS applicable. La règle déterministe vérifie le montant du remboursement par rapport au seuil autorisé de l’organisation.
Étant donné que $150 dépasse le maximum de 100 $, la stratégie retourne une deny décision. Le runtime de l’agent applique ce verdict en empêchant l’exécution de l’outil de remboursement.
En revanche, un remboursement de $75 respecterait la politique et renverrait allow. L’agent n’est pas tenu de demander l’approbation humaine pour chaque action, ni de suivre une séquence prédéfinie rigide d’étapes. Elle peut fonctionner dans les limites établies par l’organisation.
Cet exemple illustre la valeur centrale des stratégies d’exécution : les agents peuvent rester autonomes dans la façon dont ils effectuent des tâches tout en étant contraints dans les actions qu’ils sont autorisés à exécuter.
ACS et contrôles d’agent hébergés : que devez-vous utiliser ?
L’environnement d’exécution ACS open source et les Agent Controls hébergés reposent sur le même socle de politiques, mais répondent à des besoins opérationnels différents.
| Capacité | ACS open source intégré au processus | Contrôles d’agent hébergé |
|---|---|---|
| Définir des stratégies à l’aide d’ACS | Yes | Yes |
| Évaluer les politiques Rego déterministes | Yes | Yes |
| Évaluer la stratégie | SDK Open Source | service géré par Microsoft |
| Publier et mettre à jour des politiques | Fichiers gérés par l’application ou infrastructure personnalisée | Stratégie ARM partagée et ressources Rego |
| Configurer des observations | Annotateurs configurés par l’application | Classifieurs de sécurité du contenu pris en charge et juges LLM activés |
| Réutiliser des stratégies entre les applications | Grâce à la distribution et à l’intégration personnalisées | Via des ressources de politique gérées de manière centralisée |
| Intercepter l’exécution de l’agent | Hôte de l’agent | Hôte de l’agent |
| Appliquer les décisions de politique | Hôte de l’agent | Hôte de l’agent |
Utilisez ACS open source lorsque vous souhaitez incorporer et utiliser l’évaluation des stratégies au sein de votre propre application ou infrastructure.
Utilisez les contrôles d’agent hébergés lorsque vous souhaitez gérer de manière centralisée les stratégies et vous appuyer sur un service géré pour l’évaluation des stratégies entre les agents et les applications.
Les deux approches sont complémentaires. Une organisation peut utiliser les blocs de construction open source pour l’intégration des applications et le développement local, tout en utilisant les Agent Controls hébergés pour les stratégies d’entreprise partagées.
Concepts de base
Hôte de l’agent
L’hôte est l’application, le runtime de l’agent ou la passerelle qui est responsable de l’exécution. Il sait quand une demande de modèle, un appel d’outil ou une sortie est sur le point de se produire. Il construit le contexte, appelle les contrôles d’agent et décide si l’exécution peut se poursuivre.
L’hôte doit signaler l’action réelle et utiliser les valeurs évaluées. L’évaluation d’un ensemble d’arguments d’outil et la transmission d’un autre contourne la stratégie.
Point d’intervention
Un point d’intervention identifie quand une règle s’applique.
| Point | Évaluer avant |
|---|---|
agent_startup |
Démarrage d’une session |
input |
Accepter une entrée externe par l’agent |
pre_model_call |
Envoi d’une demande de modèle |
post_model_call |
Utilisation d’une réponse de modèle terminée |
pre_tool_call |
Envoi d’un appel d’outil |
post_tool_call |
Consommation d’un résultat d’outil terminé |
output |
Libération du résultat final |
agent_shutdown |
Finalisation de l’arrêt de la session |
La stratégie ACS spécifie les points d’intervention auxquels ses règles s’appliquent. L’hôte de l’agent appelle Agent Controls à ces points pour évaluer l’action ou le contenu correspondants.
Les évaluations de pré-appel déterminent si une demande de modèle ou un appel d’outil peut continuer. Les évaluations post-appel régissent l’utilisation des réponses et des résultats une fois l’opération sous-jacente terminée.
Manifeste et Rego
Une stratégie Agent Controls se compose de deux parties : un manifeste JSON et un ou plusieurs modules Rego.
Le manifeste sélectionne le point de cycle de vie, la valeur d’exécution et les règles Rego sous évaluation. Rego exprime la logique de décision. Les modules Rego sont chargés séparément et référencés par la stratégie ARM.
Par exemple, un agent de support client propose un refund_order appel d’outil avec un ID de commande et un montant de remboursement de 75. La politique commerciale autorise les remboursements de jusqu’à 100.
Pour appliquer cette limite, le manifeste lie le pre_tool_call point d’intervention à la requête data.refund_guard.verdictRego . Il sélectionne tool_call.args dans la charge utile envoyée comme cible d’évaluation.
La règle Rego utilise le nom de l’outil pour identifier une demande de remboursement. Il vérifie de façon déterministe que le montant est numérique, supérieur à zéro et non supérieur à 100.
Instantané et cible
Le snapshot décrit l’événement actuel de l’agent à un point d’intervention. Pour un appel d’outil proposé, il inclut le nom et les arguments de l’outil, ainsi que les détails de l’agent et de la session.
La cible est la partie de cet instantané que la stratégie est configurée pour vérifier. Dans l’exemple de remboursement, le manifeste sélectionne les arguments de l’outil :
Snapshot: proposed tool call
Tool name: refund_order
Arguments: <-- target
order_id: demo-001
amount: 75
Agent and session details
Rego peut inspecter l’instantané entier, y compris les arguments sélectionnés. La destination fournit aux politiques une référence cohérente aux données vérifiées, quel que soit le point d’intervention. Elle identifie également les données qu’une transformation autorisée peut changer.
Annotateur
Un annotateur vérifie le contenu pour une politique. Il s’exécute avant Rego et retourne une annotation, telle qu’une catégorie détectée, une étiquette ou un score.
Les contrôles d’agent prennent actuellement en charge deux types d’annotateurs :
- Les classificateurs Azure AI Sécurité du Contenu détectent les catégories configurées, telles que l’injection d’invite et la violence.
- Les juges LLM classifient le contenu à l’aide de critères écrits personnalisés dans la politique.
Le manifeste spécifie l’annotateur à exécuter, à quel point d’intervention et quel contenu il vérifie. Rego utilise l’annotation retournée comme entrée en même temps que l’instantané et les cibles lors de l’évaluation de la stratégie.
Par exemple, une stratégie de support peut interdire les promesses de remboursement dans les réponses destinées aux clients. À l’intervention output , un juge LLM vérifie la réponse proposée et pourrait l’étiqueter commitment. La règle Rego peut ensuite utiliser l’étiquette et retourner deny.
Verdict
Un verdict est le résultat d’une évaluation de politique. Il indique à l’hôte de l’agent si l’action proposée peut continuer, doit être bloquée ou nécessite d’abord une modification.
-
allow: l’hôte peut exécuter l’action proposée ou libérer le contenu tel qu’il est soumis. -
deny: l’hôte bloque l’action ou retient le contenu. -
transform: l’hôte applique la modification spécifiée dans le verdict à la cible, valide le résultat et poursuit les données mises à jour.
Dans l’exemple de remboursement, la règle autorise un montant valide de 75 et retourne allow. Un montant de 150 dépasse la limite, de sorte que la règle retourne deny et que l’hôte n’émet pas le remboursement. Une autre stratégie peut renvoyer transform pour masquer un champ dans une réponse avant sa publication.
Un verdict peut également inclure :
- Avertissements, qui fournissent des informations supplémentaires sans modifier la décision.
-
Une demande d’approbation, qui accompagne une
denydécision et inclut des détails pour le processus d’examen de l’hôte. L’action reste bloquée jusqu’à ce que le flux de travail d’approbation configuré de l’hôte l’approuve.
Reçu d’évaluation
Un reçu d’évaluation est un enregistrement retourné avec le verdict. Il identifie les politiques et versions évaluées, le point d’intervention vérifié et un ID d’évaluation. L’hôte utilise le reçu pour vérifier que le résultat correspond à sa requête et à sa stratégie attendue.
Par exemple, le reçu d’un contrôle de remboursement identifie la version de stratégie utilisée pour évaluer cet appel. L’hôte enregistre l’ID d’évaluation en même temps que le résultat réel du remboursement, tel que émis ou bloqué. Ce processus permet aux opérateurs de retracer l’action de l’application jusqu’à l’évaluation de la politique.
Utiliser Agent Controls avec votre application
Les contrôles d’agent fournissent deux surfaces d’API complémentaires :
Plan de contrôle : Gérer les stratégies
Utilisez le plan de contrôle Azure Resource Manager (ARM) pour publier, mettre à jour et gérer les ressources de stratégie ACS et les modules Rego réutilisables.
Plan de données : Évaluer les politiques
Utilisez l’API Unified Moderate du plan de données pour évaluer les actions et le contenu au regard de stratégies gérées de façon centralisée.
Pour le flux autonome d’évaluation de stratégie, l’application sélectionne une stratégie à l’aide du paramètre de requête policyId et fournit le contexte d’exécution approprié.
Le service retourne le verdict d’évaluation et le reçu pour que l’application appelante le traite.
Le profil d’API limité au projet utilise targetResourceId et a des exigences d’autorisation et d’accusé de réception distinctes. Ce n’est pas un sélecteur interchangeable pour le flux autonome policyId.
Pour obtenir des exemples complets, consultez les exemples de code Contrôles d’agent.
Comprendre la frontière d’application des contrôles
Les contrôles d’agent n’exécutent pas votre agent, n’exécutent pas ses outils, ne mettent pas son processus en bac à sable et ne contrôlent pas un chemin qui contourne votre code d’interception. Elle ne déduit pas les autorisations d’un utilisateur à partir d’une invite ou ne rend pas fiable une revendication d’identité générée par un modèle.
Conservez les données d’autorisation et les données d’entreprise faisant autorité dans les systèmes d’application de confiance. Utilisez des stratégies pour déterminer ce qui peut être autorisé à se poursuivre en fonction des contextes correctement construits, et vérifier l’application des règles sur l’hôte.
Billing
Pendant la préversion publique, vous payez uniquement pour l’utilisation du classifieur et de LLM déclenchée par l’évaluation de la stratégie Contrôles d’agent.
L’utilisation du classifieur Content Safety est facturée en fonction des tarifs Content Safety. Si votre stratégie appelle un juge LLM, vous êtes également responsable des frais d’utilisation de modèle associés.