In breve
- ID-JAG è uno standard IETF proposto (bozza -06) che permette all'identity provider di un'azienda di approvare l'accesso di un agente AI a un'altra app.
- L'identity provider emette un'asserzione firmata e di breve durata; l'altra app la verifica ed emette un proprio access token di breve durata.
- Sostituisce i pop-up di consenso per ogni app e le chiavi di lunga durata con un unico punto per policy e audit.
- È ancora una bozza: key binding e provisioning just-in-time potrebbero passare a documenti separati, e diversi prodotti la implementano già.
- Il laboratorio sull'esempio pubblico xaa.dev mostra il flusso, con screenshot oscurati e una registrazione.
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: ID-JAG spiegato: come gli agenti AI ottengono l'accesso tra applicazioni sotto il controllo aziendale Read the whole lab here (Markdown): https://iamops.dev/it/id-jag-explained.md What the lab needs before the first step: - A browser; xaa.dev is a public playground with throwaway data - Values I have to set myself (the lab uses placeholders): <APP_CLIENT_ID>, <APP_CLIENT_SECRET>, <EXCHANGE_CLIENT_ID>, <EXCHANGE_CLIENT_SECRET>, <RESOURCE_CLIENT_ID>, <RESOURCE_CLIENT_SECRET> 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.
Molti agenti AI devono accedere a più applicazioni aziendali per conto di un utente. Oggi ogni collegamento richiede di solito una propria richiesta di consenso, oppure si affida a una chiave di lunga durata salvata nelle impostazioni dell’agente. In entrambi i casi per un’organizzazione è difficile vedere e controllare cosa accade.
ID-JAG è uno standard proposto che sposta questa approvazione dal singolo utente all’identity provider dell’organizzazione. L’articolo spiega come funziona, a che punto è la specifica e cosa mostra una prova di laboratorio con un’applicazione di esempio pubblica.
Il problema#
I dipendenti accedono una sola volta, con un solo account, tramite il single sign-on. Il sistema che lo gestisce è l’identity provider aziendale, chiamato qui “accesso aziendale”.
Poi un agente AI deve leggere le attività in un’applicazione, i file in un’altra e il calendario in una terza. Ognuna di queste applicazioni ha un proprio server di autorizzazione, che non sa nulla dell’agente. In pratica ogni collegamento funziona in uno di due modi:
- Una richiesta di consenso per ogni applicazione e ogni utente. Gli utenti tendono ad approvare senza leggere e l’organizzazione non ha un registro centrale.
- Una chiave di lunga durata incollata nella configurazione dell’agente. Non scade e chiunque la ottenga può usarla.
L’alternativa è un unico punto che garantisce per l’utente e per l’agente, applica le regole dell’organizzazione e conserva una traccia.
Cosa fa un ID-JAG#
Il nome completo è Identity Assertion JWT Authorization Grant. In pratica è un’asserzione firmata e di breve durata emessa dall’accesso aziendale. Afferma che l’organizzazione di questo utente consente a questo agente di richiedere a quell’applicazione un accesso specifico.
Il modello costruito attorno a questo meccanismo è chiamato informalmente Cross App Access (XAA). La pagina di oauth.net lo descrive come un modo che “sostituisce il passaggio di approvazione manuale dell’utente con uno scambio di token” (token exchange).
Il flusso in cinque passaggi:
- L’utente accede al lavoro una sola volta, nel modo consueto.
- L’agente chiede all’accesso aziendale un’asserzione valida per una determinata applicazione.
- L’accesso aziendale valuta la propria policy. Se il collegamento è consentito, emette l’ID-JAG.
- L’agente presenta l’ID-JAG al server di autorizzazione dell’altra applicazione. Quel server verifica la firma, applica le proprie regole ed emette un access token di breve durata.
- L’agente usa quel token per chiamare l’applicazione.
Due dettagli contano. L’applicazione ricevente decide comunque cosa concedere, quindi l’ID-JAG non è un assegno in bianco. E poiché l’accesso aziendale sta in mezzo, esiste un solo punto in cui definire le policy e un solo punto in cui verificare cosa è successo.
Dal punto di vista tecnico concatena due standard esistenti: il token exchange (RFC 8693) e il JWT bearer grant (RFC 7523).
Laboratorio: il flusso nell’esempio di xaa.dev#
Il playground gratuito xaa.dev del team sviluppatori di Okta rende visibile il flusso. In una prova di laboratorio del 7 novembre 2026 la sua applicazione di esempio è stata eseguita in locale in un ambiente di test. L’app ha un pannello “Behind the scenes” che segna ogni fase al suo completamento: accesso aziendale, ID-JAG, access token e checklist recuperata dalla seconda applicazione. In nessun momento è comparsa una richiesta di consenso.

Fase 2: l’asserzione. Dopo l’accesso aziendale, l’esempio scambia l’ID token dell’utente con un ID-JAG (RFC 8693). Espandendo la fase 2 si vede l’asserzione decodificata: l’emittente, il destinatario (il server di autorizzazione dell’altra applicazione), la risorsa e lo scope richiesti, e gli orari di emissione e scadenza, che qui distano cinque minuti. Gli identificativi riferibili a una persona o a un client sono oscurati.

Fasi 3 e 4: l’access token. Il server di autorizzazione dell’altra applicazione verifica l’ID-JAG (RFC 7523) e restituisce un access token con scope limitato. L’esempio lo usa poi per recuperare la checklist tramite MCP. I claim del token mostrano chi lo ha emesso, per quale destinatario e con quale scope.

Ho registrato l’intero flusso sul playground pubblico xaa.dev, usando l’app di esempio in un ambiente di test locale con un utente sintetico. Si parte dalla pagina di accesso, così vedi ogni passaggio avvenire e poi il suo header e payload decodificati. L’unica aggiunta è la barra dei sottotitoli in alto. È senza audio e dura circa un minuto e 44 secondi.
Cosa stai vedendo#
- 0:08 Accesso presso l’IdP aziendale. L’utente accede su idp.xaa.dev, non nell’app dell’agente. L’app non vede mai una password, e l’IdP è il posto dove vivono MFA e regole di accesso. Il playground accetta sei cifre qualsiasi come secondo fattore.
- 0:30 L’app dell’agente riceve un ID token. Dimostra chi ha effettuato l’accesso. Guarda
iss(l’IdP),aud(il client ID dell’app) edexp, un’ora dopoiat. L’app ha ora un’identità dell’organizzazione, ma ancora nessun accesso all’app todo. - 0:47 L’IdP lo scambia con un ID-JAG (RFC 8693). L’agente chiede un’asserzione destinata a un solo bersaglio. Il tipo nell’header è
oauth-id-jag+jwt. I claim indicano inaudil server di autorizzazione dell’app todo, piùresource,client_idescope. In una distribuzione reale è qui che decide la policy dell’amministratore. Il playground la consente e basta. - 0:58 L’ID-JAG ha vita breve.
exparriva 300 secondi dopoiat. Un ID-JAG trapelato è inutile dopo cinque minuti e funziona solo sul server indicato inaud. - 1:07 Il server di autorizzazione dell’app todo emette l’access token (RFC 7523). L’agente gli presenta l’ID-JAG. Quel server verifica la firma dell’IdP, poi applica le proprie regole. Il token ha quel server come
iss, il server MCP comeaude solo loscopeapprovato. L’utente è identificato nello spazio dei nomi dell’app todo. - 1:30 L’agente chiama l’API. Con l’access token legge la checklist via MCP. La parte sinistra della pagina è quella risposta. In nessun momento è comparsa una schermata di consenso.
Il laboratorio usa un esempio pubblico con account temporanei e dati di prova. Le schermate sono state ritagliate sull’applicazione e oscurate prima della pubblicazione. La registrazione mostra i token dimostrativi decodificati per intero, perché provengono dal playground pubblico, appartengono a un utente sintetico e scadono entro un’ora. Le stringhe dei token codificati sono accorciate per l’impaginazione.
A che punto è la specifica#
È ancora una bozza, non uno standard definitivo. Il documento è draft-ietf-oauth-identity-assertion-authz-grant, ora alla versione -06, datata 31 ottobre 2026. È un documento del gruppo di lavoro OAuth dell’IETF, scritto da autori di Okta e Ping Identity e da un autore indipendente. L’esito previsto è un documento Standards Track, ma le bozze possono ancora cambiare.
IETF 127, 18 novembre 2026. Gli autori hanno presentato la bozza alla sessione OAuth. Le slide indicano tre temi aperti:
- Just-in-time provisioning, cioè come un’applicazione tratta un utente che non ha mai visto, perché il suo primo contatto è un ID-JAG. Le slide raccomandano di affrontarlo in una futura estensione.
- Key binding, cioè vincolare i token a una chiave crittografica in modo che un token rubato sia inutilizzabile. Le slide chiedono se spostarlo in un’estensione a sé e gli appunti registrano una raccomandazione per più bozze successive. Un partecipante ha osservato che spostare argomenti in altri documenti lascia la bozza con un’aria incompleta. L’autore ha risposto che il provisioning è facoltativo e che il key binding ha un’applicabilità più ampia di questa bozza.
- Gateway e proxy, frequenti nelle implementazioni AI in cui un gateway sta tra l’agente e le applicazioni. È una questione aperta. Si propone una bozza separata e gli appunti dicono che gli autori vorrebbero riunioni aggiuntive (“interim”) su gateway e key binding.
Gli appunti le registrano come raccomandazioni. Non vi compare alcuna decisione definitiva. I prossimi passi indicati nelle slide sono smistare le questioni rimaste, risolvendo ciascuna in una versione -07 oppure accantonandola deliberatamente, e poi chiedere una last call del gruppo di lavoro.
Implementazioni#
Diversi fornitori la implementano già, anche se la bozza non è definitiva. Secondo l’elenco delle implementazioni su oauth.net, consultato il 19 novembre 2026:
- Identity provider che emettono ID-JAG: tra gli altri Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (indicato “in progress”) e altri.
- Server di autorizzazione che li accettano: tra gli altri Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (early access), Stytch e WorkOS AuthKit (early access).
- Applicazioni e strumenti AI che agiscono da client: tra gli altri Claude, OpenAI Codex CLI e Visual Studio Code (preview).
- Applicazioni dal lato ricevente: tra le altre Asana, Atlassian, Linear, Notion e Slack, alcune in beta.
Alcuni esempi datati:
- Oracle: il 9 ottobre 2026 Oracle ha rilasciato il token exchange ID-JAG in OCI IAM.
- Gravitee: Access Management 4.13, annunciato il 12 novembre 2026, può svolgere entrambi i ruoli, emettere e accettare ID-JAG.
- Okta: il 13 novembre 2026 ha annunciato la disponibilità generale del supporto per identity provider di terze parti e indica Ping, Descope e Oracle come provider abilitati a XAA con cui può lavorare per utenti e agenti.
- MCP: il Model Context Protocol, un modo diffuso per collegare gli strumenti AI alle applicazioni, ha un’estensione “Enterprise-Managed Authorization” che usa un ID-JAG. Il blog del progetto l’ha annunciata come stabile nel giugno 2026.
Al momento della verifica Microsoft Entra non compariva nell’elenco di oauth.net.
Differenze rispetto alle schermate di consenso e all’on-behalf-of#
| Richiesta di consenso | On-behalf-of (OBO) | ID-JAG / XAA | |
|---|---|---|---|
| Chi approva | L’utente, applicazione per applicazione | Il consenso precedente dell’utente, trasmesso | L’accesso aziendale, secondo regole stabilite da un amministratore |
| Cosa vede l’utente | Una richiesta per ogni applicazione | Di solito nulla dopo il primo accesso | Nulla |
| Dove funziona | Ovunque funzioni OAuth | Un servizio che ne chiama un altro, all’interno di un solo sistema di identità | Tra applicazioni e organizzazioni che gestiscono ciascuna un proprio server di autorizzazione |
| Controllo centrale | Limitato | Parziale | Lo scopo del progetto |
Rispetto alle schermate di consenso: una richiesta di consenso interpella l’utente ogni volta. Un ID-JAG applica una volta le regole dell’organizzazione e poi le fa rispettare in modo silenzioso.
Rispetto all’on-behalf-of: la documentazione Microsoft descrive l’OBO come un’API web che usa l’identità di un utente per chiamare un’altra API, trasmettendo lungo la catena identità e permessi dell’utente. Avviene all’interno della piattaforma di identità Microsoft. L’ID-JAG affronta un problema affine oltre i confini: le due applicazioni hanno server di autorizzazione diversi e una terza parte, l’accesso aziendale, garantisce per l’utente. Dal punto di vista dell’utente si assomigliano, ma la fiducia è organizzata in modo diverso.
Una considerazione#
Meno richieste significano più comodità, ma anche meno momenti in cui una persona esamina la richiesta. È una valutazione, non un’affermazione dello standard: il progetto funziona solo se le policy dell’organizzazione sono solide e riviste con regolarità. L’ID-JAG rende possibile vedere e controllare l’accesso degli agenti in un unico punto. Qualcuno deve comunque esercitare il controllo.
L’articolo sarà aggiornato man mano che la bozza si avvicina alla last call del gruppo di lavoro.
Ripeti questo lab#
Servono solo Node.js 20 o successivo, git e un browser. Registri un'app gratuita su xaa.dev, esegui in locale l'esempio TypeScript di Okta e leggi l'ID-JAG e l'access token nel pannello Behind the scenes. Circa 20 minuti. Apri ogni passo, copia i blocchi e confronta con quello che ho visto io.
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
# 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' 0 di 6 passi fatti
Passo 1Registra una requesting app su xaa.dev
Obiettivo. Registra l'esempio come Requesting App con l'URI di redirect locale esatto e collegalo alla risorsa Todo MCP server.
Prerequisiti
- Un browser; xaa.dev è un playground pubblico con dati usa e getta
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. Output atteso
Credential dialog shows two pairs:
client_id <APP_CLIENT_ID>
resource_client_id <RESOURCE_CLIENT_ID> (ends in -at-todo0-mcp) Passo 2Scarica l'esempio e installalo
Obiettivo. Clona l'esempio TypeScript di Okta basato sull'SDK MCP e installa le dipendenze.
Prerequisiti
- Node.js 20 o successivo e git
- Porta 3001 libera
node --version
git clone https://github.com/oktadev/okta-xaa-typescript-mcp-sdk-example.git
cd okta-xaa-typescript-mcp-sdk-example
npm install Output atteso
v20.x.x
Cloning into 'okta-xaa-typescript-mcp-sdk-example'...
added <n> packages in <n>s Passo 3Imposta le credenziali
Obiettivo. Carica env.sh e controlla che nessun valore richiesto sia vuoto. L'app li legge dall'ambiente, quindi non c'è nessun file .env da committare per errore.
Prerequisiti
- Le credenziali del passo di registrazione in env.sh
- Il terminale è dentro la cartella clonata
. ./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 Output atteso
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 Passo 4Avvia l'app e accedi
Obiettivo. Avvia l'app e accedi con il company SSO. L'identity provider della demo accetta qualsiasi indirizzo email, quindi non servono credenziali reali.
Prerequisiti
- Le variabili di env.sh sono impostate in questo terminale
npm start # keep it running, then open http://localhost:3001 and select "Sign in with company SSO" curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3001/ # from a second terminal Output atteso
╔════════════════════════════════════════════════════╗
║ 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 Passo 5Leggi l'ID-JAG e l'access token
Obiettivo. Espandi ogni scheda nel pannello Behind the scenes e controlla tre cose nei token decodificati.
Prerequisiti
- La dashboard mostra tutti e quattro i passi come completati
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 Output atteso
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 Passo 6Pulizia
Obiettivo. Ferma l'app, elimina il clone e le variabili ed elimina l'app registrata su xaa.dev.
Prerequisiti
- Nient'altro usa la porta 3001
# 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/ Output atteso
000 Fonti#
- IETF draft-ietf-oauth-identity-assertion-authz-grant-06 (Identity Assertion JWT Authorization Grant)
- IETF 127 OAuth session slides: Identity Assertion Authorization Grant
- IETF 127 OAuth working group session notes
- oauth.net: Cross-App Access, with the list of implementations
- Okta Developer: Cross App Access (XAA) concepts
- Okta press release, 13 Nov 2026: third-party identity providers in Okta for AI Agents
- Oracle OCI IAM release note, 9 Oct 2026: ID-JAG token exchange across trust domains
- Gravitee blog, 12 Nov 2026: Cross App Access in Access Management 4.13
- Model Context Protocol blog: Enterprise-Managed Authorization
- Microsoft Learn: the on-behalf-of flow
- xaa.dev, the free Cross App Access playground
- Video: See How Cross App Access (XAA) Works (OktaDev, 7:45)
Discuti questo articolo#
La conversazione si svolge dove l'ho condiviso. Partecipa, o dimmi dove ho sbagliato.
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