# OPA hinter AuthZEN: ein Entscheidungspunkt für MCP-Tool-Aufrufe

> Rego-Policy für MCP-Tools, getestet mit OPA 1.22.4, mit AuthZEN-Endpunkt davor: Eine Zahlung von 90 $ über dem Limit von 50 $ wird abgelehnt.

- URL: https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/
- Language: de
- Author: Argo
- Published: 2026-11-11
- Category: Labs
- Depth: Praxis
- Time: 20 Min.
- Topics: OPA, AuthZEN, MCP, Autorisierung, KI-Agenten

## Kurz gesagt

- Am 11. November 2026 beschrieben [IndyKite](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#was-das-lab-baut) und Obsidian dieselbe Struktur: Der Agent oder seine Laufzeit schlägt einen Aufruf vor, und eine getrennte [Entscheidungsstelle](https://iamops.dev/de/authzen-opa-cedar-explained/#was-authzen-standardisiert) antwortet für jeden einzelnen Aufruf.
- Ich habe diese Struktur lokal gebaut: eine [Rego](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#die-policy)-Policy in [OPA 1.22.4](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#eine-anfrage-offline), sechs Unit-Tests und einen kleinen [AuthZEN](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#der-authzen-endpunkt)-Access-Evaluation-Endpunkt vor OPA. Eine Zahlung von 90 $ gegen ein Limit von 50 $ kam als decision false mit dem Grund over delegated limit zurück.
- Die Policy [lehnt standardmäßig ab](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#die-policy). Ein [unbekanntes Tool](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#weitere-ablehnungen-und-opa-verschwindet), ein fehlender Scope, eine Zahlung über dem Limit und eine unbestätigte Zahlung wurden abgelehnt, und ich habe eine Regel absichtlich zerstört, um einen Test scheitern zu sehen.
- Als ich [OPA](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#weitere-ablehnungen-und-opa-verschwindet) stoppte, gab mein Shim gar keine Antwort. Der Durchsetzungspunkt muss eine [fehlende Entscheidung](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#weitere-ablehnungen-und-opa-verschwindet) daher als Ablehnung behandeln.
- [Nicht getestet](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/#was-ich-nicht-getestet-habe): ein echtes MCP-Gateway als Durchsetzungspunkt, [AuthZEN](https://iamops.dev/de/authzen-opa-cedar-explained/#was-authzen-standardisiert)-Konformitätstests, die Batch- und Such-APIs und das Protokollieren von Entscheidungen.

Am 11. November 2026 veröffentlichten zwei Anbieter dieselbe Idee von verschiedenen Seiten. IndyKite brachte seinen Intent Agent heraus, der einen Prompt in [AuthZEN](https://openid.net/specs/authorization-api-1_0-final.html)-Auswertungen übersetzt und laut seinem [Entwicklerleitfaden](https://developer.indykite.com/guides/guide-intent-agent) nichts entscheidet: Die Entscheidung bleibt beim AuthZEN-Dienst. Obsidian beschrieb eine [Runtime Policy Decision Engine](https://www.obsidiansecurity.com/blog/runtime-policy-decision-engine), bei der ein MCP Security Proxy, eine Agenten-Laufzeit oder ein Kunden-Gateway einen Tool-Aufruf anhält, eine Entscheidung anfordert und die Antwort umsetzt.

Beide teilen die Arbeit gleich auf. Etwas, das die Anfrage hält, fragt, und etwas anderes entscheidet. Ich wollte diese Aufteilung auf meinem eigenen Rechner mit nichts als Open-Source-Teilen laufen lassen und habe sie gebaut: eine Policy-Engine (OPA) mit einer Policy für MCP-Tool-Aufrufe und einen dünnen AuthZEN-Endpunkt davor.

Ich habe eine kurze [Erklärung zu AuthZEN, OPA und Cedar](https://iamops.dev/de/authzen-opa-cedar-explained/) geschrieben.

## Was das Lab baut

- Eine Rego-Policy, die eine Anfrage in AuthZEN-Form (Subject, Action, Resource, Context) für einen MCP-`tools/call` entgegennimmt und einen Boolean samt Gründen zurückgibt.
- Sechs Unit-Tests, die offline mit dem Test-Runner von OPA laufen.
- Einen kleinen Python-Endpunkt, der `POST /access/v1/evaluation` und das Metadatendokument des PDP beantwortet und die Anfrage als Input an OPA weiterreicht.
- Zwei Ablehnungen, die ich sehen wollte: eine Zahlung über dem delegierten Limit des Agenten und was passiert, wenn OPA nicht da ist.

Geld wird in US-Cent angegeben. Der Agent darf bis zu 5000 Cent zahlen, also 50 $.

![Sequenzdiagramm: ein Aufrufer sendet eine AuthZEN-Evaluation für einen MCP-tools/call an einen kleinen Endpunkt, der sie an OPA 1.22.4 weiterleitet. Eine Zahlung über 9000 Cent bei einem Limit von 5000 wird mit dem Grund over delegated limit abgelehnt, 4500 Cent wird erlaubt, andere fehlerhafte Aufrufe werden mit Gründen abgelehnt, und ein gestopptes OPA liefert keine HTTP-Antwort.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/00-flow.webp)

*Die Entscheidung. Die Anfrage nennt den Agenten, den tools/call, das Tool, den Betrag und die Bestätigung. 9000 Cent bei einem Limit von 5000 kommen als decision false mit dem Grund over delegated limit zurück. 4500 Cent mit Bestätigung wird erlaubt. Fehlender Scope, fehlende Bestätigung oder ein unbekanntes Tool werden mit Gründen abgelehnt. Wenn OPA gestoppt ist, gibt der Endpunkt überhaupt keine HTTP-Antwort.*

## Aufbau

OPA 1.22.4 ist eine einzelne statische Binärdatei von der [Release-Seite](https://github.com/open-policy-agent/opa/releases/tag/v1.22.4). Der Endpunkt ist eine Datei mit weniger als 40 Zeilen Python 3.13 mit nur der Standardbibliothek. Außerdem brauchen Sie curl und jq. Es gibt kein Docker, keine Datenbank und kein Konto. Das Lab öffnet Port 8181 für OPA und Port 8282 für den Endpunkt, beide auf localhost.

## Die Policy

Die Anfrage ist die, die ein Durchsetzungspunkt aus einem MCP-[`tools/call`](https://modelcontextprotocol.io/specification/2026-07-28/server/tools) bauen würde. Das Subject ist der Agent mit seinen Scopes und seinem Limit, die Resource ist das Tool, und der Context trägt den Betrag und ob der Benutzer bestätigt hat.

Die Policy hat einen Tool-Katalog, der sagt, welchen Scope jedes Tool braucht und ob es Geld bewegt. `decision` ist `false`, solange keine Regel es auf `true` setzt. Lesende Tools brauchen ihren Scope. Ein Tool, das Geld bewegt, braucht den Scope, einen Betrag höchstens in Höhe des Limits und eine Bestätigung:

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

Eine zweite Menge, `reasons`, erklärt Ablehnungen. Die vollständigen Dateien stehen in den Lab-Schritten weiter unten.

## Erst die Tests

Der Runner `opa test` findet `test_`-Regeln in `_test.rego`-Dateien. Ich habe sechs geschrieben: Ein Lesen ist erlaubt, ein Schreiben ohne den Scope wird abgelehnt, eine bestätigte Zahlung innerhalb des Limits ist erlaubt, eine Zahlung über dem Limit wird mit dem richtigen Grund abgelehnt, eine unbestätigte Zahlung wird abgelehnt, und ein unbekanntes Tool wird abgelehnt. `opa check --strict` und `opa fmt` liefen vor den Tests durch.

![Terminalausgabe von OPA 1.22.4: Versionsangaben, bestandene fmt- und Strict-Prüfung und sechs Unit-Tests mit PASS samt Zusammenfassung 6 von 6.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/02-tests.webp)

*Prüfungen und Tests. Die Formatprüfung, die Strict-Prüfung und alle sechs Tests bestehen auf OPA 1.22.4.*

Um zu sehen, ob die Tests scheitern können, habe ich in einer Kopie die Zeile `user_confirmed` aus der zweiten Regel gelöscht. Fünf Tests bestanden weiter, und `test_payment_needs_confirmation` scheiterte. So soll ein Test arbeiten.

## Eine Anfrage, offline

`opa eval` nimmt die Policy und eine Anfragedatei, ohne einen Server zu starten. Die Anfrage ist der Agent `support-bot` mit beiden Scopes und einem Limit von 5000 Cent, der `send_payment` für 9000 Cent mit Bestätigung des Benutzers aufruft.

![Terminalausgabe zweier opa-eval-Befehle: Die Entscheidung ist false, und die Menge der Gründe enthält over delegated limit.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/03-eval.webp)

*Eine Zahlung von 90 $ gegen ein Limit von 50 $. Die Entscheidung ist false, der Grund lautet „over delegated limit“.*

## Der AuthZEN-Endpunkt

OPA läuft als Server auf Port 8181, und der Endpunkt auf Port 8282 steht davor. Die [AuthZEN-Spezifikation](https://openid.net/specs/authorization-api-1_0-final.html) definiert die Anfrage als Subject, Action, Resource und Context und die Antwort als verpflichtendes boolesches `decision` mit optionalem `context`. Den Inhalt dieses Context überlässt sie der Implementierung. Ich habe die Ablehnungsgründe unter `reason_admin` abgelegt, dem Schlüssel aus ihrem nicht normativen Beispiel. Das Metadatendokument liegt unter `/.well-known/authzen-configuration`.

![Terminalausgabe: das Metadatendokument des PDP mit zwei URLs, eine Ablehnung mit decision false und dem Grund over delegated limit sowie eine Freigabe mit decision true, nachdem der Betrag auf 4500 Cent geändert wurde.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/04-authzen.webp)

*Dieselbe Anfrage über AuthZEN. 9000 Cent werden mit einem Grund abgelehnt. Ändert man nur den Betrag auf 4500 Cent, kommt decision true zurück.*

Der Endpunkt ist ein Lehrbeispiel. Er authentifiziert keine Aufrufer, validiert keine Eingaben und hat weder Batch- noch Such-API, ist also kein konformer PDP.

## Weitere Ablehnungen, und OPA verschwindet

Ich habe drei weitere Anfragen über eine kleine Shell-Funktion namens `ask` geschickt. Mit nur dem Lese-Scope wurde die Zahlung wegen des fehlenden Scopes abgelehnt und auch wegen des Limits, weil der Betrag noch 9000 war. Mit 4500 Cent und `user_confirmed` auf false wurde sie wegen der fehlenden Bestätigung abgelehnt. Ein Tool namens `delete_account` wurde als unbekannt abgelehnt.

![Terminalausgabe dreier abgelehnter Anfragen mit den Gründen missing scope und over delegated limit, user did not confirm sowie unknown tool, danach eine Anfrage nach dem Stoppen von OPA, die den HTTP-Status 000 liefert.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/05-denials.webp)

*Drei weitere Ablehnungen. Jede kommt mit ihren Gründen. Nach dem Stoppen von OPA erhält die Anfrage gar keine HTTP-Antwort, curl zeigt das als 000.*

Dann habe ich OPA gestoppt und die Anfrage mit 4500 Cent erneut geschickt. Der Shim löste eine Exception aus und trennte die Verbindung, curl gab `000` aus. Es gab kein `decision: false`, das sich durchsetzen ließ. Ein Gateway, das auf ein true wartet, kann das als Ablehnung behandeln. Ein Gateway, das nur bei einem ausdrücklichen false blockiert, ließe den Aufruf durch. Ich habe kein echtes Gateway getestet. Das ist also ein Grund, Ihres zu prüfen, kein Befund über ein Produkt.

## Stolpersteine

- **Unbekannte Tools brauchen keine Regel.** Ist das Tool nicht im Katalog, ist `tool` undefiniert, damit ist jede `decision`-Regel undefiniert, und der Standardwert `false` greift. Ein Test hält das fest.
- **Gründe können sich häufen.** `reasons` ist eine Menge, und die Anfrage mit nur dem Lese-Scope lieferte zwei auf einmal.
- **Die Policy vertraut dem Context.** `user_confirmed` ist nur so gut wie der Durchsetzungspunkt, der es setzt. Ein Modell darf es nie ausfüllen können. Der Leitfaden von IndyKite sagt Ähnliches über das Subject: Es kommt aus der verifizierten Identität des Aufrufers, nie aus dem Prompt-Text.
- **Standardmäßig ablehnen ist eine Entscheidung.** Obsidians Beitrag sagt, Tool-Aufrufe ohne passende Policy laufen weiter. Meine werden abgelehnt. Keines von beidem ist falsch, aber entscheiden Sie bewusst.

## Was ich damit machen würde

1. Den Durchsetzungspunkt im Gateway oder Proxy platzieren, der jeden `tools/call` sieht, nicht im Agenten.
2. Das Subject aus dem verifizierten Token und dem Delegationseintrag bauen, nicht aus etwas, das das Modell geschrieben hat.
3. Die Policy mit ihren Tests in einem Repository halten und `opa test` in der CI laufen lassen.
4. Den Durchsetzungspunkt im Fehlerfall ablehnen lassen und das testen, indem man den Entscheidungspunkt stoppt.

## Was ich nicht getestet habe

Ich habe kein echtes MCP-Gateway als Durchsetzungspunkt getestet. Ich habe keine AuthZEN-Konformitätstests, keine Batch-Evaluations-API, keine Such-APIs und keinen anderen AuthZEN-Entscheidungspunkt ausgeführt. Ich habe weder OPA-Bundles noch Entscheidungsprotokolle noch die Policy-Performance getestet. Für dieses Lab gibt es keine Aufzeichnung. Das Lab benutzt keine Zugangsdaten und keine Tokens.

*Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs vom 20. November 2026 gerendert.*

## Dieses Lab nachbauen

Für dieses Lab brauchen Sie Linux auf amd64, curl, jq und Python 3.13. Planen Sie etwa 20 Minuten ein. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie die Ausgabe mit meiner.

Jeder Wert in spitzen Klammern ist ein Platzhalter für Ihre Testumgebung. Nichts auf dieser Seite ist eine echte Kennung oder ein echtes Geheimnis.

**Variablen einmal setzen** `env.sh` (bash)

```bash
# 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"
```

### Schritt 1: OPA herunterladen

**Ziel.** Laden Sie die einzelne statische OPA-Binärdatei in einer festen Version herunter und geben Sie die Version aus.

**Voraussetzungen**

- Linux auf amd64 (für macOS oder arm64 nehmen Sie die passende Datei von der Release-Seite), curl, jq und Python 3.13
- Ports 8181 und 8282 frei

`get-opa.sh` (bash)

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

**Erwartete Ausgabe**

```text
Version: 1.22.4
```

### Schritt 2: Die Policy schreiben

**Ziel.** Legen Sie die Rego-Policy an: einen Tool-Katalog, den Standardwert false, zwei Entscheidungsregeln und eine Menge von Ablehnungsgründen.

**Voraussetzungen**

- Schritt 1 erledigt, im selben Ordner

`write-policy.sh` (bash)

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

**Erwartete Ausgabe**

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

### Schritt 3: Die Tests schreiben und ausführen

**Ziel.** Schreiben Sie sechs Unit-Tests und führen Sie dann Formatter, Strict-Check und Test-Runner aus. Alles sollte bestehen.

**Voraussetzungen**

- Die Policy-Datei aus dem vorigen Schritt

`unit-tests.sh` (bash)

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

**Erwartete Ausgabe**

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

### Schritt 4: Eine Anfrage offline auswerten

**Ziel.** Schreiben Sie eine Anfrage in AuthZEN-Form für eine Zahlung von 90 Dollar bei einem Limit von 50 Dollar und werten Sie sie mit opa eval ohne Server aus.

**Voraussetzungen**

- Beträge sind in Cent: 9000 sind 90 Dollar und 5000 sind 50 Dollar

`eval-offline.sh` (bash)

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

**Erwartete Ausgabe**

```text
false
[
  "over delegated limit"
]
```

### Schritt 5: OPA als Server starten und den AuthZEN-Endpunkt hinzufügen

**Ziel.** Stellen Sie die Policy mit OPA auf Port 8181 bereit, prüfen Sie dessen Entscheidungs-API, starten Sie dann den kleinen Python-Endpunkt auf Port 8282 und lesen Sie sein Metadatendokument.

**Voraussetzungen**

- Schritte 2 bis 4 erledigt
- Der Endpunkt ist ein Lehrbeispiel, kein konformer AuthZEN-PDP; lassen Sie ihn auf localhost

`serve-opa.sh` (bash)

```bash
./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)"'}'
```

`start-endpoint.sh` (bash)

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

**Erwartete Ausgabe**

```text
{}
{"result":false}
{
  "policy_decision_point": "http://localhost:8282",
  "access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
}
```

### Schritt 6: Eine Entscheidung anfordern: 90 Dollar, dann 45

**Ziel.** Senden Sie die Anfrage an den AuthZEN-Auswertungsendpunkt. Er sollte mit einem Grund ablehnen. Ändern Sie dann nur den Betrag auf 4500 Cent und fragen Sie erneut.

**Voraussetzungen**

- OPA und der Endpunkt laufen

`evaluate.sh` (bash)

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

**Erwartete Ausgabe**

```text
{
  "decision": false,
  "context": {
    "reason_admin": {
      "403": "over delegated limit"
    }
  }
}
{
  "decision": true
}
```

### Schritt 7: Weitere Ablehnungen testen, dann OPA stoppen

**Ziel.** Senden Sie drei weitere Anfragen: einen fehlenden Scope, eine unbestätigte Zahlung und ein unbekanntes Tool. Stoppen Sie dann OPA und fragen Sie erneut, um zu sehen, dass keine Entscheidung zurückkommt.

**Voraussetzungen**

- Der Endpunkt läuft

`denials.sh` (bash)

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

**Erwartete Ausgabe**

```text
{"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
```

### Schritt 8: Aufräumen

**Ziel.** Stoppen Sie beide Prozesse und löschen Sie die vom Lab erzeugten Dateien.

**Voraussetzungen**

- Nichts anderes nutzt die Ports 8181 und 8282

`cleanup.sh` (bash)

```bash
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/"
```

**Erwartete Ausgabe**

```text
000
000
```


## Sources

- [IndyKite, IndyKite open sources the Intent Agent (11 Nov 2026)](https://www.indykite.ai/news/indykite-open-sources-the-intent-agent-to-set-a-standard-for-how-ai-agents-express-intent)
- [IndyKite Developer Hub, Intent Agent: turn a prompt into AuthZEN evaluations](https://developer.indykite.com/guides/guide-intent-agent)
- [Obsidian Security, Introducing the Runtime Policy Decision Engine](https://www.obsidiansecurity.com/blog/runtime-policy-decision-engine)
- [Help Net Security, Obsidian expands AI agent security with runtime policy enforcement (11 Nov 2026)](https://www.helpnetsecurity.com/2026/11/11/obsidian-security-runtime-policy-decision-engine/)
- [OpenID AuthZEN Authorization API 1.0 (Final)](https://openid.net/specs/authorization-api-1_0-final.html)
- [Open Policy Agent: Policy Testing](https://www.openpolicyagent.org/docs/policy-testing)
- [Open Policy Agent: REST API](https://www.openpolicyagent.org/docs/rest-api)
- [Open Policy Agent: v1.22.4 release](https://github.com/open-policy-agent/opa/releases/tag/v1.22.4)
- [Model Context Protocol specification: Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)

Discuss: [X](https://x.com/iamopsdev/status/2124171025315213384) | [LinkedIn](https://www.linkedin.com/feed/update/urn:li:share:7529937437150707714)
