# ID-JAG erklärt: Wie KI-Agenten anwendungsübergreifenden Zugriff unter Unternehmenskontrolle erhalten

> Wie ID-JAG und Cross App Access dem Identity Provider eines Unternehmens erlauben, den Zugriff von KI-Agenten auf andere Apps zu genehmigen. Mit Lab-Bildern.

- URL: https://iamops.dev/de/id-jag-explained/
- Language: de
- Author: Argo
- Published: 2026-11-19
- Category: Labs
- Topics: ID-JAG, Cross App Access, KI-Agenten, OAuth, Standards

## Kurz gesagt

- ID-JAG ist ein vorgeschlagener IETF-Standard (Entwurf -06), mit dem der Identity Provider eines Unternehmens den Zugriff eines KI-Agenten auf eine andere App freigibt.
- Der Identity Provider stellt eine kurzlebige signierte Assertion aus; die andere App prüft sie und stellt ein eigenes kurzlebiges Access Token aus.
- Er ersetzt Einwilligungs-Pop-ups pro App und langlebige Schlüssel durch einen zentralen Ort für Richtlinien und Audit.
- Es ist noch ein Entwurf: Key Binding und Just-in-Time-Provisionierung könnten in eigene Dokumente wandern, und mehrere Produkte setzen ihn bereits um.
- Das Labor mit dem öffentlichen xaa.dev-Beispiel zeigt den Ablauf, mit geschwärzten Screenshots und einer Aufzeichnung.

Viele KI-Agenten müssen im Auftrag eines Nutzers auf mehrere Unternehmensanwendungen zugreifen. Heute löst jede Verbindung meist eine eigene Einwilligungsabfrage aus oder stützt sich auf einen langlebigen Schlüssel in den Einstellungen des Agenten. Beides lässt sich für eine Organisation nur schwer einsehen und steuern.

**ID-JAG** ist ein vorgeschlagener Standard, der diese Freigabe vom einzelnen Nutzer auf den Identity Provider der Organisation verlagert. Dieser Artikel erklärt, wie das funktioniert, wo die Spezifikation steht und was ein Lab-Durchlauf mit einer öffentlichen Beispielanwendung zeigt.

## Das Problem

Mitarbeitende melden sich per *Single Sign-on* einmal mit einem Konto an. Das System dahinter ist der *Identity Provider* des Unternehmens, hier „Unternehmens-Anmeldung“ genannt.

Dann muss ein KI-Agent Aufgaben in einer Anwendung lesen, Dateien in einer zweiten und einen Kalender in einer dritten. Jede dieser Anwendungen betreibt einen eigenen Autorisierungsserver, der den Agenten nicht kennt. In der Praxis funktioniert jede Verbindung auf eine von zwei Arten:

- **Eine Einwilligungsabfrage** pro Anwendung und Nutzer. Nutzer bestätigen oft, ohne zu lesen, und die Organisation hat keine zentrale Übersicht.
- **Ein langlebiger Schlüssel**, der in die Konfiguration des Agenten eingefügt wird. Er läuft nicht ab, und jeder, der ihn erlangt, kann ihn verwenden.

Die Alternative ist eine zentrale Stelle, die für Nutzer und Agent bürgt, die Regeln der Organisation anwendet und Protokoll führt.

## Was ein ID-JAG leistet

Der vollständige Name lautet *Identity Assertion JWT Authorization Grant*. Praktisch ist es eine **kurzlebige, signierte Zusicherung** der Unternehmens-Anmeldung. Sie besagt, dass die Organisation dieses Nutzers diesem Agenten erlaubt, bei jener Anwendung bestimmten Zugriff anzufordern.

Das darum herum gebaute Muster heißt informell **Cross App Access (XAA)**. Die Seite oauth.net dazu sagt, es „ersetzt den manuellen Genehmigungsschritt des Nutzers durch einen Token Exchange“.

![Die fünf Schritte eines ID-JAG-Ablaufs, von der einmaligen Anmeldung bis zur Nutzung eines kurzlebigen Access Tokens durch den Agenten.](https://iamops.dev/img/id-jag-flow.de.svg)

Der Ablauf in fünf Schritten:

1. Der Nutzer meldet sich einmal wie gewohnt bei der Arbeit an.
2. Der Agent fordert bei der Unternehmens-Anmeldung eine Zusicherung für eine bestimmte Anwendung an.
3. Die Unternehmens-Anmeldung prüft ihre Richtlinie. Ist die Verbindung erlaubt, stellt sie den ID-JAG aus.
4. Der Agent legt den ID-JAG dem Autorisierungsserver der anderen Anwendung vor. Dieser prüft die Signatur, wendet **seine eigenen** Regeln an und stellt ein kurzlebiges Access Token aus.
5. Der Agent ruft die Anwendung mit diesem Token auf.

Zwei Details sind wichtig. Die empfangende Anwendung entscheidet weiterhin selbst, was sie gewährt; der ID-JAG ist also kein Blankoscheck. Und weil die Unternehmens-Anmeldung in der Mitte steht, gibt es eine Stelle zum Festlegen der Richtlinien und eine zum Nachvollziehen, was geschehen ist.

Technisch verkettet das Verfahren zwei bestehende Standards: Token Exchange ([RFC 8693](https://iamops.dev/de/keycloak-token-exchange-rfc-8693/)) und den JWT Bearer Grant (RFC 7523).

## Lab: der Ablauf im xaa.dev-Beispiel

Der kostenlose **xaa.dev**-Playground des Entwicklerteams von Okta macht den Ablauf sichtbar. In einem Lab-Durchlauf am 7. November 2026 wurde die Beispielanwendung lokal in einer Testumgebung ausgeführt. Die App hat ein Panel „Behind the scenes“, das jede Stufe nach Abschluss markiert: Unternehmens-Anmeldung, ID-JAG, Access Token und die von der zweiten Anwendung abgerufene Checkliste. Zu keinem Zeitpunkt erschien eine Einwilligungsabfrage.

![Die xaa.dev-Beispiel-App mit der Onboarding-Checkliste links und dem Panel Behind the scenes rechts, in dem alle vier Stufen als abgeschlossen angezeigt werden.](https://iamops.dev/media/xaa/dashboard.webp)

*Überblick. Die Checkliste (links) wurde mit der Unternehmensidentität von der zweiten Anwendung abgerufen. Das Panel (rechts) listet die vier Stufen: Unternehmens-Anmeldung, ID-JAG, Access Token, Checkliste über MCP. Der Subject-Claim (sub) ist geschwärzt.*

**Stufe 2: die Zusicherung.** Nach der Unternehmens-Anmeldung tauscht das Beispiel das ID-Token des Nutzers gegen einen ID-JAG (RFC 8693). Das Aufklappen von Stufe 2 zeigt die dekodierte Zusicherung: Aussteller, Zielgruppe (den Autorisierungsserver der anderen Anwendung), angeforderte Ressource und Scope sowie Ausstellungs- und Ablaufzeit, die hier fünf Minuten auseinanderliegen. Kennungen, die auf eine Person oder einen Client verweisen, sind geschwärzt.

![Aufgeklappte Stufe 2 im Panel Behind the scenes: der dekodierte ID-JAG mit sichtbaren Angaben zu Aussteller, Zielgruppe, Ressource, Ausstellungs- und Ablaufzeit und Scope; Kennungen sind durch schwarze Balken abgedeckt.](https://iamops.dev/media/xaa/id-jag.webp)

*Stufe 2, der ID-JAG. Aussteller, Zielgruppe, Ressource, Gültigkeitsdauer und Scope sind sichtbar. Subject, Client und Token-Kennungen sind durch schwarze Balken abgedeckt, das kodierte Token wird nicht gezeigt.*

**Stufen 3 und 4: das Access Token.** Der Autorisierungsserver der anderen Anwendung prüft den ID-JAG (RFC 7523) und liefert ein Access Token mit begrenztem Scope zurück. Das Beispiel nutzt es anschließend, um die Checkliste über MCP abzurufen. Die Token-Claims zeigen, wer das Token ausgestellt hat, für welche Zielgruppe und mit welchem Scope.

![Aufgeklappter Abschnitt des Access Tokens; die Claims zeigen Aussteller, Zielgruppe und die Scopes todos.read und mcp.access, das kodierte Token und das Subject sind geschwärzt.](https://iamops.dev/media/xaa/access-token.webp)

*Stufen 3 und 4, das Access Token. Die Token-Claims (Aussteller, Zielgruppe, Scope) sind echt. Das kodierte Token und das Subject sind geschwärzt.*

Ich habe den ganzen Ablauf auf dem öffentlichen xaa.dev-Playground aufgezeichnet, mit der Beispiel-App in einer lokalen Testumgebung und einem synthetischen Nutzer. Die Aufnahme beginnt auf der Anmeldeseite. So sehen Sie jeden Schritt passieren und danach seinen dekodierten Header und Payload. Hinzugefügt ist nur die Untertitelleiste oben. Die Aufnahme ist stumm und dauert etwa eine Minute 44 Sekunden.

[Bildschirmaufzeichnung (1 Min. 44 s, ohne Ton, Untertitel verfügbar): Anmeldung beim IdP der Firma, danach jeder Schritt mit dekodiertem Header und Payload. Synthetischer Nutzer und kurzlebige Demo-Tokens aus dem öffentlichen Playground. Die kodierten Token-Strings sind fürs Layout gekürzt.](https://iamops.dev/media/xaa/idjag-flow.mp4)

### Was Sie hier sehen

1. **0:08 Anmeldung beim IdP der Firma.** Der Nutzer meldet sich auf idp.xaa.dev an, nicht in der Agent-App. Die App sieht nie ein Passwort, und beim IdP liegen MFA und Anmelderegeln. Der Playground nimmt beliebige sechs Ziffern als zweiten Faktor.
2. **0:30 Die Agent-App erhält ein ID-Token.** Es belegt, wer sich angemeldet hat. Achte auf <code>iss</code> (der IdP), <code>aud</code> (die Client-ID der App) und <code>exp</code>, eine Stunde nach <code>iat</code>. Die App hat jetzt eine Identität der Organisation, aber noch keinen Zugriff auf die Todo-App.
3. **0:47 Der IdP tauscht es gegen ein ID-JAG (RFC 8693).** Der Agent fragt eine Assertion für genau ein Ziel an. Der Header-Typ ist <code>oauth-id-jag+jwt</code>. Die Claims nennen in <code>aud</code> den Autorisierungsserver der Todo-App, dazu <code>resource</code>, <code>client_id</code> und <code>scope</code>. In einem echten Einsatz entscheidet hier die Policy des Administrators. Der Playground erlaubt es einfach.
4. **0:58 Das ID-JAG ist kurzlebig.** <code>exp</code> liegt 300 Sekunden nach <code>iat</code>. Ein abgeflossenes ID-JAG ist nach fünf Minuten wertlos und funktioniert nur bei dem Server, der in <code>aud</code> steht.
5. **1:07 Der eigene Autorisierungsserver der Todo-App stellt das Access Token aus (RFC 7523).** Der Agent legt ihm das ID-JAG vor. Der Server prüft die Signatur des IdP und wendet dann seine eigenen Regeln an. Im Token ist dieser Server <code>iss</code>, der MCP-Server <code>aud</code>, und es enthält nur den genehmigten <code>scope</code>. Der Nutzer wird im Namensraum der Todo-App identifiziert.
6. **1:30 Der Agent ruft die API auf.** Mit dem Access Token liest er die Checkliste über MCP. Die linke Seite der Seite ist genau diese Antwort. Ein Einwilligungsdialog erschien zu keinem Zeitpunkt.

*Das Lab nutzt ein öffentliches Beispiel mit Wegwerfkonten und Beispieldaten. Die Screenshots wurden vor der Veröffentlichung auf die Anwendung zugeschnitten und geschwärzt. Die Aufzeichnung zeigt die dekodierten Demo-Tokens vollständig, weil sie aus dem öffentlichen Playground stammen, zu einem synthetischen Nutzer gehören und innerhalb einer Stunde ablaufen. Die kodierten Token-Strings sind fürs Layout gekürzt.*

## Stand der Spezifikation

**Es ist weiterhin ein Entwurf, kein fertiger Standard.** Das Dokument heißt *draft-ietf-oauth-identity-assertion-authz-grant*, liegt inzwischen in Version **-06** vor und ist auf den 31. Oktober 2026 datiert. Es ist ein Dokument der IETF-Arbeitsgruppe OAuth, verfasst von Autoren von Okta und Ping Identity sowie einem unabhängigen Autor. Angestrebt ist ein Standards-Track-Dokument, doch Entwürfe können sich noch ändern.

**IETF 127, 18. November 2026.** Die Autoren stellten den Entwurf in der OAuth-Sitzung vor. Die Folien nennen drei offene Themen:

- **Just-in-Time-Provisioning**: wie eine Anwendung mit einem Nutzer umgeht, den sie noch nie gesehen hat, weil ihr erster Kontakt ein ID-JAG ist. Die Folien empfehlen, dies in einer künftigen Erweiterung zu behandeln.
- **Key Binding**: Tokens an einen kryptografischen Schlüssel zu binden, sodass ein gestohlenes Token wertlos ist. Die Folien fragen, ob es in eine eigene Erweiterung ausgelagert werden soll, und die Notizen halten eine Empfehlung für mehrere Folgeentwürfe fest. Ein Teilnehmer meinte, das Auslagern von Themen in andere Dokumente lasse den Entwurf unfertig wirken. Der Autor entgegnete, Provisioning sei optional und Key Binding gelte breiter als dieser Entwurf.
- **Gateways und Proxys**, die in KI-Umgebungen üblich sind, wenn ein Gateway zwischen Agent und Anwendungen sitzt. Das ist ein offenes Thema. Ein separater Entwurf ist vorgeschlagen, und laut den Notizen wünschen sich die Autoren zusätzliche („Interim“-)Treffen zu Gateways und Key Binding.

Die Notizen halten diese Punkte als **Empfehlungen** fest. Eine endgültige Entscheidung findet sich darin nicht. Als nächste Schritte nennen die Folien, die verbleibenden Punkte zu sichten, jeweils in Version -07 zu lösen oder bewusst zurückzustellen, und dann einen Working Group Last Call zu beantragen.

## Implementierungen

Mehrere Anbieter setzen ihn bereits um, obwohl der Entwurf nicht final ist. Laut der [Implementierungsliste auf oauth.net](https://oauth.net/cross-app-access/), geprüft am 19. November 2026:

- **Identity Provider, die ID-JAGs ausstellen**, sind unter anderem Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (als „in progress“ markiert) und weitere.
- **Autorisierungsserver, die sie akzeptieren**, sind unter anderem Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (Early Access), Stytch und WorkOS AuthKit (Early Access).
- **KI-Anwendungen und -Werkzeuge als Clients** sind unter anderem Claude, OpenAI Codex CLI und Visual Studio Code (Preview).
- **Anwendungen auf der Empfängerseite** sind unter anderem Asana, Atlassian, Linear, Notion und Slack, teils in der Beta.

Einige datierte Beispiele:

- **Oracle**: Am 9. Oktober 2026 veröffentlichte Oracle den ID-JAG-Token-Exchange in OCI IAM.
- **Gravitee**: Access Management 4.13, angekündigt am 12. November 2026, kann beide Rollen übernehmen, also ID-JAGs ausstellen und akzeptieren.
- **Okta**: Am 13. November 2026 kündigte Okta die allgemeine Verfügbarkeit der Unterstützung für Identity Provider von Drittanbietern an und nennt Ping, Descope und Oracle als XAA-fähige Anbieter, mit deren Nutzern und Agenten es zusammenarbeiten kann.
- **MCP**: Das Model Context Protocol, eine verbreitete Methode, KI-Werkzeuge mit Anwendungen zu verbinden, hat eine Erweiterung „Enterprise-Managed Authorization“, die einen ID-JAG verwendet. Der Projektblog kündigte sie im Juni 2026 als stabil an.

Microsoft Entra stand zum Zeitpunkt der Prüfung nicht auf der Liste von oauth.net.

## Unterschied zu Einwilligungsdialogen und On-Behalf-of

| | Einwilligungsabfrage | On-Behalf-of (OBO) | ID-JAG / XAA |
| --- | --- | --- | --- |
| **Wer genehmigt** | Der Nutzer, Anwendung für Anwendung | Die frühere Einwilligung des Nutzers, weitergereicht | Die Unternehmens-Anmeldung nach Regeln eines Administrators |
| **Was der Nutzer sieht** | Eine Abfrage pro Anwendung | Meist nichts nach der ersten Anmeldung | Nichts |
| **Wo es funktioniert** | Überall, wo OAuth funktioniert | Ein Dienst ruft einen anderen auf, innerhalb eines Identitätssystems | Zwischen Anwendungen und Organisationen mit jeweils eigenem Autorisierungsserver |
| **Zentrale Kontrolle** | Begrenzt | Teilweise | Zweck des Designs |

**Im Vergleich zu Einwilligungsdialogen:** Eine Einwilligungsabfrage fragt den Nutzer jedes Mal. Ein ID-JAG wendet die Regeln der Organisation einmal an und setzt sie dann unauffällig durch.

**Im Vergleich zu [On-Behalf-of](https://iamops.dev/de/entra-on-behalf-of-agent-middle-tier/):** Microsofts Dokumentation beschreibt OBO als eine Web-API, die die Identität eines Nutzers verwendet, um eine andere API aufzurufen, und Identität und Berechtigungen des Nutzers entlang der Kette weitergibt. Das geschieht innerhalb der Microsoft-Identitätsplattform. Der ID-JAG löst ein verwandtes Problem über Grenzen hinweg: Die beiden Anwendungen haben unterschiedliche Autorisierungsserver, und eine dritte Partei, die Unternehmens-Anmeldung, bürgt für den Nutzer. Aus Nutzersicht wirken beide ähnlich, das Vertrauen ist jedoch anders aufgebaut.

## Eine Überlegung

Weniger Abfragen bedeuten mehr Komfort, aber auch weniger Momente, in denen eine Person die Anfrage prüft. Das ist eine Einschätzung, keine Aussage des Standards: Das Design hilft nur, wenn die Richtlinien der Organisation solide sind und regelmäßig überprüft werden. Der ID-JAG macht es **möglich**, Agentenzugriffe an einer Stelle zu sehen und zu steuern. Steuern muss weiterhin jemand.

Dieser Artikel wird aktualisiert, sobald der Entwurf auf den Working Group Last Call zugeht.

## Dieses Lab nachbauen

Sie brauchen nur Node.js 20 oder neuer, git und einen Browser. Sie registrieren eine kostenlose App bei xaa.dev, starten Oktas TypeScript-Beispiel lokal und lesen ID-JAG und Access Token im Panel Behind the scenes. Etwa 20 Minuten. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie mit dem, was ich gesehen habe.

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
# Values from the xaa.dev registration dialog. Replace each <PLACEHOLDER>; the endpoints below are the public defaults.
export XAA_CLIENT_ID='<APP_CLIENT_ID>'
export XAA_CLIENT_SECRET='<APP_CLIENT_SECRET>'
export EXCHANGE_CLIENT_ID='<EXCHANGE_CLIENT_ID>'          # leave empty if the dialog shows the same pair as above
export EXCHANGE_CLIENT_SECRET='<EXCHANGE_CLIENT_SECRET>'
export MCP_CLIENT_ID='<RESOURCE_CLIENT_ID>'               # the id that ends in -at-todo0-mcp
export MCP_CLIENT_SECRET='<RESOURCE_CLIENT_SECRET>'
export IDP_BASE_URL='https://idp.xaa.dev'
export AUTH_SERVER_URL='https://auth.resource.xaa.dev'
export MCP_SERVER_URL='https://mcp.xaa.dev/mcp'
export PORT='3001'
export BASE_URL='http://localhost:3001'
export XAA_SCOPE='todos.read mcp.access'
```

### Schritt 1: Eine Requesting App bei xaa.dev registrieren

**Ziel.** Registrieren Sie das Beispiel als Requesting App mit genau dem lokalen Redirect-URI und verbinden Sie es mit der Ressource Todo MCP server.

**Voraussetzungen**

- Ein Browser; xaa.dev ist ein öffentlicher Playground mit Wegwerfdaten

`xaa-registration.txt` (text)

```text
1. Open https://xaa.dev/developer/register and enter any email address (it only filters which apps you see; no account is created).
2. Select + Register New App.
   Application Name:   Onboarding App - Local Dev
   Redirect URIs:      http://localhost:3001/callback      (exact match: scheme, host, port, path)
   Connect to Resource: Todo MCP server (todo0-mcp), keep the scopes todos.read and mcp.access
3. Save the credentials from the confirmation dialog. There are two OAuth clients:
   - main client (client_id / client_secret): sign-in and token exchange at the IdP
   - resource client (the id ends in -at-todo0-mcp): the JWT bearer grant at the resource's authorization server
4. Put them into env.sh. Do not mix the two pairs up: that is the most common mistake.
```

**Erwartete Ausgabe**

```text
Credential dialog shows two pairs:
  client_id           <APP_CLIENT_ID>
  resource_client_id  <RESOURCE_CLIENT_ID>   (ends in -at-todo0-mcp)
```

### Schritt 2: Das Beispiel holen und installieren

**Ziel.** Klonen Sie Oktas TypeScript-Beispiel auf Basis des MCP-SDK und installieren Sie die Abhängigkeiten.

**Voraussetzungen**

- Node.js 20 oder neuer und git
- Port 3001 frei

`install.sh` (bash)

```bash
node --version
git clone https://github.com/oktadev/okta-xaa-typescript-mcp-sdk-example.git
cd okta-xaa-typescript-mcp-sdk-example
npm install
```

**Erwartete Ausgabe**

```text
v20.x.x
Cloning into 'okta-xaa-typescript-mcp-sdk-example'...
added <n> packages in <n>s
```

### Schritt 3: Die Zugangsdaten setzen

**Ziel.** Laden Sie env.sh und prüfen Sie, dass kein benötigter Wert leer ist. Die App liest sie aus der Umgebung, es gibt also keine .env-Datei, die Sie versehentlich committen könnten.

**Voraussetzungen**

- Die Zugangsdaten aus dem Registrierungsschritt in env.sh
- Das Terminal steht im geklonten Ordner

`check-env.sh` (bash)

```bash
. ./env.sh   # adjust the path if you saved env.sh elsewhere
for v in XAA_CLIENT_ID XAA_CLIENT_SECRET MCP_CLIENT_ID MCP_CLIENT_SECRET IDP_BASE_URL AUTH_SERVER_URL MCP_SERVER_URL BASE_URL XAA_SCOPE; do
  [ -n "${!v}" ] && echo "ok       $v" || echo "MISSING  $v"
done
```

**Erwartete Ausgabe**

```text
ok       XAA_CLIENT_ID
ok       XAA_CLIENT_SECRET
ok       MCP_CLIENT_ID
ok       MCP_CLIENT_SECRET
ok       IDP_BASE_URL
ok       AUTH_SERVER_URL
ok       MCP_SERVER_URL
ok       BASE_URL
ok       XAA_SCOPE
```

### Schritt 4: Die App starten und anmelden

**Ziel.** Starten Sie die App und melden Sie sich mit dem Company SSO an. Der Demo-Identity-Provider akzeptiert jede E-Mail-Adresse, echte Zugangsdaten sind nicht nötig.

**Voraussetzungen**

- Die Variablen aus env.sh sind in diesem Terminal gesetzt

`start.sh` (bash)

```bash
npm start   # keep it running, then open http://localhost:3001 and select "Sign in with company SSO"
```

`check-port.sh` (bash)

```bash
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3001/   # from a second terminal
```

**Erwartete Ausgabe**

```text
╔════════════════════════════════════════════════════╗
║     Employee Onboarding (XAA · xaa.dev demo)        ║
╚════════════════════════════════════════════════════╝
  App:          http://localhost:3001
  IdP:          https://idp.xaa.dev
  Auth server:  https://auth.resource.xaa.dev
  MCP server:   https://mcp.xaa.dev/mcp
[login] logged in as <your-demo-email>
200
```

### Schritt 5: ID-JAG und Access Token lesen

**Ziel.** Klappen Sie jede Karte im Panel Behind the scenes auf und prüfen Sie drei Dinge in den dekodierten Tokens.

**Voraussetzungen**

- Das Dashboard zeigt alle vier Schritte als abgeschlossen

`checks.txt` (text)

```text
Stage 2, ID-JAG:
  header typ  = oauth-id-jag+jwt
  aud         = https://auth.resource.xaa.dev     (the resource's authorization server)
  resource    = https://mcp.xaa.dev/mcp
  scope       = todos.read mcp.access
  exp - iat   = 300 seconds

Stage 3, access token:
  scope       contains todos.read and mcp.access
  aud         = the ID-JAG's resource, byte for byte
```

**Erwartete Ausgabe**

```text
ID-JAG aud is the authorization server:           yes
ID-JAG resource is the MCP server:                yes
access token scope has todos.read and mcp.access: yes
access token aud equals ID-JAG resource:          yes
```

### Schritt 6: Aufräumen

**Ziel.** Stoppen Sie die App, löschen Sie den Klon und die Variablen und löschen Sie die registrierte App bei xaa.dev.

**Voraussetzungen**

- Nichts anderes nutzt Port 3001

`cleanup.sh` (bash)

```bash
# Stop the app: Ctrl+C in its terminal, or:
pkill -f "tsx.*src/server.ts" || true
cd .. && rm -rf okta-xaa-typescript-mcp-sdk-example
unset XAA_CLIENT_ID XAA_CLIENT_SECRET EXCHANGE_CLIENT_ID EXCHANGE_CLIENT_SECRET MCP_CLIENT_ID MCP_CLIENT_SECRET
# Then delete the app on https://xaa.dev/developer/register (select it, then delete).
# check: nothing listens on port 3001 any more
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3001/
```

**Erwartete Ausgabe**

```text
000
```


## Sources

- [IETF draft-ietf-oauth-identity-assertion-authz-grant-06 (Identity Assertion JWT Authorization Grant)](https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-assertion-authz-grant/)
- [IETF 127 OAuth session slides: Identity Assertion Authorization Grant](https://datatracker.ietf.org/meeting/127/materials/slides-127-oauth-sessa-identity-assertion-jwt-authorization-grant-00)
- [IETF 127 OAuth working group session notes](https://notes.ietf.org/notes-ietf-127-oauth)
- [oauth.net: Cross-App Access, with the list of implementations](https://oauth.net/cross-app-access/)
- [Okta Developer: Cross App Access (XAA) concepts](https://developer.okta.com/docs/concepts/xaa/)
- [Okta press release, 13 Nov 2026: third-party identity providers in Okta for AI Agents](https://www.okta.com/newsroom/press-releases/okta-for-ai-agents-now-works-out-of-the-box-with-multiple-third-party-identity-providers/)
- [Oracle OCI IAM release note, 9 Oct 2026: ID-JAG token exchange across trust domains](https://docs.oracle.com/en-us/iaas/releasenotes/identity/id-jag-token-exchange-across-trust-domains.htm)
- [Gravitee blog, 12 Nov 2026: Cross App Access in Access Management 4.13](https://www.gravitee.io/blog/single-sign-on-ai-agents-cross-app-access)
- [Model Context Protocol blog: Enterprise-Managed Authorization](https://blog.modelcontextprotocol.io/posts/enterprise-managed-auth/)
- [Microsoft Learn: the on-behalf-of flow](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-on-behalf-of-flow)
- [xaa.dev, the free Cross App Access playground](https://xaa.dev)
- [Video: See How Cross App Access (XAA) Works (OktaDev, 7:45)](https://www.youtube.com/watch?v=O_QGg1RR56c)
