> ## Documentation Index
> Fetch the complete documentation index at: https://docs.truthlocks.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Politiques MAIP

> Définissez des règles d'application d'exécution qui contrôlent ce que les agents IA peuvent faire en fonction des scores de confiance, des étendues, de la profondeur de délégation et du type d'agent.

Les politiques MAIP vous permettent d'appliquer des garde-fous au comportement des agents IA lors de l'exécution. Lorsqu'un agent demande l'accès à une ressource délimitée, toutes les politiques actives sont évaluées avant que l'action ne se poursuive. Si une politique refuse la demande, l'action est bloquée.

> [!NOTE]
>
> Les politiques MAIP sont différentes des [politiques d'émission](https://docs.truthlocks.com/fr/guides/issuance-policies.md). Les politiques d'émission régissent la **création et la vérification des identifiants** pour les utilisateurs humains et les émetteurs. Les politiques MAIP régissent le **comportement des agents machine** à l'exécution — contrôlant ce que les agents peuvent faire en fonction des scores de confiance, de la profondeur de délégation, des portées et du type d'agent.

## Quand utiliser les politiques MAIP

Utilisez les politiques MAIP lorsque vous avez besoin de :

* Bloquer les agents avec de faibles scores de confiance pour les empêcher d'effectuer des opérations sensibles
* Exiger une approbation humaine lorsqu'un agent est profondément dans une chaîne de délégation
* Restreindre l'accès à certaines portées pour des types d'agents spécifiques (par exemple, `llm` ou `worker`)
* Appliquer des règles différentes pour différents niveaux de risque sans modifier le code de l'agent
* Ajouter des garde-fous d'exécution aux workflows d'orchestration multi-agents

Si vous ne créez aucune politique MAIP, l'accès de l'agent est contrôlé uniquement par les attributions de portée et le statut de l'agent.

## Comment fonctionnent les politiques

Chaque politique MAIP contient une ou plusieurs **règles**. Chaque règle a :

* **Conditions** — vérifications au niveau du champ évaluées par rapport au contexte de l'agent demandeur
* **Effet** — `allow`, `deny`, ou `require_approval`
* **requires\_approval** — drapeau optionnel qui déclenche un flux de travail d'approbation humaine

Les règles au sein d'une politique sont évaluées indépendamment. Si **une** règle avec un effet `deny` correspond, l'action est bloquée quelles que soient les règles `allow`. C'est un modèle de **refus-prioritaire**.

```
Agent requests scope → Evaluate all active policies (priority order)
                              │
                     ┌────────┼────────┐
                     ▼        ▼        ▼
                  Policy A  Policy B  Policy C
                  (p: 10)   (p: 20)  (p: 100)
                     │        │        │
                     ▼        ▼        ▼
               Any deny? ──yes──→ Action BLOCKED
                  │
                  no
                  │
                  ▼
             Action ALLOWED
```

### Ordre d'évaluation

1. **Statut de l'agent** — l'agent doit être `active`. Les agents suspendus ou révoqués sont toujours refusés.
2. **Vérification de la portée** — la portée demandée doit être dans les portées accordées à l'agent. Les portées explicitement refusées (préfixées par `!`) bloquent toujours l'accès.
3. **Règles de politique** — toutes les politiques de locataire actives sont évaluées par ordre de priorité (les numéros inférieurs en premier). Les conditions de chaque règle sont liées par un ET.

### Champs de condition

| Champ | Type | Opérateurs | Description |
| - | - | - | - |
| `trust_score` | number | `lt`, `gt`, `le`, `ge` | Score de confiance actuel de l'agent (0.0–1.0) |
| `scope` | chaîne | `eq`, `ne`, `in`, `contains` | La portée demandée (par exemple, `data:write`) |
| `agent_type` | chaîne | `eq`, `ne`, `in` | Type d'agent (par exemple, `llm`, `worker`, `orchestrator`) |
| `delegation_depth` | number | `gt`, `ge`, `lt`, `le` | Position dans la chaîne de délégation (0 = direct) |

### Opérateurs

| Opérateur | Description | Exemple de valeur |
| - | - | - |
| `eq` | Égal à | `"data:write"` |
| `ne` | Différent de | `"system"` |
| `lt` | Inférieur à | `0.5` |
| `gt` | Supérieur à | `3` |
| `le` | Inférieur ou égal | `0.3` |
| `ge` | Supérieur ou égal | `0.7` |
| `in` | Correspond à n'importe quelle valeur d'une liste | `["llm", "worker"]` |
| `contains` | La chaîne contient la sous-chaîne | `"write"` |

### Effets

| Effet | Comportement |
| - | - |
| `allow` | Autoriser explicitement l'action. Ne remplace pas les refus d'autres règles. |
| `deny` | Bloquer l'action. Le premier refus l'emporte. |
| `require_approval` | Autoriser l'action mais la signaler pour approbation humaine avant de continuer. |

## Création d'une politique

```bash cURL theme={null}
curl -X POST https://api.truthlocks.com/v1/maip/policies \
  -H "X-API-Key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Block Low-Trust Write Operations",
    "description": "Deny data:write scope for agents with trust score below 0.5",
    "category": "trust",
    "priority": 10,
    "rules": [
      {
        "conditions": [
          {"field": "trust_score", "op": "lt", "value": 0.5},
          {"field": "scope", "op": "eq", "value": "data:write"}
        ],
        "effect": "deny",
        "requires_approval": false
      }
    ]
  }'
```

```javascript JavaScript theme={null}
const response = await fetch("https://api.truthlocks.com/v1/maip/policies", {
  method: "POST",
  headers: {
    "X-API-Key": "tl_live_...",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "Block Low-Trust Write Operations",
    description: "Deny data:write scope for agents with trust score below 0.5",
    category: "trust",
    priority: 10,
    rules: [
      {
        conditions: [
          { field: "trust_score", op: "lt", value: 0.5 },
          { field: "scope", op: "eq", value: "data:write" },
        ],
        effect: "deny",
        requires_approval: false,
      },
    ],
  }),
});
const policy = await response.json();
```

```python Python theme={null}
import requests

response = requests.post(
    "https://api.truthlocks.com/v1/maip/policies",
    headers={
        "X-API-Key": "tl_live_...",
        "Content-Type": "application/json",
    },
    json={
        "name": "Block Low-Trust Write Operations",
        "description": "Deny data:write scope for agents with trust score below 0.5",
        "category": "trust",
        "priority": 10,
        "rules": [
            {
                "conditions": [
                    {"field": "trust_score", "op": "lt", "value": 0.5},
                    {"field": "scope", "op": "eq", "value": "data:write"},
                ],
                "effect": "deny",
                "requires_approval": False,
            }
        ],
    },
)
policy = response.json()
```

Toutes les nouvelles politiques sont créées avec `status: "active"` et prennent effet immédiatement.

### Catégories de politiques

| Catégorie | Cas d'utilisation |
| - | - |
| `scope` | Restreindre l'accès en fonction de portées ou de ressources spécifiques |
| `trust` | Restreindre l'accès en fonction des seuils de score de confiance |
| `rate` | Restreindre la fréquence ou le volume d'accès |
| `custom` | Logique d'application personnalisée (par défaut si omis) |

### Priorité

Le champ `priority` contrôle l'ordre d'évaluation. Les nombres inférieurs sont évalués en premier. Plage : 1–1000. Par défaut : `100`. Si plusieurs politiques partagent la même priorité, elles sont évaluées dans l'ordre de création.

## Évaluation des politiques à l'exécution

Appelez le point de terminaison d'évaluation avant que votre agent n'effectue une opération sensible. La réponse vous indique si l'action est autorisée, refusée ou nécessite une approbation humaine.

```bash theme={null}
curl -X POST https://api.truthlocks.com/v1/maip/policies/evaluate \
  -H "X-API-Key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "maip:t1234567:01HYX3KPZQ7RJGBN0WFMV8SDEH",
    "scope": "data:write",
    "action": "update_customer_record",
    "resource": "customers/cust_12345"
  }'
```

**Réponse autorisée :**

```json theme={null}
{
  "allowed": true,
  "requires_approval": false
}
```

**Réponse refusée :**

```json theme={null}
{
  "allowed": false,
  "denied_by": ["Block Low-Trust Write Operations"],
  "reason": "denied by policy",
  "requires_approval": false
}
```

**Nécessite une réponse d'approbation :**

```json theme={null}
{
  "allowed": true,
  "requires_approval": true
}
```

Lorsque `requires_approval` est `true`, votre application doit acheminer l'action via un flux de travail d'approbation humaine avant de continuer.

## Liste des politiques

```bash theme={null}
curl https://api.truthlocks.com/v1/maip/policies \
  -H "X-API-Key: $API_KEY"
```

Renvoie toutes les politiques MAIP pour votre locataire, y compris leurs règles, leur priorité et leur statut.

## Modèles courants

### Bloquer les agents non fiables d'écrire des données

Refuser à tout agent ayant un score de confiance inférieur à 0,5 l'accès aux scopes d'écriture.

```json theme={null}
{
  "name": "Block Low-Trust Writes",
  "category": "trust",
  "priority": 10,
  "rules": [
    {
      "conditions": [
        { "field": "trust_score", "op": "lt", "value": 0.5 },
        { "field": "scope", "op": "eq", "value": "data:write" }
      ],
      "effect": "deny"
    }
  ]
}
```

### Exiger l'approbation pour les chaînes de délégation profondes

Les agents à plus de trois niveaux de profondeur dans une chaîne de délégation doivent obtenir l'approbation humaine pour toute action.

```json theme={null}
{
  "name": "Approval for Deep Delegation",
  "category": "scope",
  "priority": 20,
  "rules": [
    {
      "conditions": [
        { "field": "delegation_depth", "op": "gt", "value": 3 }
      ],
      "effect": "require_approval",
      "requires_approval": true
    }
  ]
}
```

### Restreindre les agents LLM à exécuter des outils

Empêcher les agents de type LLM d'invoquer des portées d'exécution d'outils tout en autorisant d'autres types d'agents.

```json theme={null}
{
  "name": "No Tool Execution for LLMs",
  "category": "scope",
  "priority": 15,
  "rules": [
    {
      "conditions": [
        { "field": "agent_type", "op": "eq", "value": "llm" },
        { "field": "scope", "op": "eq", "value": "tool:execute" }
      ],
      "effect": "deny"
    }
  ]
}
```

### Bloquer plusieurs types d'agents d'une portée

Utilisez l'opérateur `in` pour correspondre à une liste de valeurs au lieu d'écrire des règles distinctes pour chaque type d'agent.

```json theme={null}
{
  "name": "No Autonomous Writes",
  "category": "scope",
  "priority": 10,
  "rules": [
    {
      "conditions": [
        { "field": "agent_type", "op": "in", "value": ["llm", "worker"] },
        { "field": "scope", "op": "eq", "value": "data:write" }
      ],
      "effect": "deny"
    }
  ]
}
```

### Refuser toutes les portées d'écriture avec une seule règle

Utilisez l'opérateur `contains` pour correspondre à toute portée qui inclut une sous-chaîne, plutôt que de lister chaque portée d'écriture individuellement.

```json theme={null}
{
  "name": "Read-Only for Low Trust",
  "category": "trust",
  "priority": 10,
  "rules": [
    {
      "conditions": [
        { "field": "trust_score", "op": "lt", "value": 0.5 },
        { "field": "scope", "op": "contains", "value": "write" }
      ],
      "effect": "deny"
    }
  ]
}
```

### Combiner plusieurs règles dans une seule politique

Une seule politique peut contenir plusieurs règles pour une application en couches :

```json theme={null}
{
  "name": "Production Safety Net",
  "category": "custom",
  "priority": 5,
  "rules": [
    {
      "conditions": [
        { "field": "trust_score", "op": "lt", "value": 0.3 }
      ],
      "effect": "deny"
    },
    {
      "conditions": [
        { "field": "trust_score", "op": "lt", "value": 0.7 },
        { "field": "scope", "op": "eq", "value": "data:write" }
      ],
      "effect": "require_approval",
      "requires_approval": true
    }
  ]
}
```

Cette politique bloque purement et simplement les agents dont le score de confiance est inférieur à 0,3, et exige une approbation humaine pour les opérations d'écriture des agents dont le score est compris entre 0,3 et 0,7.

## Politiques MAIP vs. politiques RBAC

| | Politiques MAIP | Politiques RBAC (émission) |
| - | - | - |
| **Gouverne** | Comportement d'exécution de l'agent machine | Création, vérification et exportation des identifiants |
| **Sujets** | Agents IA identifiés par l'ID MAIP | Utilisateurs humains et émetteurs |
| **Champs de condition** | `trust_score`, `scope`, `agent_type`, `delegation_depth` | `jurisdiction`, `trust_tier`, `risk_rating`, `key.age_days` |
| **Modèle d'évaluation** | Les refus l'emportent (tout blocage par refus) | La première correspondance l'emporte |
| **Chemin API** | `/v1/maip/policies` | `/v1/policies` |

## Lié

> [card] [Référence de l'API des politiques MAIP](https://docs.truthlocks.com/api-reference/machine-identity/policies/list.md)
>
> Créer, lister et évaluer les politiques MAIP via l'API REST.

> [card] [Scores de confiance](https://docs.truthlocks.com/guides/trust-scores.md)
>
> Comprendre le système de score de confiance qui alimente les conditions de politique.

> [card] [Autorisation de l'agent](https://docs.truthlocks.com/guides/agent-authorization.md)
>
> Autorisation basée sur la portée et gestion des sessions pour les agents.

> [card] [Identité machine](https://docs.truthlocks.com/guides/machine-identity.md)
>
> Vue d'ensemble complète du protocole d'identité de l'agent machine.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.