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

# Políticas MAIP

> Defina reglas de aplicación en tiempo de ejecución que controlen lo que los agentes de IA pueden hacer basándose en puntuaciones de confianza, alcances, profundidad de delegación y tipo de agente.

Las políticas MAIP le permiten aplicar barreras al comportamiento del agente de IA en tiempo de ejecución. Cuando un agente solicita acceso a un recurso con ámbito, todas las políticas activas se evalúan antes de que la acción continúe. Si alguna política deniega la solicitud, la acción se bloquea.

> [!NOTE]
>
> Las políticas MAIP son diferentes de las [políticas de emisión](https://docs.truthlocks.com/es/guides/issuance-policies.md). Las políticas de emisión rigen la **acuñación y verificación de credenciales** para usuarios e emisores humanos. Las políticas MAIP rigen el **comportamiento del agente de máquina** en tiempo de ejecución, controlando lo que los agentes pueden hacer basándose en puntuaciones de confianza, profundidad de delegación, alcances y tipo de agente.

## Cuándo usar políticas MAIP

Use las políticas de MAIP cuando necesite:

* Bloquear agentes con puntuaciones de confianza bajas para que no realicen operaciones sensibles
* Requerir aprobación humana cuando un agente está inmerso en una cadena de delegación
* Restringir tipos de agentes específicos (por ejemplo, `llm` o `worker`) para que no accedan a ciertos ámbitos
* Aplicar diferentes reglas para diferentes niveles de riesgo sin cambiar el código del agente
* Añadir barreras de seguridad en tiempo de ejecución a los flujos de trabajo de orquestación multiagente

Si no crea ninguna política de MAIP, el acceso del agente se controla solo mediante asignaciones de alcance y el estado del agente.

## Cómo funcionan las políticas

Cada política MAIP contiene una o más **reglas**. Cada regla tiene:

* **Condiciones** — comprobaciones a nivel de campo evaluadas contra el contexto del agente solicitante
* **Efecto** — `allow`, `deny`, o `require_approval`
* **requires\_approval** — bandera opcional que activa un flujo de trabajo de aprobación humana

Las reglas dentro de una política se evalúan de forma independiente. Si **cualquier** regla con un efecto `deny` coincide, la acción se bloquea independientemente de cualquier regla `allow`. Este es un modelo de **denegar-anula**.

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

### Orden de evaluación

1. **Estado del agente**: el agente debe estar `active`. Los agentes suspendidos o revocados siempre son denegados.
2. **Verificación de alcance**: el alcance solicitado debe estar en los alcances concedidos del agente. Los alcances denegados explícitamente (con el prefijo `!`) siempre bloquean el acceso.
3. **Reglas de política** — todas las políticas de inquilino activas se evalúan en orden de prioridad (los números más bajos primero). Las condiciones de cada regla se unen con AND.

### Campos de condición

| Campo | Tipo | Operadores | Descripción |
| - | - | - | - |
| `trust_score` | number | `lt`, `gt`, `le`, `ge` | Puntuación de confianza actual del agente (0.0–1.0) |
| `scope` | string | `eq`, `ne`, `in`, `contains` | El alcance que se solicita (por ejemplo, `data:write`) |
| `agent_type` | string | `eq`, `ne`, `in` | Tipo de agente (por ejemplo, `llm`, `worker`, `orchestrator`) |
| `delegation_depth` | number | `gt`, `ge`, `lt`, `le` | Posición en la cadena de delegación (0 = directo) |

### Operadores

| Operador | Descripción | Valor de ejemplo |
| - | - | - |
| `eq` | Es igual a | `"data:write"` |
| `ne` | No es igual a | `"system"` |
| `lt` | Menor que | `0.5` |
| `gt` | Mayor que | `3` |
| `le` | Menor o igual que | `0.3` |
| `ge` | Mayor o igual que | `0.7` |
| `in` | Coincide con cualquier valor de una lista | `["llm", "worker"]` |
| `contains` | La cadena contiene la subcadena | `"write"` |

### Efectos

| Efecto | Comportamiento |
| - | - |
| `allow` | Permitir explícitamente la acción. No anula las denegaciones de otras reglas. |
| `deny` | Bloquear la acción. La primera denegación gana. |
| `require_approval` | Permitir la acción pero marcarla para aprobación humana antes de continuar. |

## Creación de una política

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

Todas las nuevas políticas se crean con `status: "active"` y entran en vigor inmediatamente.

### Categorías de políticas

| Categoría | Caso de uso |
| - | - |
| `scope` | Restringir el acceso según ámbitos o recursos específicos |
| `trust` | Restringir el acceso según umbrales de puntuación de confianza |
| `rate` | Restringir la frecuencia o el volumen de acceso |
| `custom` | Lógica de aplicación personalizada (predeterminada si se omite) |

### Prioridad

El campo `priority` controla el orden de evaluación. Los números más bajos se evalúan primero. Rango: 1–1000. Predeterminado: `100`. Si varias políticas comparten la misma prioridad, se evalúan en orden de creación.

## Evaluación de políticas en tiempo de ejecución

Llame al endpoint de evaluación antes de que su agente realice una operación sensible. La respuesta le indicará si la acción está permitida, denegada o requiere aprobación humana.

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

**Respuesta permitida:**

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

**Respuesta denegada:**

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

**Requiere respuesta de aprobación:**

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

Cuando `requires_approval` es `true`, su aplicación debe enrutar la acción a través de un flujo de trabajo de aprobación humana antes de continuar.

## Listado de políticas

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

Devuelve todas las políticas MAIP para su inquilino, incluidas sus reglas, prioridad y estado.

## Patrones comunes

### Bloquear agentes no confiables para que no escriban datos

Denegar a cualquier agente con una puntuación de confianza inferior a 0.5 el acceso a ámbitos de escritura.

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

### Requerir aprobación para cadenas de delegación profunda

Los agentes con más de tres niveles de profundidad en una cadena de delegación deben obtener aprobación humana para cualquier acción.

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

### Restringir a los agentes LLM la ejecución de herramientas

Evitar que los agentes de tipo LLM invoquen ámbitos de ejecución de herramientas mientras se permiten otros tipos de agentes.

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

### Bloquear múltiples tipos de agentes de un ámbito

Utilice el operador `in` para hacer coincidir una lista de valores en lugar de escribir reglas separadas para cada tipo de agente.

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

### Denegar todos los ámbitos de escritura con una sola regla

Utilice el operador `contains` para hacer coincidir cualquier ámbito que incluya una subcadena, en lugar de listar cada ámbito de escritura individualmente.

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

### Combinar múltiples reglas en una política

Una sola política puede contener múltiples reglas para una aplicación en capas:

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

Esta política bloquea directamente a los agentes con puntuaciones de confianza inferiores a 0.3 y requiere aprobación humana para las operaciones de escritura de agentes con puntuaciones entre 0.3 y 0.7.

## Políticas MAIP vs. políticas RBAC

| | Políticas MAIP | Políticas RBAC (emisión) |
| - | - | - |
| **Gobierna** | Comportamiento en tiempo de ejecución del agente de máquina | Creación, verificación y exportación de credenciales |
| **Sujetos** | Agentes de IA identificados por MAIP ID | Usuarios e emisores humanos |
| **Campos de condición** | `trust_score`, `scope`, `agent_type`, `delegation_depth` | `jurisdiction`, `trust_tier`, `risk_rating`, `key.age_days` |
| **Modelo de evaluación** | Denegar-anula (cualquier bloqueo de denegación) | La primera coincidencia gana |
| **Ruta de la API** | `/v1/maip/policies` | `/v1/policies` |

## Relacionado

> [card] [Referencia de la API de políticas MAIP](https://docs.truthlocks.com/api-reference/machine-identity/policies/list.md)
>
> Cree, liste y evalúe políticas MAIP a través de la API REST.

> [card] [Puntuaciones de confianza](https://docs.truthlocks.com/guides/trust-scores.md)
>
> Comprenda el sistema de puntuación de confianza que alimenta las condiciones de la política.

> [card] [Autorización del agente](https://docs.truthlocks.com/guides/agent-authorization.md)
>
> Autorización basada en alcance y gestión de sesiones para agentes.

> [card] [Identidad de máquina](https://docs.truthlocks.com/guides/machine-identity.md)
>
> Descripción general completa del Protocolo de Identidad del Agente de Máquina.


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