> ## 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.

# MAIP-Richtlinien

> Definieren Sie Laufzeit-Durchsetzungsregeln, die steuern, was KI-Agenten basierend auf Vertrauenswerten, Scopes, Delegationstiefe und Agententyp tun können.

MAIP-Richtlinien ermöglichen es Ihnen, Leitplanken für das Verhalten von KI-Agenten zur Laufzeit durchzusetzen. Wenn ein Agent Zugriff auf eine bereichsbezogene Ressource anfordert, werden alle aktiven Richtlinien ausgewertet, bevor die Aktion fortgesetzt wird. Wenn eine Richtlinie die Anforderung ablehnt, wird die Aktion blockiert.

> [!NOTE]
>
> MAIP-Richtlinien unterscheiden sich von [Ausstellungsrichtlinien](https://docs.truthlocks.com/de/guides/issuance-policies.md). Ausstellungsrichtlinien regeln die **Erstellung und Verifizierung von Anmeldeinformationen** für menschliche Benutzer und Aussteller. MAIP-Richtlinien regeln das **Verhalten von Maschinenagenten** zur Laufzeit – sie steuern, was Agenten basierend auf Vertrauenswerten, Delegationstiefe, Scopes und Agententyp tun können.

## Wann MAIP-Richtlinien verwendet werden sollten

Verwenden Sie MAIP-Richtlinien, wenn Sie Folgendes benötigen:

* Agenten mit niedrigen Vertrauenswerten daran hindern, sensible Operationen durchzuführen
* Menschliche Genehmigung verlangen, wenn ein Agent tief in einer Delegationskette steckt
* Bestimmte Agententypen (z. B. `llm` oder `worker`) vom Zugriff auf bestimmte Bereiche ausschließen
* Unterschiedliche Regeln für verschiedene Risikostufen durchsetzen, ohne den Agenten-Code zu ändern
* Laufzeit-Schutzmaßnahmen zu Multi-Agenten-Orchestrierungs-Workflows hinzufügen

Wenn Sie keine MAIP-Richtlinien erstellen, wird der Agentenzugriff nur durch Bereichszuweisungen und den Agentenstatus gesteuert.

## Wie Richtlinien funktionieren

Jede MAIP-Richtlinie enthält eine oder mehrere **Regeln**. Jede Regel hat:

* **Bedingungen** – Feldprüfungen, die anhand des Kontexts des anfragenden Agenten ausgewertet werden.
* **Effekt** – `allow`, `deny` oder `require_approval`
* **requires\_approval** – optionales Flag, das einen menschlichen Genehmigungsworkflow auslöst

Regeln innerhalb einer Richtlinie werden unabhängig voneinander ausgewertet. Wenn **irgendeine** Regel mit einem `deny`-Effekt übereinstimmt, wird die Aktion blockiert, unabhängig von allen `allow`-Regeln. Dies ist ein **Deny-Overrides**-Modell.

```
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
```

### Auswertungsreihenfolge

1. **Agentenstatus** – Der Agent muss `active` sein. Gesperrte oder widerrufene Agenten werden immer abgelehnt.
2. **Bereichsprüfung** – Der angeforderte Bereich muss in den gewährten Bereichen des Agenten enthalten sein. Explizit verweigerte Bereiche (mit dem Präfix `!`) blockieren immer den Zugriff.
3. **Richtlinienregeln** – alle aktiven Mandantenrichtlinien werden in der Reihenfolge ihrer Priorität ausgewertet (niedrigere Nummern zuerst). Die Bedingungen jeder Regel werden mit UND verknüpft.

### Bedingungsfelder

| Feld | Typ | Operatoren | Beschreibung |
| - | - | - | - |
| `trust_score` | number | `lt`, `gt`, `le`, `ge` | Aktueller Vertrauenswert des Agenten (0.0–1.0) |
| `scope` | string | `eq`, `ne`, `in`, `contains` | Der angeforderte Bereich (z. B. `data:write`) |
| `agent_type` | string | `eq`, `ne`, `in` | Agententyp (z. B. `llm`, `worker`, `orchestrator`) |
| `delegation_depth` | number | `gt`, `ge`, `lt`, `le` | Position in der Delegationskette (0 = direkt) |

### Operatoren

| Operator | Beschreibung | Beispielwert |
| - | - | - |
| `eq` | Gleich | `"data:write"` |
| `ne` | Ungleich | `"system"` |
| `lt` | Kleiner als | `0.5` |
| `gt` | Größer als | `3` |
| `le` | Kleiner als oder gleich | `0.3` |
| `ge` | Größer als oder gleich | `0.7` |
| `in` | Entspricht einem beliebigen Wert in einer Liste | `["llm", "worker"]` |
| `contains` | Zeichenkette enthält Teilzeichenkette | `"write"` |

### Effekte

| Effekt | Verhalten |
| - | - |
| `allow` | Aktion explizit zulassen. Überschreibt keine Ablehnungen von anderen Regeln. |
| `deny` | Aktion blockieren. Die erste Ablehnung gewinnt. |
| `require_approval` | Aktion zulassen, aber zur menschlichen Genehmigung kennzeichnen, bevor fortgefahren wird. |

## Eine Richtlinie erstellen

```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()
```

Alle neuen Richtlinien werden mit `status: "active"` erstellt und treten sofort in Kraft.

### Richtlinienkategorien

| Kategorie | Anwendungsfall |
| - | - |
| `scope` | Zugriff basierend auf spezifischen Scopes oder Ressourcen einschränken |
| `trust` | Zugriff basierend auf Vertrauensbewertungsschwellen einschränken |
| `rate` | Zugriffshäufigkeit oder -volumen einschränken |
| `custom` | Benutzerdefinierte Durchsetzungslogik (Standard, falls weggelassen) |

### Priorität

Das Feld `priority` steuert die Auswertungsreihenfolge. Kleinere Zahlen werden zuerst ausgewertet. Bereich: 1–1000. Standard: `100`. Wenn mehrere Richtlinien dieselbe Priorität haben, werden sie in der Reihenfolge ihrer Erstellung ausgewertet.

## Richtlinien zur Laufzeit bewerten

Rufen Sie den Auswertungsendpunkt auf, bevor Ihr Agent eine sensible Operation durchführt. Die Antwort teilt Ihnen mit, ob die Aktion erlaubt, verweigert oder eine menschliche Genehmigung erfordert.

```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"
  }'
```

**Zulässige Antwort:**

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

**Abgelehnte Antwort:**

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

**Genehmigungsantwort erforderlich:**

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

Wenn `requires_approval` `true` ist, sollte Ihre Anwendung die Aktion vor dem Fortfahren durch einen menschlichen Genehmigungsworkflow leiten.

## Richtlinien auflisten

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

Gibt alle MAIP-Richtlinien für Ihren Mandanten zurück, einschließlich ihrer Regeln, Priorität und ihres Status.

## Gängige Muster

### Nicht vertrauenswürdige Agenten vom Schreiben von Daten abhalten

Verweigern Sie jedem Agenten mit einem Vertrauenswert unter 0,5 den Zugriff auf Schreibbereiche.

```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"
    }
  ]
}
```

### Genehmigung für tiefe Delegationsketten erforderlich

Agenten, die mehr als drei Ebenen tief in einer Delegationskette sind, müssen für jede Aktion eine menschliche Genehmigung einholen.

```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
    }
  ]
}
```

### LLM-Agenten die Ausführung von Tools untersagen

Verhindern Sie, dass LLM-Agenten Tool-Ausführungsumfänge aufrufen, während andere Agententypen zugelassen werden.

```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"
    }
  ]
}
```

### Mehrere Agententypen von einem Bereich ausschließen

Verwenden Sie den Operator `in`, um eine Liste von Werten abzugleichen, anstatt separate Regeln für jeden Agententyp zu schreiben.

```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"
    }
  ]
}
```

### Alle Schreibbereiche mit einer einzigen Regel verweigern

Verwenden Sie den Operator `contains`, um jeden Bereich abzugleichen, der eine Teilzeichenfolge enthält, anstatt jeden Schreibbereich einzeln aufzulisten.

```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"
    }
  ]
}
```

### Mehrere Regeln in einer Richtlinie kombinieren

Eine einzelne Richtlinie kann mehrere Regeln für eine mehrschichtige Durchsetzung enthalten:

```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
    }
  ]
}
```

Diese Richtlinie blockiert Agenten mit einem Vertrauensscore unter 0,3 vollständig und erfordert eine menschliche Genehmigung für Schreibvorgänge von Agenten mit einem Score zwischen 0,3 und 0,7.

## MAIP-Richtlinien vs. RBAC-Richtlinien

| | MAIP-Richtlinien | RBAC (Ausgabe)-Richtlinien |
| - | - | - |
| **Regelt** | Laufzeitverhalten des Maschinenagenten | Erstellung, Verifizierung und Export von Anmeldeinformationen |
| **Subjekte** | KI-Agenten, identifiziert durch MAIP-ID | Menschliche Benutzer und Aussteller |
| **Bedingungsfelder** | `trust_score`, `scope`, `agent_type`, `delegation_depth` | `jurisdiction`, `trust_tier`, `risk_rating`, `key.age_days` |
| **Evaluierungsmodell** | Deny-Overrides (alle Ablehnungsblöcke) | First-Match wins |
| **API-Pfad** | `/v1/maip/policies` | `/v1/policies` |

## Verwandt

> [card] [MAIP Policies API-Referenz](https://docs.truthlocks.com/api-reference/machine-identity/policies/list.md)
>
> MAIP-Richtlinien über die REST-API erstellen, auflisten und auswerten.

> [card] [Vertrauenswerte](https://docs.truthlocks.com/guides/trust-scores.md)
>
> Verstehen Sie das Vertrauensbewertungssystem, das in die Richtlinienbedingungen einfließt.

> [card] [Agentenautorisierung](https://docs.truthlocks.com/guides/agent-authorization.md)
>
> Scope-basierte Autorisierung und Sitzungsverwaltung für Agenten.

> [card] [Maschinenidentität](https://docs.truthlocks.com/guides/machine-identity.md)
>
> Vollständige Übersicht über das Machine Agent Identity Protocol.


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