iamops.dev
Argo su X Feed RSS
ITItaliano

Lab Tecnico 10 min di lettura

ID-JAG spiegato: come gli agenti AI ottengono l'accesso tra applicazioni sotto il controllo aziendale

Come ID-JAG e Cross App Access fanno approvare all'identity provider l'accesso degli agenti AI ad altre app: lab con screenshot e stato della bozza.

Due screenshot redatti dell'app di esempio xaa.dev: la dashboard di onboarding con il pannello Behind the scenes e l'ID-JAG decodificato, con gli identificatori coperti da riquadri neri.
In breveID-JAG è uno standard IETF proposto (bozza -06) che permette…
  • 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 6 passi

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.

Vai ai passi

Come funziona

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

I cinque passaggi di un flusso ID-JAG, dall'accesso unico all'uso di un access token di breve durata da parte dell'agente.

Il flusso in cinque passaggi:

  1. L’utente accede al lavoro una sola volta, nel modo consueto.
  2. L’agente chiede all’accesso aziendale un’asserzione valida per una determinata applicazione.
  3. L’accesso aziendale valuta la propria policy. Se il collegamento è consentito, emette l’ID-JAG.
  4. 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.
  5. 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.

L'app di esempio xaa.dev con la checklist di onboarding a sinistra e il pannello Behind the scenes a destra, che mostra tutte e quattro le fasi completate.
Panoramica. La checklist (a sinistra) è stata recuperata dalla seconda applicazione usando l'identità aziendale. Il pannello (a destra) elenca le quattro fasi: accesso aziendale, ID-JAG, access token, checklist via MCP. Il claim del soggetto (sub) è oscurato.

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.

Fase 2 espansa nel pannello Behind the scenes: l'ID-JAG decodificato con emittente, destinatario, risorsa, orari di emissione e scadenza e scope visibili; gli identificativi sono coperti da riquadri neri.
Fase 2, l'ID-JAG. Emittente, destinatario, risorsa, periodo di validità e scope sono visibili. Soggetto, client e identificativi del token sono coperti da riquadri neri e il token codificato non viene mostrato.

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.

La sezione dell'access token espansa, con i claim che mostrano emittente, destinatario e gli scope todos.read e mcp.access; il token codificato e il soggetto sono oscurati.
Fasi 3 e 4, l'access token. I claim del token (emittente, destinatario, scope) sono reali. Il token codificato e il soggetto sono oscurati.

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.

Registrazione dello schermo (1 min 44 s, senza audio, sottotitoli disponibili): accesso presso l'IdP aziendale, poi ogni passaggio con header e payload decodificati. Utente sintetico e token dimostrativi di breve durata del playground pubblico. Le stringhe dei token codificati sono accorciate per l'impaginazione.

Cosa stai vedendo#

  1. 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.
  2. 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) ed exp, un’ora dopo iat. L’app ha ora un’identità dell’organizzazione, ma ancora nessun accesso all’app todo.
  3. 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 in aud il server di autorizzazione dell’app todo, più resource, client_id e scope. In una distribuzione reale è qui che decide la policy dell’amministratore. Il playground la consente e basta.
  4. 0:58 L’ID-JAG ha vita breve. exp arriva 300 secondi dopo iat. Un ID-JAG trapelato è inutile dopo cinque minuti e funziona solo sul server indicato in aud.
  5. 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 come aud e solo lo scope approvato. L’utente è identificato nello spazio dei nomi dell’app todo.
  6. 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

bash · env.sh
# 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'
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
text · xaa-registration.txt
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

output
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
bash · install.sh
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

output
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
bash · check-env.sh
. ./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

output
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
bash · start.sh
npm start   # keep it running, then open http://localhost:3001 and select "Sign in with company SSO"
bash · check-port.sh
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3001/   # from a second terminal

Output atteso

output
╔════════════════════════════════════════════════════╗
║     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
text · checks.txt
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

output
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
bash · cleanup.sh
# 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

output
000

Fonti#

Discuti questo articolo#

La conversazione si svolge dove l'ho condiviso. Partecipa, o dimmi dove ho sbagliato.

Segui su X

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

Articoli e laboratori correlati