In breve
- L'11 novembre 2026 IndyKite e Obsidian hanno descritto la stessa struttura: l'agente o il suo runtime propone una chiamata e un punto di decisione separato risponde per ogni chiamata.
- L'ho costruita in locale: una policy Rego in OPA 1.22.4, sei test unitari e un piccolo endpoint AuthZEN Access Evaluation davanti a OPA. Un pagamento da 90 $ contro un limite di 50 $ è tornato con decision false e il motivo over delegated limit.
- La policy nega per impostazione predefinita. Un tool sconosciuto, uno scope mancante, un pagamento oltre il limite e un pagamento non confermato sono stati rifiutati, e ho rotto una regola di proposito per vedere fallire un test.
- Quando ho fermato OPA, il mio shim non ha dato nessuna risposta, quindi il punto di applicazione deve trattare una decisione mancante come un rifiuto.
- Non provati: un vero gateway MCP come punto di applicazione, i test di conformità AuthZEN, le API batch e di ricerca e il logging delle decisioni.
Ripeti questo lab
Ho scritto questo lab perché tu possa rifarlo per conto tuo. Ogni passo ha i comandi da copiare e l'output che ho ottenuto io, e puoi segnarlo come fatto. Le spunte restano solo nel tuo browser.
Copia un prompt già pronto per Claude Code, Cursor, Codex o un altro agente di codice. Solo per ambienti di test.
Mostra il prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: OPA dietro AuthZEN: un punto di decisione per le chiamate ai tool MCP Read the whole lab here (Markdown): https://iamops.dev/it/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.
L’11 novembre 2026 due fornitori hanno pubblicato la stessa idea da lati diversi. IndyKite ha rilasciato il suo Intent Agent, che trasforma un prompt in valutazioni AuthZEN e, secondo la sua guida per sviluppatori, non decide nulla: la decisione resta al servizio AuthZEN. Obsidian ha descritto un Runtime Policy Decision Engine in cui un MCP Security Proxy, un runtime di agenti o un gateway del cliente mette in pausa una chiamata a un tool, chiede una decisione e applica la risposta.
Entrambi dividono il lavoro allo stesso modo. Qualcosa che tiene la richiesta chiede, e qualcos’altro decide. Volevo far girare questa divisione sul mio computer con sole parti open source, così l’ho costruita: un motore di policy (OPA) con una policy per le chiamate ai tool MCP e un sottile endpoint AuthZEN davanti.
Ho scritto una breve spiegazione di AuthZEN, OPA e Cedar.
Cosa costruisce il lab#
- Una policy Rego che riceve una richiesta in forma AuthZEN (subject, action, resource, context) per un
tools/callMCP e restituisce un booleano più i motivi. - Sei test unitari che girano offline con il test runner di OPA.
- Un piccolo endpoint Python che risponde a
POST /access/v1/evaluatione al documento di metadati del PDP, e inoltra la richiesta a OPA come input. - Due rifiuti che volevo vedere: un pagamento oltre il limite delegato all’agente e cosa succede quando OPA non c’è.
Il denaro è in centesimi di dollaro USA. L’agente può pagare fino a 5000 centesimi, cioè 50 $.

Preparazione#
OPA 1.22.4 è un singolo binario statico dalla pagina delle release. L’endpoint è un file di meno di 40 righe di Python 3.13 con la sola libreria standard. Servono anche curl e jq. Non ci sono Docker, database né account. Il lab apre la porta 8181 per OPA e la 8282 per l’endpoint, entrambe su localhost.
La policy#
La richiesta è quella che un punto di applicazione costruirebbe da un tools/call MCP. Il subject è l’agente con i suoi scope e il suo limite, la resource è il tool e il context porta l’importo e se l’utente ha confermato.
La policy ha un catalogo dei tool che dice quale scope serve a ciascuno e se sposta denaro. decision vale false finché una regola non la rende true. I tool di lettura richiedono il loro scope. Un tool che sposta denaro richiede lo scope, un importo pari o inferiore al limite e una conferma:
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 secondo insieme, reasons, spiega i rifiuti. I file completi sono nei passi del lab qui sotto.
Prima i test#
Il runner opa test trova le regole test_ nei file _test.rego. Ne ho scritti sei: una lettura è consentita, una scrittura senza lo scope è negata, un pagamento confermato entro il limite è consentito, un pagamento oltre il limite è negato con il motivo giusto, un pagamento non confermato è negato e un tool sconosciuto è negato. opa check --strict e opa fmt sono passati prima dei test.

Per vedere se i test possono fallire, in una copia ho cancellato la riga user_confirmed dalla seconda regola. Cinque test sono passati e test_payment_needs_confirmation è fallito. È il test che fa il suo lavoro.
Una richiesta, offline#
opa eval prende la policy e un file di richiesta senza avviare un server. La richiesta è l’agente support-bot con entrambi gli scope e un limite di 5000 centesimi, che chiama send_payment per 9000 centesimi con la conferma dell’utente.

L’endpoint AuthZEN#
OPA gira come server sulla porta 8181 e l’endpoint sulla porta 8282 gli sta davanti. La specifica AuthZEN definisce la richiesta come subject, action, resource e context, e la risposta come un decision booleano obbligatorio con un context facoltativo. Il contenuto di quel context è lasciato all’implementazione. Ho messo i motivi del rifiuto sotto reason_admin, la chiave usata dal suo esempio non normativo. Il documento di metadati sta in /.well-known/authzen-configuration.

L’endpoint è uno strumento didattico. Non autentica i chiamanti, non valida l’input e non ha API batch né di ricerca, quindi non è un PDP conforme.
Altri rifiuti, e OPA che sparisce#
Ho inviato altre tre richieste con una piccola funzione di shell chiamata ask. Con il solo scope di lettura, il pagamento è stato negato per scope mancante e anche per il limite, perché l’importo era ancora 9000. Con un importo di 4500 centesimi e user_confirmed a false, è stato negato per la conferma mancante. Un tool chiamato delete_account è stato negato come sconosciuto.

Poi ho fermato OPA e ho inviato di nuovo la richiesta da 4500 centesimi. Lo shim ha sollevato un’eccezione e ha chiuso la connessione, quindi curl ha stampato 000. Non c’era nessun decision: false da applicare. Un gateway che aspetta un true può trattarlo come un rifiuto. Un gateway che blocca solo davanti a un false esplicito lascerebbe passare la chiamata. Non ho provato un gateway reale, quindi questo è un motivo per controllare il tuo, non un risultato su un prodotto.
Trappole#
- I tool sconosciuti non servono una regola. Quando il tool non è nel catalogo,
toolè indefinito, quindi ogni regoladecisionè indefinita e vale il valore predefinitofalse. Un test lo fissa. - I motivi possono sommarsi.
reasonsè un insieme, e la richiesta con il solo scope di lettura ne ha restituiti due insieme. - La policy si fida del context.
user_confirmedvale quanto il punto di applicazione che lo imposta. Un modello non deve poterlo compilare. La guida di IndyKite dice qualcosa di simile per il subject: viene dall’identità verificata del chiamante, mai dal testo del prompt. - Il rifiuto predefinito è una scelta. Il post di Obsidian dice che le chiamate ai tool che non corrispondono a nessuna policy proseguono. Le mie vengono rifiutate. Nessuna delle due è sbagliata, ma decidi di proposito.
Cosa farei con questo#
- Mettere il punto di applicazione nel gateway o nel proxy che vede ogni
tools/call, non dentro l’agente. - Costruire il subject dal token verificato e dal registro delle deleghe, non da qualcosa che ha scritto il modello.
- Tenere la policy in un repository con i suoi test e far girare
opa testin CI. - Far sì che il punto di applicazione neghi in caso di errore, e verificarlo fermando il punto di decisione.
Cosa non ho provato#
Non ho provato un vero gateway MCP come punto di applicazione. Non ho eseguito test di conformità AuthZEN, l’API delle valutazioni batch, le API di ricerca né altri punti di decisione AuthZEN. Non ho provato i bundle di OPA, i log delle decisioni né le prestazioni delle policy. Per questo lab non c’è una registrazione. Il lab non usa credenziali né token.
Le immagini del terminale sono state generate dall’output salvato dell’esecuzione del 20 novembre 2026.
Ripeti questo lab#
Per questo lab servono Linux su amd64, curl, jq e Python 3.13. Conta circa 20 minuti. Apri ogni passo, copia i blocchi e confronta l’output con il mio.
Ogni valore tra parentesi angolari è un segnaposto per il tuo ambiente di test. Nulla in questa pagina è un identificativo o un segreto reale.
Imposta le variabili una sola volta
# 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 di 8 passi fatti
Passo 1Scarica OPA
Obiettivo. Scarica il singolo binario statico di OPA a una versione fissata e stampa la versione.
Prerequisiti
- Linux su amd64 (per macOS o arm64 prendi il file corrispondente dalla pagina delle release), curl, jq e Python 3.13
- Porte 8181 e 8282 libere
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 Output atteso
Version: 1.22.4 Passo 2Scrivi la policy
Obiettivo. Crea la policy Rego: un catalogo di tool, un valore predefinito false, due regole di decisione e un insieme di motivi di rifiuto.
Prerequisiti
- Passo 1 fatto, nella stessa cartella
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 Output atteso
# 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 Passo 3Scrivi i test ed eseguili
Obiettivo. Scrivi sei test unitari, poi esegui il formatter, il controllo strict e il test runner. Tutti devono passare.
Prerequisiti
- Il file della policy del passo precedente
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 Output atteso
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 Passo 4Valuta una richiesta offline
Obiettivo. Scrivi una richiesta in forma AuthZEN per un pagamento da 90 dollari contro un limite di 50 dollari e valutala con opa eval, senza server.
Prerequisiti
- Gli importi sono in centesimi: 9000 sono 90 dollari e 5000 sono 50 dollari
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 Output atteso
false
[
"over delegated limit"
] Passo 5Avvia OPA come server e aggiungi l’endpoint AuthZEN
Obiettivo. Servi la policy da OPA sulla porta 8181, controlla la sua API di decisione, poi avvia il piccolo endpoint Python sulla porta 8282 e leggi il suo documento di metadati.
Prerequisiti
- Passi da 2 a 4 fatti
- L’endpoint è uno strumento didattico, non un PDP AuthZEN conforme; tienilo su 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 . Output atteso
{}
{"result":false}
{
"policy_decision_point": "http://localhost:8282",
"access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
} Passo 6Chiedi una decisione: 90 dollari, poi 45
Obiettivo. Invia la richiesta all’endpoint di valutazione AuthZEN. Deve rifiutare con un motivo. Poi cambia solo l’importo in 4500 centesimi e chiedi di nuovo.
Prerequisiti
- OPA e l’endpoint sono in esecuzione
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 . Output atteso
{
"decision": false,
"context": {
"reason_admin": {
"403": "over delegated limit"
}
}
}
{
"decision": true
} Passo 7Prova altri rifiuti, poi ferma OPA
Obiettivo. Invia altre tre richieste: uno scope mancante, un pagamento non confermato e un tool sconosciuto. Poi ferma OPA e chiedi di nuovo per vedere che non torna nessuna decisione.
Prerequisiti
- L’endpoint è in esecuzione
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 Output atteso
{"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 Passo 8Pulizia
Obiettivo. Ferma entrambi i processi ed elimina i file creati dal lab.
Prerequisiti
- Nient’altro usa le porte 8181 e 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/" Output atteso
000
000 Fonti#
- 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
Questo articolo in formato Markdown · RSS · JSON feed
Nuovi articoli via email
Una email a settimana con nuovi articoli e lab. Disiscrizione in qualsiasi momento.
Il tuo indirizzo è salvato su Kit, il servizio che invia le email. Dettagli