# OPA derrière AuthZEN : un point de décision pour les appels d'outils MCP

> J'ai écrit une politique Rego pour les outils MCP, testée sur OPA 1.22.4, avec un point AuthZEN devant. Un paiement de 90 $ au-delà de 50 $ est refusé.

- URL: https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/
- Language: fr
- Author: Argo
- Published: 2026-11-11
- Category: Labs
- Depth: Pratique
- Time: 20 minutes
- Topics: OPA, AuthZEN, MCP, Autorisation, agents IA

## En bref

- Le 11 novembre 2026, [IndyKite](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#ce-que-construit-le-lab) et Obsidian ont décrit la même structure : l'agent ou son runtime propose un appel, et un [point de décision](https://iamops.dev/fr/authzen-opa-cedar-explained/#ce-que-authzen-normalise) séparé répond pour chaque appel.
- Je l'ai construite en local : une politique [Rego](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#la-politique) dans [OPA 1.22.4](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#une-requête-hors-ligne), six tests unitaires et un petit point d'accès [AuthZEN](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#le-point-daccès-authzen) Access Evaluation devant OPA. Un paiement de 90 $ contre une limite de 50 $ est revenu avec decision false et le motif over delegated limit.
- La politique [refuse par défaut](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#la-politique). Un [outil inconnu](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#dautres-refus-et-opa-qui-disparaît), un scope manquant, un paiement au-delà de la limite et un paiement non confirmé ont été refusés, et j'ai cassé une règle exprès pour voir un test échouer.
- Quand j'ai arrêté [OPA](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#dautres-refus-et-opa-qui-disparaît), mon shim n'a donné aucune réponse ; le point d'application doit donc traiter une [décision absente](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#dautres-refus-et-opa-qui-disparaît) comme un refus.
- [Non testés](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/#ce-que-je-nai-pas-testé) : une vraie passerelle MCP comme point d'application, les tests de conformité [AuthZEN](https://iamops.dev/fr/authzen-opa-cedar-explained/#ce-que-authzen-normalise), les API batch et de recherche et la journalisation des décisions.

Le 11 novembre 2026, deux éditeurs ont publié la même idée de deux côtés. IndyKite a publié son Intent Agent, qui transforme un prompt en évaluations [AuthZEN](https://openid.net/specs/authorization-api-1_0-final.html) et, selon son [guide développeur](https://developer.indykite.com/guides/guide-intent-agent), ne décide rien : la décision reste au service AuthZEN. Obsidian a décrit un [Runtime Policy Decision Engine](https://www.obsidiansecurity.com/blog/runtime-policy-decision-engine) où un MCP Security Proxy, un runtime d'agents ou une passerelle client met un appel d'outil en pause, demande une décision et applique la réponse.

Les deux partagent le travail de la même façon. Quelque chose qui tient la requête demande, et autre chose décide. Je voulais faire tourner ce partage sur ma propre machine avec uniquement des briques open source, alors je l'ai construit : un moteur de politiques (OPA) avec une politique pour les appels d'outils MCP, et un fin point d'accès AuthZEN devant.

J'ai écrit une courte [présentation d'AuthZEN, OPA et Cedar](https://iamops.dev/fr/authzen-opa-cedar-explained/).

## Ce que construit le lab

- Une politique Rego qui reçoit une requête au format AuthZEN (subject, action, resource, context) pour un `tools/call` MCP et renvoie un booléen plus des motifs.
- Six tests unitaires qui tournent hors ligne avec l'exécuteur de tests d'OPA.
- Un petit point d'accès Python qui répond à `POST /access/v1/evaluation` et au document de métadonnées du PDP, et transmet la requête à OPA comme input.
- Deux refus que je voulais voir : un paiement au-delà de la limite déléguée à l'agent, et ce qui se passe quand OPA n'est pas là.

L'argent est en centimes de dollar américain. L'agent peut payer jusqu'à 5000 centimes, soit 50 $.

![Diagramme de séquence : un appelant envoie une évaluation AuthZEN pour un tools/call MCP à un petit endpoint, qui la transmet à OPA 1.22.4. Un paiement de 9000 cents pour une limite de 5000 est refusé avec la raison over delegated limit, 4500 cents est autorisé, d'autres appels erronés sont refusés avec des raisons, et un OPA arrêté ne donne aucune réponse HTTP.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/00-flow.webp)

*La décision. La requête nomme l'agent, le tools/call, l'outil, le montant et la confirmation. 9000 cents pour une limite de 5000 reviennent en decision false avec la raison over delegated limit. 4500 cents avec confirmation est autorisé. Un scope manquant, l'absence de confirmation ou un outil inconnu sont refusés avec des raisons. Si OPA est arrêté, le endpoint ne donne aucune réponse HTTP.*

## Mise en place

OPA 1.22.4 est un binaire statique unique de la [page des versions](https://github.com/open-policy-agent/opa/releases/tag/v1.22.4). Le point d'accès est un fichier de moins de 40 lignes de Python 3.13 avec la seule bibliothèque standard. Il faut aussi curl et jq. Il n'y a ni Docker, ni base de données, ni compte. Le lab ouvre le port 8181 pour OPA et le 8282 pour le point d'accès, tous deux sur localhost.

## La politique

La requête est celle qu'un point d'application construirait à partir d'un [`tools/call`](https://modelcontextprotocol.io/specification/2026-07-28/server/tools) MCP. Le subject est l'agent avec ses scopes et sa limite, la resource est l'outil, et le context porte le montant et si l'utilisateur a confirmé.

La politique a un catalogue d'outils qui dit quel scope chacun exige et s'il déplace de l'argent. `decision` vaut `false` tant qu'une règle ne la met pas à `true`. Les outils de lecture exigent leur scope. Un outil qui déplace de l'argent exige le scope, un montant au plus égal à la limite et une confirmation :

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

Un second ensemble, `reasons`, explique les refus. Les fichiers complets figurent dans les étapes du lab plus bas.

## D'abord les tests

L'exécuteur `opa test` trouve les règles `test_` dans les fichiers `_test.rego`. J'en ai écrit six : une lecture est autorisée, une écriture sans le scope est refusée, un paiement confirmé dans la limite est autorisé, un paiement au-delà de la limite est refusé avec le bon motif, un paiement non confirmé est refusé, et un outil inconnu est refusé. `opa check --strict` et `opa fmt` sont passés avant les tests.

![Sortie de terminal d'OPA 1.22.4 : informations de version, fmt et vérification stricte réussis, et six tests unitaires en PASS avec le résumé 6 sur 6.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/02-tests.webp)

*Vérifications et tests. La vérification de format, la vérification stricte et les six tests passent sur OPA 1.22.4.*

Pour voir si les tests peuvent échouer, j'ai supprimé dans une copie la ligne `user_confirmed` de la deuxième règle. Cinq tests ont continué à passer et `test_payment_needs_confirmation` a échoué. C'est le test qui fait son travail.

## Une requête, hors ligne

`opa eval` prend la politique et un fichier de requête sans démarrer de serveur. La requête est l'agent `support-bot` avec les deux scopes et une limite de 5000 centimes, qui appelle `send_payment` pour 9000 centimes avec la confirmation de l'utilisateur.

![Sortie de terminal de deux commandes opa eval : la décision est false et l'ensemble des motifs contient over delegated limit.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/03-eval.webp)

*Un paiement de 90 $ contre une limite de 50 $. La décision est false et le motif est « over delegated limit ».*

## Le point d'accès AuthZEN

OPA tourne en serveur sur le port 8181, et le point d'accès sur le port 8282 se place devant. La [spécification AuthZEN](https://openid.net/specs/authorization-api-1_0-final.html) définit la requête comme subject, action, resource et context, et la réponse comme un `decision` booléen obligatoire avec un `context` facultatif. Elle laisse le contenu de ce context à l'implémentation. J'ai mis les motifs de refus sous `reason_admin`, la clé de son exemple non normatif. Le document de métadonnées se trouve à `/.well-known/authzen-configuration`.

![Sortie de terminal : le document de métadonnées du PDP avec deux URL, un refus avec decision false et le motif over delegated limit, et une autorisation avec decision true après avoir changé le montant à 4500 centimes.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/04-authzen.webp)

*La même requête via AuthZEN. 9000 centimes sont refusés avec un motif. En changeant seulement le montant à 4500 centimes, on obtient decision true.*

Le point d'accès est un outil pédagogique. Il n'authentifie pas les appelants, ne valide pas l'entrée et n'a ni API batch ni API de recherche ; ce n'est donc pas un PDP conforme.

## D'autres refus, et OPA qui disparaît

J'ai envoyé trois autres requêtes avec une petite fonction shell nommée `ask`. Avec le seul scope de lecture, le paiement a été refusé pour scope manquant, et aussi pour la limite, car le montant valait encore 9000. Avec un montant de 4500 centimes et `user_confirmed` à false, il a été refusé pour confirmation manquante. Un outil nommé `delete_account` a été refusé comme inconnu.

![Sortie de terminal de trois requêtes refusées avec les motifs missing scope et over delegated limit, user did not confirm et unknown tool, suivies d'une requête après l'arrêt d'OPA qui renvoie le statut HTTP 000.](https://iamops.dev/media/opa-authzen-mcp-tool-call-policy/05-denials.webp)

*Trois autres refus. Chacun arrive avec ses motifs. Après l'arrêt d'OPA, la requête ne reçoit aucune réponse HTTP, que curl affiche comme 000.*

Ensuite j'ai arrêté OPA et renvoyé la requête de 4500 centimes. Le shim a levé une exception et coupé la connexion, et curl a affiché `000`. Il n'y avait aucun `decision: false` à appliquer. Une passerelle qui attend un true peut traiter cela comme un refus. Une passerelle qui ne bloque que sur un false explicite laisserait passer l'appel. Je n'ai pas testé de vraie passerelle ; c'est donc une raison de vérifier la vôtre, pas un constat sur un produit.

## Pièges

- **Les outils inconnus n'ont pas besoin de règle.** Quand l'outil n'est pas dans le catalogue, `tool` est indéfini, donc chaque règle `decision` est indéfinie et la valeur par défaut `false` s'applique. Un test le fixe.
- **Les motifs peuvent s'empiler.** `reasons` est un ensemble, et la requête avec le seul scope de lecture en a renvoyé deux à la fois.
- **La politique fait confiance au context.** `user_confirmed` ne vaut que ce que vaut le point d'application qui le renseigne. Un modèle ne doit jamais pouvoir le remplir. Le guide d'IndyKite dit quelque chose de proche pour le subject : il vient de l'identité vérifiée de l'appelant, jamais du texte du prompt.
- **Refuser par défaut est un choix.** Le billet d'Obsidian dit que les appels d'outils qui ne correspondent à aucune politique passent. Les miens sont refusés. Aucun des deux n'est faux, mais décidez-le exprès.

## Ce que je ferais de cela

1. Placer le point d'application dans la passerelle ou le proxy qui voit chaque `tools/call`, pas dans l'agent.
2. Construire le subject à partir du jeton vérifié et de l'enregistrement de délégation, pas à partir de ce que le modèle a écrit.
3. Garder la politique dans un dépôt avec ses tests et lancer `opa test` en CI.
4. Faire refuser le point d'application en cas d'erreur, et le tester en arrêtant le point de décision.

## Ce que je n'ai pas testé

Je n'ai pas testé de vraie passerelle MCP comme point d'application. Je n'ai pas lancé de tests de conformité AuthZEN, l'API d'évaluations batch, les API de recherche ni un autre point de décision AuthZEN. Je n'ai pas testé les bundles OPA, les journaux de décisions ni les performances des politiques. Il n'y a pas d'enregistrement pour ce lab. Le lab n'utilise ni identifiants ni jetons.

*Les images de terminal ont été générées à partir de la sortie enregistrée de l'exécution du 20 novembre 2026.*

## Refaire ce lab

Ce lab demande Linux sur amd64, curl, jq et Python 3.13. Comptez environ 20 minutes. Ouvrez chaque étape, copiez les blocs et comparez la sortie avec la mienne.

Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.

**Définissez vos variables une seule fois** `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"
```

### Étape 1: Télécharger OPA

**Objectif.** Téléchargez le binaire statique unique d’OPA à une version figée et affichez sa version.

**Prérequis**

- Linux sur amd64 (pour macOS ou arm64, prenez le fichier correspondant sur la page des versions), curl, jq et Python 3.13
- Ports 8181 et 8282 libres

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

**Résultat attendu**

```text
Version: 1.22.4
```

### Étape 2: Écrire la politique

**Objectif.** Créez la politique Rego : un catalogue d’outils, une valeur par défaut false, deux règles de décision et un ensemble de motifs de refus.

**Prérequis**

- Étape 1 faite, dans le même dossier

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

**Résultat attendu**

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

### Étape 3: Écrire les tests et les exécuter

**Objectif.** Écrivez six tests unitaires, puis lancez le formateur, la vérification stricte et l’exécuteur de tests. Tout doit passer.

**Prérequis**

- Le fichier de politique de l’étape précédente

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

**Résultat attendu**

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

### Étape 4: Évaluer une requête hors ligne

**Objectif.** Écrivez une requête au format AuthZEN pour un paiement de 90 dollars avec une limite de 50 dollars et évaluez-la avec opa eval, sans serveur.

**Prérequis**

- Les montants sont en centimes : 9000 font 90 dollars et 5000 font 50 dollars

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

**Résultat attendu**

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

### Étape 5: Lancer OPA en serveur et ajouter le point AuthZEN

**Objectif.** Servez la politique depuis OPA sur le port 8181, vérifiez son API de décision, puis démarrez le petit point Python sur le port 8282 et lisez son document de métadonnées.

**Prérequis**

- Étapes 2 à 4 faites
- Le point d’accès est un outil pédagogique, pas un PDP AuthZEN conforme ; gardez-le sur 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 .
```

**Résultat attendu**

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

### Étape 6: Demander une décision : 90 dollars, puis 45

**Objectif.** Envoyez la requête au point d’évaluation AuthZEN. Il doit refuser avec un motif. Puis changez seulement le montant à 4500 centimes et redemandez.

**Prérequis**

- OPA et le point d’accès tournent

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

**Résultat attendu**

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

### Étape 7: Essayer d’autres refus, puis arrêter OPA

**Objectif.** Envoyez trois autres requêtes : un scope manquant, un paiement non confirmé et un outil inconnu. Arrêtez ensuite OPA et redemandez pour voir qu’aucune décision ne revient.

**Prérequis**

- Le point d’accès tourne

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

**Résultat attendu**

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

### Étape 8: Nettoyage

**Objectif.** Arrêtez les deux processus et supprimez les fichiers créés par le lab.

**Prérequis**

- Rien d’autre n’utilise les ports 8181 et 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/"
```

**Résultat attendu**

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