+150 XP

ChatGPT · Guardrails : permissions, validation et coûts

Un agent capable d'envoyer un email, de merger une pull request ou de déplacer de l'argent n'est sûr que dans la mesure des verrous que vous placez devant ces actions. Le modèle ne se contente plus de générer du texte. Il agit, et une hallucination formulée avec assurance devient une conséquence bien réelle. Cette leçon traite de la couche de contrôle : ce à quoi un agent peut toucher, quand un humain doit valider, ce qui ne doit jamais tourner sans supervision, et comment empêcher une boucle incontrôlée de brûler votre budget.

Les trois modes de défaillance contre lesquels vous vous protégez

Chaque guardrail que vous construisez correspond à l'un d'entre eux :

  1. Mauvaise action. L'agent fait quelque chose qu'il ne devrait pas faire (supprime un enregistrement, écrit au mauvais client).
  2. Bonne action, mauvais périmètre. L'agent fait ce qu'il faut, mais avec une portée trop large (rembourse toute la commande au lieu d'une seule ligne).
  3. Dérive des coûts. Une boucle, une tempête de retries ou une sortie d'outil énorme qui réintègre le contexte et fait exploser votre facture de tokens.

Les permissions traitent les cas 1 et 2. La validation humaine intercepte les situations à fort enjeu dans ces deux cas. Les contrôles de coûts gèrent le cas 3. Traitez-les comme des systèmes distincts, et non comme une seule grande consigne « soyez prudent ».

Permissions : limitez les outils, pas le prompt

L'erreur la plus fréquente consiste à placer la sécurité dans le prompt (« ne supprime jamais rien sans demander »). Un prompt n'est qu'une suggestion. Les permissions vivent dans le code et la configuration, là où le modèle ne peut pas les contourner par la parole.

Dans ChatGPT (le produit)

Quand vous construisez avec les Custom GPTs et les GPT Actions, vous définissez précisément, via le schéma OpenAPI, quels endpoints d'API l'action peut appeler. Le GPT ne peut pas appeler un endpoint que vous n'avez pas exposé. Utilisez OAuth dans la configuration d'authentification de l'action pour que chaque utilisateur agisse avec ses propres permissions, et non avec une clé partagée. Consultez la documentation Actions pour le flux d'authentification.

Les apps dans ChatGPT (anciennement appelées connecteurs : Google Drive, SharePoint, GitHub et d'autres) héritent des permissions du compte connecté. Si vous connectez un compte de service en lecture seule, l'agent n'a qu'un accès en lecture seule. Configurez le compte sous-jacent selon le principe du moindre privilège avant de le connecter. Sur les offres Business et Enterprise, les administrateurs peuvent aussi restreindre les apps disponibles et les actions qu'elles peuvent effectuer.

L'agent ChatGPT navigue, exécute du code et utilise des apps dans un environnement sandboxé, et il s'arrête pour demander confirmation avant les étapes lourdes de conséquences, comme soumettre un formulaire ou effectuer un achat. Considérez cette confirmation intégrée comme un minimum, pas comme toute votre stratégie.

Dans l'API (où vous contrôlez tout)

Avec la Responses API et l'Agents SDK, les permissions sont du code qui entoure vos fonctions d'outils. Le modèle propose un appel ; votre code décide de l'honorer ou non.

python
ALLOWED_REFUND_CEILING = 100_00  # centimes

def issue_refund(order_id: str, amount_cents: int) -> dict:
    if amount_cents > ALLOWED_REFUND_CEILING:
        return {
            "status": "needs_review",
            "reason": f"Amount {amount_cents} exceeds auto-approve ceiling",
        }
    result = payments.refund(order_id, amount_cents)
    return {"status": "done", "refund_id": result.id}

Le modèle ne voit jamais les identifiants de paiement et ne peut pas relever le plafond. La règle est appliquée là où elle compte.

OpenAI fournit désormais une partie de ces outils en natif. L'Agents SDK propose des guardrails d'entrée et de sortie (des contrôles qui s'exécutent en parallèle de l'agent et peuvent interrompre une exécution) et permet de marquer certains outils comme nécessitant une validation humaine. L'Agent Builder visuel d'AgentKit inclut des nœuds de guardrail et de validation, et la bibliothèque open source Guardrails couvre les contrôles courants comme la détection de données personnelles et le filtrage des jailbreaks. Utilisez-les, mais gardez les limites strictes, comme le plafond de remboursement, dans votre propre code d'outil.

Le point de validation : un exemple concret

Voici le pattern en pratique : un agent prépare une action, mais un humain la valide avant son exécution. C'est un outil en deux phases. La première phase renvoie une proposition. Un humain (ou une étape de validation distincte) confirme. La seconde phase exécute.

Imaginez un agent de support qui traite des demandes de remboursement. Vous voulez qu'il fasse le travail fastidieux (retrouver la commande, lire la politique, préparer le remboursement) mais qu'il ne déplace jamais d'argent de lui-même au-delà d'un seuil.

python
PENDING = {}  # en production, utilisez un vrai datastore

def propose_refund(order_id: str, amount_cents: int, reason: str) -> dict:
    token = f"refund_{order_id}"
    PENDING[token] = {"order_id": order_id, "amount_cents": amount_cents}
    return {
        "status": "awaiting_approval",
        "approval_token": token,
        "summary": f"Refund ${amount_cents/100:.2f} on {order_id}: {reason}",
    }

def commit_refund(approval_token: str) -> dict:
    job = PENDING.pop(approval_token, None)
    if not job:
        return {"status": "error", "reason": "unknown or already-used token"}
    receipt = payments.refund(job["order_id"], job["amount_cents"])
    return {"status": "done", "refund_id": receipt.id}

L'agent peut appeler propose_refund librement. commit_refund n'est jamais exposé au modèle comme outil ; c'est votre interface de validation qui l'appelle après qu'un humain a cliqué sur « approuver ». Le travail du modèle s'arrête à « voici ce que je veux faire ». Le « oui » appartient à une personne. (En production, générez un token aléatoire plutôt qu'un token dérivé de l'identifiant de commande.)

C'est le modèle mental à appliquer à toute automatisation à fort enjeu : l'IA propose, l'humain exécute, avec une étape d'exécution verrouillée derrière quelque chose que le modèle ne peut pas falsifier. Les validations d'outils intégrées à l'Agents SDK appliquent la même idée : l'exécution se met en pause avec une validation en attente, et votre code la reprend une fois qu'une personne a tranché.

Où placer l'humain

Toutes les actions ne méritent pas le même verrou. Répartissez vos outils en catégories :

  • Automatique : lecture seule ou facilement réversible (consulter une commande, rédiger du texte, chercher dans la documentation). Aucun verrou.
  • Validation : lourd de conséquences mais routinier (envoyer un email client, créer un ticket, rembourser sous un plafond). Un humain valide, idéalement par lots.
  • Jamais sans supervision : irréversible ou à fort rayon d'impact (supprimer des données de production, virer de l'argent au-delà d'une limite, publier auprès de tous les utilisateurs, modifier des permissions). Toujours une personne, toujours tracé.

Rendez ces catégories explicites dans votre document de conception. « Dans quelle catégorie se trouve cet outil ? » est la première question à poser pour toute nouvelle capacité ajoutée.

Ce qu'il ne faut jamais automatiser sans supervision

Quelques catégories relèvent de la troisième case, quelle que soit la qualité de votre agent :

  • Les suppressions irréversibles de données clients ou de production.
  • Les transactions financières sortantes au-delà d'une limite faible et fixe.
  • Les modifications d'identité et d'accès (attribution de rôles, rotation des identifiants d'un tiers, modification des paramètres de partage).
  • Les communications publiques ou de masse (publication publique, email à toute une liste, tout ce qui ne peut pas être annulé).
  • Les engagements juridiques ou de conformité (signature, acceptation de conditions, déclarations réglementaires).

Le test : *si l'agent se trompe une seule fois, puis-je annuler avant que quelqu'un en subisse les conséquences ?* Si la réponse est non, c'est un humain qui exécute. Les tâches planifiées rendent ce point encore plus critique, car une tâche planifiée dans ChatGPT s'exécute quand vous ne regardez pas. Tout ce qui est planifié doit produire un brouillon ou une notification, et non déclencher une action irréversible dans le vide.

Vérification des acquis

1. Pourquoi la leçon considère-t-elle que placer les règles de sécurité dans le prompt (par exemple « ne supprime jamais rien sans demander ») est l'erreur la plus fréquente ?

2. Un agent effectue à juste titre un remboursement, mais rembourse toute la commande au lieu de la seule ligne demandée. De quel mode de défaillance s'agit-il ?

3. Selon la leçon, comment faut-il considérer la confirmation intégrée de l'agent ChatGPT avant les étapes lourdes de conséquences ?

CHOIX MULTIPLES

4. Sélectionnez TOUTES les affirmations exactes sur le fonctionnement des permissions avec les Custom GPTs, les GPT Actions et les connecteurs.

Sélectionnez toutes les réponses correctes.

CHOIX MULTIPLES

5. Sélectionnez TOUTES les associations exactes entre un système de guardrail et le mode de défaillance qu'il traite principalement.

Sélectionnez toutes les réponses correctes.

Maîtriser les coûts

Les agents bouclent. C'est leur force et leur risque financier. Une seule exécution défaillante peut appeler un outil cinquante fois, réinjecter chaque résultat volumineux dans le contexte et faire grimper discrètement une facture bien plus élevée qu'une conversation normale. La maîtrise des coûts est un guardrail, pas un sujet secondaire.

Plafonnez la boucle

La limite la plus importante est le nombre maximal d'étapes qu'un agent peut effectuer. Dans l'Agents SDK, vous fixez une limite de tours pour qu'un agent bloqué s'arrête au lieu de tourner indéfiniment.

python
from agents import Agent, Runner

agent = Agent(name="support", instructions=SYSTEM_PROMPT, tools=[propose_refund])

result = Runner.run_sync(agent, "Refund order 8842, item was defective", max_turns=8)

Si l'agent ne termine pas en huit tours, il s'arrête avec une erreur que vous pouvez intercepter et journaliser. Ce seul paramètre fait la différence entre une tâche bornée et une boucle incontrôlée.

Contrôlez ce qui réintègre le contexte

Le coût en tokens s'accumule parce que chaque résultat d'outil est ajouté au contexte et renvoyé à l'appel suivant. Un dump d'API de 20 000 tokens dont le modèle n'avait besoin que d'un champ vous coûtera à chaque tour suivant. Tronquez et résumez les sorties d'outils avant de les renvoyer.

python
def search_logs(query: str) -> dict:
    rows = db.search(query, limit=2000)
    return {"matched": len(rows), "top": rows[:5]}  # pas les 2000

Renvoyez le décompte et un échantillon, pas toute la botte de foin. Le modèle a rarement besoin du dump brut, et votre budget encore moins.

Dimensionnez le modèle et utilisez les leviers peu coûteux

Vous n'avez pas besoin de votre modèle le plus puissant à chaque étape. Confier la classification et l'extraction à un modèle plus petit et moins cher, et réserver le modèle frontier au vrai raisonnement, est l'un des leviers de coût les plus efficaces. Les modèles de raisonnement permettent aussi de fixer un effort de raisonnement plus faible pour les étapes simples. Vérifiez la gamme actuelle et les tarifs par token sur la page de tarifs OpenAI, car les modèles et les chiffres évoluent dans le temps.

Deux autres leviers :

  • Le prompt caching réduit le coût de la partie répétée et statique de votre prompt (instructions système, définitions d'outils) lorsque le même préfixe revient. Placez votre contenu stable au début pour qu'il soit mis en cache.
  • Les structured outputs produisent des réponses concises et exploitables, ce qui évite les cycles de re-prompt et de retry qui doublent discrètement vos dépenses. Définissez le schéma et le modèle renvoie exactement ce format.

Surveillez les dépenses, ne les découvrez pas

Créez des projets distincts (un pour le dev, un pour la prod) avec leurs propres clés d'API, afin d'attribuer les dépenses et de révoquer celle qui pose problème. Fixez un budget mensuel et des seuils d'alerte sur chaque projet dans les paramètres de facturation et de projet OpenAI, et utilisez les rate limits par projet pour plafonner la vitesse à laquelle un bug peut dépenser. Surveillez ensuite le dashboard d'usage. Un pic de coûts sur un graphique est un signal d'alerte ; une facture surprise est un postmortem.

Assembler les couches

Un agent bien protégé fait fonctionner les trois systèmes en même temps :

  1. Les permissions déterminent quels outils existent et quel périmètre a chacun, avec une application dans le code.
  2. Les points de validation se placent devant les outils lourds de conséquences, avec une séparation proposition/exécution pour qu'un humain détienne chaque « oui » irréversible.
  3. Les contrôles de coûts plafonnent la boucle, réduisent ce qui réintègre le contexte, orientent vers le bon modèle et alertent sur les dépenses.

Aucun de ces systèmes ne vit dans le prompt. Le prompt oriente le comportement ; les guardrails imposent les limites. Quand vous ajoutez une nouvelle capacité, posez les questions dans cet ordre : *À quoi cela peut-il toucher ? Qui valide ? Combien cela coûte-t-il si ça boucle ?*

Points clés

  • Appliquez les permissions dans le code, pas dans le prompt. Utilisez les schémas des GPT Actions, des comptes à moindre privilège derrière les apps ChatGPT et des contrôles au niveau des outils que le modèle ne peut pas contourner.
  • Utilisez un verrou proposition/exécution pour les actions à fort enjeu. Les validations d'outils de l'Agents SDK et les nœuds de guardrail d'AgentKit aident, mais les limites strictes appartiennent à votre propre code.
  • Tenez une liste explicite « jamais sans supervision » : suppressions irréversibles, montants au-delà d'une limite fixe, modifications d'accès, communication de masse et engagements juridiques.
  • Plafonnez le nombre d'étapes de chaque agent avec max_turns (ou son équivalent), et tronquez les sorties d'outils pour que les résultats volumineux ne réintègrent pas le contexte à chaque boucle.
  • Séparez dev et prod dans des projets dotés de budgets et d'alertes, orientez les étapes simples vers des modèles moins chers et surveillez le dashboard d'usage pour qu'un pic soit un avertissement, pas une facture.

À faire, tiré de cette leçon

Ces actions sont compilées dans le plan d'action du rôle.

  • Utilisez OAuth pour les Actions à portée utilisateur ou en écriture ; les clés d'API uniquement pour les accès partagés en lecture seule
  • Utiliser des gates propose-then-commit avec tokens pour toutes les actions à fort enjeu
  • Fixez des plafonds de facturation stricts avec des clés API distinctes par environnement
Voir le plan d'action complet →

Articles liés

Les articles récents du blog qui s'appuient sur cette leçon.