En resumen
- El 11 de noviembre de 2026 IndyKite y Obsidian describieron la misma estructura: el agente o su runtime propone una llamada y un punto de decisión aparte responde por cada llamada.
- La construí en local: una política Rego en OPA 1.22.4, seis pruebas unitarias y un pequeño endpoint AuthZEN Access Evaluation delante de OPA. Un pago de 90 $ contra un límite de 50 $ volvió con decision false y el motivo over delegated limit.
- La política deniega por defecto. Una herramienta desconocida, un scope que falta, un pago por encima del límite y un pago sin confirmar fueron rechazados, y rompí una regla a propósito para ver fallar una prueba.
- Cuando detuve OPA, mi shim no dio ninguna respuesta, así que el punto de aplicación debe tratar una decisión ausente como un rechazo.
- No probados: un gateway MCP real como punto de aplicación, las pruebas de conformidad de AuthZEN, las API batch y de búsqueda y el registro de decisiones.
Repite este lab
Escribí este lab para que puedas repetirlo tú mismo. Cada paso tiene los comandos para copiar y la salida que obtuve yo, y puedes marcarlo como hecho. Las marcas se quedan solo en este navegador.
Copia un prompt listo para Claude Code, Cursor, Codex o cualquier agente de código. Solo para entornos de prueba.
Mostrar el prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: OPA detrás de AuthZEN: un punto de decisión para las llamadas a herramientas MCP Read the whole lab here (Markdown): https://iamops.dev/es/opa-authzen-mcp-tool-call-policy.md What the lab needs before the first step: - Linux on amd64 (for macOS or arm64 take the matching file from the release page), curl, jq and Python 3.13 - Ports 8181 and 8282 free How I want you to work: 1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything. 2. Run one step at a time. Before each command, show it to me and say in a sentence what it does. 3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer. 4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself. 5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me. 6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick. This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users. You may answer in my language.
El 11 de noviembre de 2026 dos proveedores publicaron la misma idea desde lados distintos. IndyKite lanzó su Intent Agent, que convierte un prompt en evaluaciones AuthZEN y, según su guía para desarrolladores, no decide nada: la decisión queda en el servicio AuthZEN. Obsidian describió un Runtime Policy Decision Engine en el que un MCP Security Proxy, un runtime de agentes o un gateway del cliente pausa una llamada a una herramienta, pide una decisión y aplica la respuesta.
Los dos reparten el trabajo igual. Algo que sostiene la petición pregunta y otra cosa decide. Quería ejecutar ese reparto en mi propio equipo con solo piezas de código abierto, así que lo construí: un motor de políticas (OPA) con una política para llamadas a herramientas MCP y un endpoint AuthZEN fino delante.
Escribí una explicación breve de AuthZEN, OPA y Cedar.
Qué construye el lab#
- Una política Rego que recibe una petición con forma AuthZEN (subject, action, resource, context) para un
tools/callde MCP y devuelve un booleano más los motivos. - Seis pruebas unitarias que corren sin conexión con el ejecutor de pruebas de OPA.
- Un pequeño endpoint de Python que responde a
POST /access/v1/evaluationy al documento de metadatos del PDP, y reenvía la petición a OPA como input. - Dos rechazos que quería ver: un pago por encima del límite delegado al agente y qué pasa cuando OPA no está.
El dinero va en centavos de dólar estadounidense. El agente puede pagar hasta 5000 centavos, es decir, 50 $.

Preparación#
OPA 1.22.4 es un único binario estático de la página de versiones. El endpoint es un archivo de menos de 40 líneas de Python 3.13 con solo la biblioteca estándar. También necesitas curl y jq. No hay Docker, ni base de datos, ni cuenta. El lab abre el puerto 8181 para OPA y el 8282 para el endpoint, ambos en localhost.
La política#
La petición es la que un punto de aplicación construiría a partir de un tools/call de MCP. El subject es el agente con sus scopes y su límite, la resource es la herramienta y el context lleva el importe y si el usuario confirmó.
La política tiene un catálogo de herramientas que dice qué scope necesita cada una y si mueve dinero. decision vale false mientras ninguna regla la ponga en true. Las herramientas de lectura necesitan su scope. Una herramienta que mueve dinero necesita el scope, un importe igual o menor que el límite y una confirmación:
decision if {
input.subject.type == "agent"
input.action.name == "tools/call"
tool.scope in input.subject.properties.scopes
tool.moves_money
input.context.amount_cents <= input.subject.properties.limit_cents
input.context.user_confirmed
}Un segundo conjunto, reasons, explica los rechazos. Los archivos completos están en los pasos del lab más abajo.
Primero las pruebas#
El ejecutor opa test encuentra las reglas test_ en los archivos _test.rego. Escribí seis: una lectura está permitida, una escritura sin el scope se deniega, un pago confirmado dentro del límite está permitido, un pago por encima del límite se deniega con el motivo correcto, un pago sin confirmar se deniega y una herramienta desconocida se deniega. opa check --strict y opa fmt pasaron antes de las pruebas.

Para ver si las pruebas pueden fallar, en una copia borré la línea user_confirmed de la segunda regla. Cinco pruebas siguieron pasando y test_payment_needs_confirmation falló. Es la prueba haciendo su trabajo.
Una petición, sin conexión#
opa eval toma la política y un archivo de petición sin arrancar un servidor. La petición es el agente support-bot con ambos scopes y un límite de 5000 centavos, que llama a send_payment por 9000 centavos con la confirmación del usuario.

El endpoint AuthZEN#
OPA corre como servidor en el puerto 8181 y el endpoint del puerto 8282 se pone delante. La especificación de AuthZEN define la petición como subject, action, resource y context, y la respuesta como un decision booleano obligatorio con un context opcional. Deja el contenido de ese context a la implementación. Puse los motivos del rechazo bajo reason_admin, la clave de su ejemplo no normativo. El documento de metadatos está en /.well-known/authzen-configuration.

El endpoint es una herramienta didáctica. No autentica a quien llama, no valida la entrada y no tiene API batch ni de búsqueda, así que no es un PDP conforme.
Más rechazos, y OPA que desaparece#
Envié tres peticiones más con una pequeña función de shell llamada ask. Con solo el scope de lectura, el pago se denegó por scope que falta y también por el límite, porque el importe seguía siendo 9000. Con un importe de 4500 centavos y user_confirmed en false, se denegó por la confirmación que falta. Una herramienta llamada delete_account se denegó como desconocida.

Después detuve OPA y volví a enviar la petición de 4500 centavos. El shim lanzó una excepción y cortó la conexión, y curl imprimió 000. No había ningún decision: false que aplicar. Un gateway que espera un true puede tratarlo como un rechazo. Un gateway que solo bloquea ante un false explícito dejaría pasar la llamada. No probé un gateway real, así que esto es un motivo para comprobar el tuyo, no un hallazgo sobre ningún producto.
Trampas#
- Las herramientas desconocidas no necesitan regla. Cuando la herramienta no está en el catálogo,
toolqueda sin definir, así que toda regladecisionqueda sin definir y se aplica el valor por defectofalse. Una prueba lo fija. - Los motivos pueden acumularse.
reasonses un conjunto, y la petición con solo el scope de lectura devolvió dos a la vez. - La política confía en el context.
user_confirmedvale lo que valga el punto de aplicación que lo rellena. Un modelo nunca debe poder rellenarlo. La guía de IndyKite dice algo parecido del subject: viene de la identidad verificada de quien llama, nunca del texto del prompt. - Denegar por defecto es una elección. La entrada de Obsidian dice que las llamadas a herramientas que no coinciden con ninguna política continúan. Las mías se rechazan. Ninguna de las dos es errónea, pero decídelo a propósito.
Qué haría con esto#
- Poner el punto de aplicación en el gateway o proxy que ve cada
tools/call, no dentro del agente. - Construir el subject a partir del token verificado y del registro de delegación, no de algo que escribió el modelo.
- Guardar la política en un repositorio con sus pruebas y ejecutar
opa testen CI. - Hacer que el punto de aplicación deniegue ante un error, y probarlo deteniendo el punto de decisión.
Qué no probé#
No probé un gateway MCP real como punto de aplicación. No ejecuté pruebas de conformidad de AuthZEN, la API de evaluaciones batch, las API de búsqueda ni ningún otro punto de decisión AuthZEN. No probé los bundles de OPA, los registros de decisiones ni el rendimiento de las políticas. Este lab no tiene grabación. El lab no usa credenciales ni tokens.
Las imágenes de terminal se generaron a partir de la salida guardada de la ejecución del 20 de noviembre de 2026.
Repite este lab#
Este lab necesita Linux en amd64, curl, jq y Python 3.13. Cuenta con unos 20 minutos. Abre cada paso, copia los bloques y compara la salida con la mía.
Cada valor entre corchetes angulares es un marcador para tu entorno de prueba. Nada en esta página es un identificador o secreto real.
Define tus variables una sola vez
# Paste into every terminal you use for this lab. No secrets are involved.
export OPA_VERSION="1.22.4"
export OPA_URL="http://localhost:8181"
export PDP_URL="http://localhost:8282" 0 de 8 pasos hechos
Paso 1Descarga OPA
Objetivo. Descarga el binario estático único de OPA con una versión fija e imprime su versión.
Requisitos
- Linux en amd64 (para macOS o arm64 toma el archivo correspondiente de la página de versiones), curl, jq y Python 3.13
- Puertos 8181 y 8282 libres
curl -sSL -o opa "https://github.com/open-policy-agent/opa/releases/download/v$OPA_VERSION/opa_linux_amd64_static"
chmod +x opa
./opa version | head -1 Salida esperada
Version: 1.22.4 Paso 2Escribe la política
Objetivo. Crea la política Rego: un catálogo de herramientas, un valor por defecto false, dos reglas de decisión y un conjunto de motivos de rechazo.
Requisitos
- Paso 1 hecho, en la misma carpeta
cat > mcp_tools.rego <<'EOF'
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools
default decision := false
# Tool catalog: the scope each tool needs and whether it moves money.
catalog := {
"get_balance": {"scope": "payments.read", "moves_money": false},
"list_transactions": {"scope": "payments.read", "moves_money": false},
"send_payment": {"scope": "payments.write", "moves_money": true},
}
tool := catalog[input.resource.id]
decision if {
input.subject.type == "agent"
input.action.name == "tools/call"
tool.scope in input.subject.properties.scopes
not tool.moves_money
}
decision if {
input.subject.type == "agent"
input.action.name == "tools/call"
tool.scope in input.subject.properties.scopes
tool.moves_money
input.context.amount_cents <= input.subject.properties.limit_cents
input.context.user_confirmed
}
# Explain denials, the way a PDP would put reasons in the AuthZEN context.
reasons contains "unknown tool" if not catalog[input.resource.id]
reasons contains "missing scope" if {
tool
not tool.scope in input.subject.properties.scopes
}
reasons contains "over delegated limit" if {
tool.moves_money
input.context.amount_cents > input.subject.properties.limit_cents
}
reasons contains "user did not confirm" if {
tool.moves_money
not input.context.user_confirmed
}
EOF
head -3 mcp_tools.rego Salida esperada
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools Paso 3Escribe las pruebas y ejecútalas
Objetivo. Escribe seis pruebas unitarias y ejecuta el formateador, la comprobación estricta y el ejecutor de pruebas. Todo debe pasar.
Requisitos
- El archivo de política del paso anterior
cat > mcp_tools_test.rego <<'EOF'
package mcp.tools_test
import data.mcp.tools
agent(scopes, limit) := {"type": "agent", "id": "support-bot", "properties": {"scopes": scopes, "limit_cents": limit}}
call(subject, tool, ctx) := {"subject": subject, "action": {"name": "tools/call"}, "resource": {"type": "mcp_tool", "id": tool}, "context": ctx}
test_read_allowed if {
tools.decision with input as call(agent(["payments.read"], 0), "get_balance", {})
}
test_write_needs_scope if {
not tools.decision with input as call(agent(["payments.read"], 50000), "send_payment", {"amount_cents": 100, "user_confirmed": true})
}
test_payment_within_limit_confirmed if {
tools.decision with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 4500, "user_confirmed": true})
}
test_payment_over_limit_denied if {
r := tools.reasons with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 9000, "user_confirmed": true})
"over delegated limit" in r
}
test_payment_needs_confirmation if {
not tools.decision with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 4500, "user_confirmed": false})
}
test_unknown_tool_denied if {
not tools.decision with input as call(agent(["payments.write"], 5000), "delete_account", {})
}
EOF
./opa fmt --list --fail . && ./opa check --strict . && echo "fmt + strict check: OK"
./opa test . -v Salida esperada
fmt + strict check: OK
mcp_tools_test.rego:30:
data.mcp.tools_test.test_unknown_tool_denied: PASS (970.514µs)
mcp_tools_test.rego:17:
data.mcp.tools_test.test_payment_within_limit_confirmed: PASS (984.282µs)
mcp_tools_test.rego:26:
data.mcp.tools_test.test_payment_needs_confirmation: PASS (1.131509ms)
mcp_tools_test.rego:21:
data.mcp.tools_test.test_payment_over_limit_denied: PASS (1.197352ms)
mcp_tools_test.rego:13:
data.mcp.tools_test.test_write_needs_scope: PASS (1.433506ms)
mcp_tools_test.rego:9:
data.mcp.tools_test.test_read_allowed: PASS (1.255784ms)
--------------------------------------------------------------------------------
PASS: 6/6 Paso 4Evalúa una petición sin conexión
Objetivo. Escribe una petición con forma AuthZEN para un pago de 90 dólares con un límite de 50 dólares y evalúala con opa eval, sin servidor.
Requisitos
- Los importes están en centavos: 9000 son 90 dólares y 5000 son 50 dólares
cat > request.json <<'EOF'
{
"subject": { "type": "agent", "id": "support-bot",
"properties": { "scopes": ["payments.read", "payments.write"], "limit_cents": 5000 } },
"action": { "name": "tools/call" },
"resource": { "type": "mcp_tool", "id": "send_payment" },
"context": { "amount_cents": 9000, "user_confirmed": true }
}
EOF
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.decision' --format pretty
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.reasons' --format pretty Salida esperada
false
[
"over delegated limit"
] Paso 5Arranca OPA como servidor y añade el endpoint AuthZEN
Objetivo. Sirve la política desde OPA en el puerto 8181, comprueba su API de decisión, arranca el pequeño endpoint de Python en el puerto 8282 y lee su documento de metadatos.
Requisitos
- Pasos 2 a 4 hechos
- El endpoint es una herramienta didáctica, no un PDP AuthZEN conforme; déjalo en localhost
./opa run --server --addr localhost:8181 mcp_tools.rego > opa-server.log 2>&1 &
sleep 2
curl -s $OPA_URL/health
curl -s $OPA_URL/v1/data/mcp/tools/decision -d '{"input":'"$(cat request.json)"'}' cat > authzen_pdp.py <<'EOF'
"""A minimal AuthZEN Access Evaluation endpoint in front of OPA.
Standard library only (Python 3.10+). OPA runs on :8181 with mcp_tools.rego loaded.
This is a teaching shim, not a conformant AuthZEN PDP."""
import json
import urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer
OPA = "http://localhost:8181/v1/data/mcp/tools"
class PDP(BaseHTTPRequestHandler):
def _send(self, code, body):
data = json.dumps(body).encode()
self.send_response(code)
self.send_header("content-type", "application/json")
self.end_headers()
self.wfile.write(data)
def do_GET(self):
if self.path == "/.well-known/authzen-configuration":
base = f"http://{self.headers['host']}"
return self._send(200, {"policy_decision_point": base,
"access_evaluation_endpoint": f"{base}/access/v1/evaluation"})
self._send(404, {})
def do_POST(self):
if self.path != "/access/v1/evaluation":
return self._send(404, {})
request = json.loads(self.rfile.read(int(self.headers["content-length"])))
opa_req = urllib.request.Request(OPA, data=json.dumps({"input": request}).encode(),
headers={"content-type": "application/json"})
result = json.load(urllib.request.urlopen(opa_req)).get("result", {})
body = {"decision": bool(result.get("decision"))}
if not body["decision"]:
body["context"] = {"reason_admin": {"403": ", ".join(sorted(result.get("reasons", [])))}}
self._send(200, body)
HTTPServer(("127.0.0.1", 8282), PDP).serve_forever()
EOF
python3 authzen_pdp.py > pdp.log 2>&1 &
sleep 1
curl -s $PDP_URL/.well-known/authzen-configuration | jq . Salida esperada
{}
{"result":false}
{
"policy_decision_point": "http://localhost:8282",
"access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
} Paso 6Pide una decisión: 90 dólares y luego 45
Objetivo. Envía la petición al endpoint de evaluación AuthZEN. Debe rechazar con un motivo. Luego cambia solo el importe a 4500 centavos y vuelve a preguntar.
Requisitos
- OPA y el endpoint están en marcha
curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json | jq .
jq '.context.amount_cents=4500' request.json \
| curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq . Salida esperada
{
"decision": false,
"context": {
"reason_admin": {
"403": "over delegated limit"
}
}
}
{
"decision": true
} Paso 7Prueba más rechazos y luego detén OPA
Objetivo. Envía tres peticiones más: un scope que falta, un pago sin confirmar y una herramienta desconocida. Luego detén OPA y vuelve a preguntar para ver que no llega ninguna decisión.
Requisitos
- El endpoint está en marcha
ask() { curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq -c .; }
jq '.subject.properties.scopes=["payments.read"]' request.json | ask
jq '.context.user_confirmed=false | .context.amount_cents=4500' request.json | ask
jq '.resource.id="delete_account"' request.json | ask
# Now stop OPA and ask again: no decision comes back
pkill -f "opa run --server"
sleep 1
curl -s -o /dev/null -w "%{http_code}\n" -m 5 $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json Salida esperada
{"decision":false,"context":{"reason_admin":{"403":"missing scope, over delegated limit"}}}
{"decision":false,"context":{"reason_admin":{"403":"user did not confirm"}}}
{"decision":false,"context":{"reason_admin":{"403":"unknown tool"}}}
000 Paso 8Limpieza
Objetivo. Detén ambos procesos y borra los archivos que creó el lab.
Requisitos
- Nada más usa los puertos 8181 y 8282
pkill -f "opa run --server" || true
pkill -f authzen_pdp.py || true
rm -f opa mcp_tools.rego mcp_tools_test.rego request.json authzen_pdp.py opa-server.log pdp.log
unset -f ask
# check: nothing listens on ports 8181 and 8282 any more
curl -s -o /dev/null -w "%{http_code}\n" "$OPA_URL/health"
curl -s -o /dev/null -w "%{http_code}\n" "$PDP_URL/" Salida esperada
000
000 Fuentes#
- IndyKite, IndyKite open sources the Intent Agent (11 Nov 2026)
- IndyKite Developer Hub, Intent Agent: turn a prompt into AuthZEN evaluations
- Obsidian Security, Introducing the Runtime Policy Decision Engine
- Help Net Security, Obsidian expands AI agent security with runtime policy enforcement (11 Nov 2026)
- OpenID AuthZEN Authorization API 1.0 (Final)
- Open Policy Agent: Policy Testing
- Open Policy Agent: REST API
- Open Policy Agent: v1.22.4 release
- Model Context Protocol specification: Tools
Este artículo en Markdown · RSS · JSON feed
Nuevos artículos por correo
Un correo a la semana con nuevos artículos y labs. Puedes darte de baja cuando quieras.
Tu dirección se guarda en Kit, el servicio que envía los correos. Detalles