Agentes IA perdem identidade do usuário: token exchange (compliance + segurança)

Agentes IA perdem identidade do usuário: token exchange (compliance + segurança)

O problema invisível que mata auditoria de agentes IA (e ninguém fala):

Você provavelmente pensa em agentes IA = "age em nome do usuário, mas é transparente".

Realidade: ERRADO. Seu agente IA = faz ação em APIs downstream (ServiceNow, Salesforce, banco de dados) = provavelmente = como aplicação (não como usuário). Exemplo: Agente de suporte = usuário da empresa = Jane = faz pergunta = agente = acessa database = mas acesso = vem como "app_service_account" (não Jane). Resultado = auditoria = vê = "app fez acesso" (não "Jane fez acesso"). Compliance quebra (LGPD, SOX = requer user-level audit trail). Segurança quebra (access control = não aplica ao usuário = apenas ao app = Jane = acessa dados que não deveria). Dados vazam (se agente = buggado = age como app = permissões = full = vazamento invisível). ServiceNow + AWS Bedrock = descobriu isso = on-behalf-of token exchange = solução (agente = mantém identidade = Jane = Jane fica no audit trail). Sua SaaS IA = provavelmente = sem isso = está quebrada.

Mais específico (o problema):

• Problem 1: Agentes IA = agem como aplicação (não usuário)
• Problem 2: Audit trail = vê app (não usuário) = compliance quebra
• Problem 3: Access control = não aplica ao usuário = segurança quebra
• Problem 4: Dados sensíveis = acesso sem restrição = vazamento invisível
• Problem 5: Token = não propagado = request chain = perde identidade
• Solution 1: On-behalf-of token exchange (ServiceNow pattern)
• Solution 2: Token propagation (mantém identidade = na request chain)
• Solution 3: User-level audit (quem fez o quê = rastreável)
• Solution 4: Least privilege (agente = age com permissões do usuário = não app)
• Solution 5: Compliance ready (LGPD, SOX, HIPAA = audit trail intacta)
• Aplicação direta: Sua SaaS IA = PRECISA = on-behalf-of token = HOJE
• Timeline: Urgente (compliance violation = multa heavy)

Crítica pergunta (pra sua SaaS de agentes IA):

Se seu agente IA = age como aplicação (não usuário) = audit trail quebra = compliance violada = dados vazam entre usuários. ServiceNow + Bedrock = provou que on-behalf-of token = é possível. Você está implementando = ou deixando = compliance vulnerability aberta? 🎯⚠️

Resposta honesta:

Antes: "Agente faz ação, não importa identidade". Agora: "Agente precisa = manter identidade = usuário = audit trail intacta". Realidade: Token exchange = é compliance requirement (não optional). ServiceNow = set standard. Ação: Implementar on-behalf-of token (AGORA). Esperado: User-level audit, access control per user, compliance ready. Decisão: Implementar = ou violação comprovada. Timeline: 2-4 semanas. 🎯⚠️

Para sua SaaS IA com agentes (realidade que importa):

• Agentes IA = precisam manter identidade usuário
• Token exchange = on-behalf-of = é padrão emergente
• Audit trail = DEVE rastrear = usuário (não app)
• Access control = DEVE ser = user-level (não app-level)
• Compliance = LGPD, SOX, HIPAA = exigem isso
• Implementation = 2-4 semanas (tech debt)
• Risk = violação = multa = reputação

---

O problema invisível: Identity loss em agentes IA

Análise: Como agentes perdem identidade

Traditional architecture (QUEBRADA):

User (Jane) ↓ Agent AI (recebe request como Jane) ↓ Agent = precisa acessar API downstream (ServiceNow) ↓ Agent = faz request com TOKEN?

• NO (problema!)
• Agent = usa app service account token
• Request = vai para ServiceNow como "app_service_account"
• ServiceNow = vê origin = app (não Jane) ↓ ServiceNow API
• Audit log = "app_service_account acessou dados"
• Não sabe = foi Jane que solicitou
• Access control = aplica app permissions (não Jane's)
• Resultado = Jane = acessa dados que não deveria (via agent)

Compliance violation:

LGPD (Brazil):

• Artigo 8 = Empresa = precisa demonstrar = consentimento do usuário
• Audit trail = DEVE rastrear = usuário individual (não app)
• Se agente = age como app = audit trail = perdido
• Violation = não consegue comprovar = consentimento
• Multa = 2% revenue (até R$50M)

SOX (Sarbanes-Oxley):

• Requer = user-level audit trails
• Cada ação = DEVE ser rastreada = para usuário específico
• Se agente = age como app = SOX violation
• Multa = até $1M + criminal charges

HIPAA (healthcare):

• Access logs = DEVEM incluir = user identity
• PHI (Protected Health Information) = acesso DEVE ser rastreado
• Agente = sem user identity = HIPAA violation
• Multa = até $1.5M por violation

Security breach scenario:

Your SaaS = Contact center automation Agents = acessam CRM (Salesforce)

Scenario:

1. User (John) = pede agente = "buscar histórico de customer"
2. Agent = recebe request = como John
3. Agent = precisa chamar API = Salesforce
4. Problem = agent = usa app token (não John's)
5. Salesforce = vê request = de "app_service_account"
6. Access control = app_service_account = tem = FULL CRM access
7. Agent = consegue = buscar = dados de QUALQUER customer
   • Não só do customer de John
   • Por que access control = é app-level (não user-level)
8. Bug no agent = bug faz agent = fetch all customers
   • Bug = consegue = porque token = é app-level
   • Todos os dados = vazam
9. Audit trail = vê = "app_service_account acessou 50K customers"
   • Não consegue = rastrear = para usuário
   • Não consegue = culpar = John (ou outro usuário)
   • Não consegue = auditar = quem fez o quê
10. Compliance investigation = não consegue = provar = quem autorizou
    • Múltiplas multas = LGPD, SOX, HIPAA
    • Reputação = destruída

Security breach sem on-behalf-of token = é invisível:

Without identity propagation:

• Audit log = "2026-11-03 10:15:22 app_service_account accessed 50K records"
• Você = não sabe = qual usuário = autorizou
• Você = não consegue = culpar = alguém
• Investigação = impossível
• Compliance = fails

With on-behalf-of token:

• Audit log = "2026-11-03 10:15:22 john.doe@company.com accessed customer XYZ via agent"
• Você = SABE = John fez o quém
• Você = CONSEGUE = investigar = John
• Se bug = consegue = rastrear = origem
• Compliance = passes

---

Solução: On-behalf-of token exchange

Como funciona

Architecture (CORRIGIDA):

User (Jane) @ app ↓ Agent AI (recebe request com Jane's context) ↓ Agent = precisa acessar API downstream (ServiceNow) ↓ Agent = precisa = token de Jane (não app token)

• Problem = como conseguir?
• Solution = token exchange ↓ Bedrock AgentCore Gateway:
• Intermediate layer
• Input = Jane's context (identity)
• Output = Jane's token (for downstream API) ↓ Agent = usa Jane's token
• Request = vai para ServiceNow
• Request = como "jane.doe@company.com" (não app)
• ServiceNow = vê origin = Jane
• Access control = aplica = Jane's permissions ↓ ServiceNow API
• Audit log = "jane.doe@company.com accessed customer data"
• Identity = preservado
• Access control = per-user (não app)
• Compliance = passes

Token exchange flow (technical):

1. User Jane = faz request para Agent Request payload = { user_id: "jane.doe@company.com", action: "get_customer_data", context: {...} }

2. Agent = recebe request = sabe user = Jane

3. Agent = precisa = token de Jane = para chamar ServiceNow Problem = agent = não tem = token Solution = pedir = para gateway

4. Bedrock AgentCore Gateway = token exchange endpoint Agent = faz request = {user_id: "jane.doe@company.com"} Gateway = valida = Jane existe Gateway = puxa = Jane's service account token (ou OAuth token) Gateway = retorna = token = para agent

5. Agent = recebe = Jane's token Agent = chama = ServiceNow API = com Jane's token Request = { Authorization: "Bearer <jane_token>", action: "get_customer_data", ... }

6. ServiceNow = recebe = request ServiceNow = valida = token = é Jane's ServiceNow = aplica = Jane's access control ServiceNow = retorna = dados = que Jane = pode acessar ServiceNow = loga = "jane.doe accessed data"

7. Audit trail = intacta Log = "jane.doe @ 10:15:22 acessou customer data via agent" Compliance = passes

---

Implementação: 4-step roadmap

Step 1: Audit current token usage (baseline)

Identify:

1. Quais APIs = seu agent = acessa?

   • List all downstream APIs
   • Example: ServiceNow, Salesforce, Slack, etc

2. Como = agent = autentica?

   • App token? (service account)
   • User token? (user-level)
   • No auth? (public APIs)

3. Audit trail = rastreia o quê?

   • User identity? (Jane)
   • App identity? (agent_app_account)
   • Nada? (no logging)

4. Compliance requirements = aplicáveis?

   • LGPD? (Brazil = user identity required)
   • SOX? (finance = user-level audit)
   • HIPAA? (healthcare = PHI access = user-level)
   • GDPR? (EU = user consent = user identity required)

Questions to answer:

• "Agent = usa app token ou user token?" If app token = PROBLEM (needs fixing) If user token = OK (but check propagation)

• "Audit trail = mostra user identity?" If app identity = PROBLEM If user identity = OK

• "Compliance = requer user-level audit?" If yes = URGENT (fix ASAP) If no = can defer (but still recommended)

Timeline: 1 week (audit)

Step 2: Design token exchange layer (architecture)

Components:

1. Identity source = onde vem identidade do usuário?

   • JWT token? (OpenID Connect)
   • User context? (API header)
   • Session store? (database lookup)

2. Token translator = como converter para downstream API?

   • OAuth token exchange? (RFC 8693)
   • Service account impersonation? (Google Cloud)
   • On-behalf-of flow? (Azure AD)
   • Custom token mapping? (proprietary)

3. Secure storage = como guardar downstream tokens?

   • Vault? (HashiCorp, Azure Key Vault)
   • Encrypted database?
   • Ephemeral (generate on-demand)?

4. Gateway = quem media?

   • Bedrock AgentCore? (AWS)
   • Custom middleware? (DIY)
   • API gateway? (Kong, Apigee)

Example design (Bedrock AgentCore):

User Jane ↓ OpenClaw SaaS Agent ↓ (request with jane_id) Bedrock AgentCore Gateway ↓ (lookup jane_id) Vault (stores jane's service account token) ↓ (return encrypted token) Agent (receives jane's token) ↓ (calls ServiceNow with jane's token) ServiceNow ↓ (audit log: jane.doe accessed data) Compliance = OK

Timeline: 1-2 weeks (design + proof of concept)

Step 3: Implement token exchange (development)

Code example (pseudocode):

javascript // Bedrock AgentCore = token exchange endpoint const exchangeToken = async (request) => { const { user_id, downstream_api } = request;

// 1. Validate user identity const user = await validateUser(user_id); // Check JWT or session if (!user) throw new Error("Unauthorized");

// 2. Look up downstream token for user // Two options: // Option A = Service account impersonation const serviceAccountToken = await getServiceAccountToken(user_id, downstream_api);

// Option B = OAuth token exchange (RFC 8693) const exchangedToken = await exchangeOAuthToken({ subject_token: request.jwt_token, // User's JWT subject_token_type: "urn:ietf:params:oauth:token-type:jwt", resource: downstream_api, // e.g., "ServiceNow" actor_token: request.agent_token, // Agent's identity actor_token_type: "urn:ietf:params:oauth:token-type:access_token" });

// 3. Return token to agent return { access_token: exchangedToken, token_type: "Bearer", expires_in: 3600, scope: user.permissions[downstream_api] // User's scope for this API }; };

// Agent = uses token const callDownstreamAPI = async (agent_request) => { const { user_id, downstream_api, action } = agent_request;

// 1. Exchange token const { access_token } = await exchangeToken({ user_id, downstream_api });

// 2. Call downstream API with user's token const response = await fetch(https://${downstream_api}/api/${action}, { headers: { "Authorization": Bearer ${access_token}, "X-User-Id": user_id, // Optional: for audit "X-Agent-Id": agent_id // Optional: for audit }, body: JSON.stringify(agent_request) });

// 3. Return response return await response.json(); };

Timeline: 2-3 weeks (development + testing)

Step 4: Enable user-level audit logging (compliance)

Audit trail implementation:

javascript // Log every agent action with user identity const logAgentAction = async (event) => { const logEntry = { timestamp: new Date().toISOString(), user_id: event.user_id, agent_id: event.agent_id, action: event.action, downstream_api: event.downstream_api, resource_accessed: event.resource_id, result: event.result, // success or failure ip_address: event.client_ip, token_used: "user_token" // NOT app_token };

// Store in audit log (immutable) await auditLog.write(logEntry);

// Optional: stream to compliance system await complianceSystem.log(logEntry); };

// Example log const exampleLog = { timestamp: "2026-11-03T10:15:22Z", user_id: "jane.doe@company.com", agent_id: "contact-center-agent-01", action: "get_customer_history", downstream_api: "ServiceNow", resource_accessed: "customer_123", result: "success", ip_address: "192.168.1.100", token_used: "user_token" };

// Compliance = can now prove: // - WHO accessed WHAT (jane.doe accessed customer_123) // - WHEN (2026-11-03T10:15:22Z) // - VIA WHAT (contact-center-agent-01) // - WITH WHAT PERMISSIONS (user_token = jane's permissions)

Compliance report (what you can generate now):

Audit report for LGPD compliance:

1. User-level traceability: ✅ All agent actions traced to user (jane.doe@company.com) ✅ No app-level actions hiding user identity ✅ Audit trail = immutable

2. Access control: ✅ Agent = uses user's token (not app token) ✅ Permissions = enforced at user level ✅ Least privilege = maintained

3. Compliance violations: ✅ LGPD = audit trail ✓ ✅ SOX = user-level logging ✓ ✅ HIPAA = identity propagation ✓

4. Investigation capability: ✅ If breach = can trace to user ✅ If unauthorized access = can identify ✅ If compliance violation = evidence is clear

Timeline: 1 week (audit log setup)

Total timeline: 5-7 weeks

---

Impacto real: Compliance + security

Exemplo: SaaS de CRM automation (500 customers, 10K agents)

Before (app token = BROKEN):

Agent = usa app_service_account token Audit trail = "app_service_account accessed 1M records"

Compliance vulnerability:

• Audit trail = não rastreia = usuário individual
• Access control = app-level (permissões = full)
• Breach = não consegue investigar

Risk = multa LGPD = 2% revenue Assumir = SaaS revenue = R$50M/ano Multa = R$1M + criminal charges

Reputação = destruída (clientes = deixam) Revenue impact = -30% (clientes = assustam) Total impact = -R$16M/ano

After (on-behalf-of token = FIXED):

Agent = usa user token (jane.doe) Audit trail = "jane.doe accessed customer_123 @ 2026-11-03 10:15:22 via agent"

Compliance = OK:

• Audit trail = rastreia = usuário individual
• Access control = user-level (permissões = limited)
• Breach = consegue investigar (rastrear origin)

Compliance = passes = sem multa Reputação = intacta Clientes = confiam Revenue impact = 0 (ou +5% = trust premium) Total impact = +R$2.5M/ano (vs -R$16M before)

ROI: Implementação custa R$200K-500K (dev + infrastructure). Valor evitado (multa + reputação + revenue) = R$18M+. Payback = < 1 mês. 🎯

---

Conclusão: On-behalf-of token = é compliance requirement (não optional)

Agentes IA = precisam manter identidade usuário (on-behalf-of token exchange). ServiceNow + Bedrock = padrão emergente. Sua SaaS IA = provavelmente = sem isso = compliance quebrada + security vulnerável + dados vazando. 4-step solution: (1) Audit current tokens (1 week). (2) Design token exchange (1-2 weeks). (3) Implement (2-3 weeks). (4) Enable audit logging (1 week). Total: 5-7 weeks. Cost: R$200-500K. Risk if skip: LGPD violation (-R$1M multa + reputação), SOX violation (-R$1M+ multa), security breach (dados vazam). Decision: Implementar AGORA. Timeline: Começar segunda-feira. 🎯⚠️

Agentes IA = perdem identidade = compliance quebra = dados vazam. On-behalf-of token exchange = é padrão. Sua SaaS = precisa implementar. 5-7 weeks, R$200-500K, -R$18M+ risk. Start NOW. 🎯⚠️

OpenClaw: Agentes IA Identity Token Exchange | Compliance + Security