Ce qu'un agent est autorisé à faire (et ce qu'il ne l'est pas)

Un agent IA peut faire plus que répondre aux demandes.

Il peut :

• Modifier des données
• Envoyer des requêtes API
• Créer des fichiers
• Ou lancer des processus

Autrement dit, il peut exécuter des actions dans le monde réel.

Et c'est exactement là qu'un nouveau problème apparaît.

Parce que toutes les actions ne sont pas sûres.

Un agent peut :

• Supprimer des données
• Dépenser de l'argent
• Ou envoyer une requête à un système externe

Même si vous ne l'aviez pas prévu.

Donc un agent ne doit pas être autorisé à tout faire.

Il a besoin de limites.

Ce que sont les actions autorisées (Permissions)

Un agent n'a pas d'accès direct aux outils.

Il ne peut pas tout seul :

• Ouvrir un fichier
• Modifier un enregistrement en base
• Ou envoyer une requête API

Pour exécuter une action, il doit utiliser un outil.

Et seulement les outils qu'il est autorisé à appeler.

Cette liste d'actions autorisées est précisément ses Permissions.

Elles définissent :

• Ce que l'agent peut faire
• Et ce qu'il ne peut pas

Niveaux d'autorisation

Toutes les actions ne sont pas également sûres.

C'est pourquoi les autorisations sont généralement divisées en niveaux, selon à quel point l'agent peut impacter le système.

Read
L'agent peut récupérer des données. Mais il ne peut pas les modifier.

Par exemple : lire un enregistrement en base, ouvrir un fichier, vérifier un statut.

Write
L'agent peut créer ou modifier des données.

Par exemple : créer un nouvel enregistrement, mettre à jour un fichier, sauvegarder un résultat.

Execute
L'agent peut appeler des processus ou des services externes.

Par exemple : envoyer une requête API, lancer un script, appeler un webhook.

Delete
L'agent peut supprimer des données ou des enregistrements.

C'est le niveau le plus dangereux.
Parce que l'action est irréversible.

Plus le niveau d'autorisation est élevé, plus l'agent peut modifier le monde.

Donc on lui donne uniquement l'accès nécessaire pour exécuter la tâche.

Pourquoi il ne faut pas donner accès à tout

Un agent ne comprend pas les conséquences de ses actions.

Il choisit l'outil qui semble le plus adapté dans ce contexte.

Mais "adapté" ne veut pas toujours dire "sûr".

Un agent peut :

• Écrire des données incorrectes
• Appeler une API payante
• Ou supprimer un fichier important

Simplement parce que cela aide à terminer la tâche.

Si vous lui donnez accès à tout, il peut faire plus que prévu.

Qui fixe les limites

Un agent ne choisit pas ses autorisations lui-même.

Il ne décide pas :

• À quels outils il a accès
• Quelles actions il peut exécuter

Ces limites sont fixées par un humain.

Ou par un système qui définit :

• Quels outils sont autorisés
• Quelles actions peuvent être exécutées
• Et à quel niveau d'accès

L'agent ne travaille qu'à l'intérieur de ces règles.

Principe du moindre privilège

Il existe une règle simple :

On donne à l'agent uniquement l'accès nécessaire pour exécuter une tâche précise.

Pas plus.

C'est ce qu'on appelle le principe du moindre privilège (Least Privilege).

Si un agent a seulement besoin d'un accès en lecture, il ne doit pas recevoir un accès en écriture.

S'il doit créer un fichier, il ne doit pas pouvoir le supprimer.

Moins d'autorisations = moins de risques.

En code, cela ressemble à ceci

Ci-dessous, le même principe dans un format simple :
on définit explicitement ce que l'agent peut faire, et on force le système à le vérifier avant chaque action.

1) On a des outils avec différents niveaux de risque

def read_user(user_id: int):
    return {"id": user_id, "status": "active"}


def update_user(user_id: int, status: str):
    return {"id": user_id, "status": status}


def send_webhook(event: str):
    return {"sent": event}


def delete_user(user_id: int):
    return {"deleted": user_id}


TOOLS = {
    "read_user": {"level": "read", "handler": read_user},
    "update_user": {"level": "write", "handler": update_user},
    "send_webhook": {"level": "execute", "handler": send_webhook},
    "delete_user": {"level": "delete", "handler": delete_user},
}

2) Ici on définit les permissions pour cet agent

AGENT_PERMISSIONS = {"read", "write"}  # execute et delete sont interdits

3) Le modèle demande d'exécuter une action

model_output = {
    "action": "update_user",
    "parameters": {"user_id": 42, "status": "paused"},
}

4) Le système vérifie les droits avant exécution

def run_action(call: dict):
    action = call["action"]
    params = call["parameters"]

    tool = TOOLS.get(action)
    if tool is None:
        return {"error": "Outil introuvable"}

    if tool["level"] not in AGENT_PERMISSIONS:
        return {"error": "Action non autorisée"}

    return tool["handler"](**params)

5) Si le niveau est autorisé, on exécute l'action

result = run_action(model_output)
# {"id": 42, "status": "paused"}

Si le modèle demande delete_user, le système retourne :

{
  "error": "Action non autorisée"
}

Analogie du quotidien

Imaginez que vous donnez à quelqu'un les clés de votre appartement.

S'il faut seulement arroser les plantes, vous donnez la clé de la porte.

Mais vous ne donnez pas :

• La clé du coffre-fort
• L'accès à l'application bancaire
• Ou le code PIN de la carte

Parce que plus il y a d'accès, plus on peut modifier des choses.

Même par accident.

C'est pourquoi on donne uniquement les clés nécessaires à la tâche précise.

En bref

FAQ

Q: Un agent peut-il exécuter n'importe quelle action via des outils ?
A: Non. Il peut utiliser uniquement les outils et les actions qui lui sont autorisés.

Q: Qui définit ce qu'un agent est autorisé à faire ?
A: Un humain ou un système qui définit la liste des outils disponibles et leur niveau d'accès.

Q: Qu'est-ce que le principe du moindre privilège ?
A: C'est une règle selon laquelle l'agent reçoit uniquement l'accès nécessaire pour une tâche précise.

Et ensuite

Maintenant, vous savez ce qu'un agent est autorisé à faire.

Mais même avec des restrictions, il peut :

• Rester bloqué dans une boucle
• Répéter les mêmes actions
• Ou consommer des ressources

Donc parfois, l'agent doit s'arrêter tout seul.

Ou être arrêté par le système.