Ir al contenido principal
RBAC en Agentes IA: Tools Solo para Quien Corresponde

RBAC en Agentes IA: Tools Solo para Quien Corresponde

AI Integration
••7 min read•Por Daily Miranda Pardo

Tu agente IA tiene cuatro herramientas: get_order(), cancel_order(), issue_refund() y delete_record(). El equipo interno las usa a diario sin problema. Decides abrir el mismo agente a tus clientes para que consulten el estado de sus pedidos.

¿Qué ocurre la primera vez que un cliente escribe "quiero cancelar"?

El modelo tiene cancel_order() disponible. La lógica del flujo del usuario tiene sentido para él. La llama. Y tú te enteras cuando el pedido ya está cancelado.

Este es el error de arquitectura más ignorado en agentes IA multirol: definir las herramientas una sola vez y exponerlas igual a todos.

Por qué las tools estáticas no son suficientes

La forma habitual de registrar herramientas en un agente es una lista fija que se pasa al modelo en cada petición. Esto funciona bien cuando hay un solo tipo de usuario. Cuando hay varios roles —interno, cliente, administrador, solo lectura— el sistema tiene un problema estructural.

El modelo no tiene concepto de "este usuario no debería hacer esto". Tiene el contexto de la conversación y la lista de herramientas disponibles. Si la herramienta existe y el contexto empuja hacia ella, la usará.

Algunas soluciones que se ven frecuentemente y que no funcionan:

  • Instrucción en el system prompt: "No uses cancel_order si el usuario es cliente." El problema es que las instrucciones del sistema pueden contraponerse al contexto de la conversación, y en edge cases el modelo puede ignorarlas o interpretarlas diferente.
  • Validación posterior: revisar qué tool llamó el modelo y bloquearla si no corresponde. Esto protege la ejecución, pero el modelo ya tomó una decisión que podría afectar al resto de la respuesta.

La solución real es más simple: el modelo no puede llamar una tool que no ve. Si la tool no está en la lista, no existe para él.

RBAC para tools: el patrón que funciona

La idea central es filtrar las herramientas disponibles antes de llamar al LLM, según el rol del usuario autenticado. El modelo solo ve las tools que corresponden a ese rol.

// Mapa de roles a tools permitidas
type UserRole = 'admin' | 'manager' | 'viewer' | 'customer';

const TOOLS_BY_ROLE: Record<UserRole, string[]> = {
  admin: [
    'get_order', 'cancel_order', 'issue_refund',
    'update_customer', 'delete_record',
  ],
  manager: [
    'get_order', 'cancel_order', 'issue_refund', 'update_customer',
  ],
  viewer: [
    'get_order', 'get_customer',
  ],
  customer: [
    'get_own_orders', 'get_product_info',
  ],
};

function getToolsForRole(role: UserRole, allTools: Tool[]): Tool[] {
  const allowed = new Set(TOOLS_BY_ROLE[role] ?? []);
  return allTools.filter(tool => allowed.has(tool.name));
}

El filtrado es en la capa de negocio, no en el prompt. No dependemos del modelo para decidir qué puede hacer: lo decidimos nosotros antes de que el modelo reciba la petición.

Implementación en Next.js App Router

Este es el patrón completo para un endpoint de agente con RBAC en Next.js:

// app/api/agent/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { jwtVerify } from 'jose';
import { generateText } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { allTools, getToolsForRole } from '@/lib/agent-tools';

const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET!);

export async function POST(req: NextRequest) {
  // 1. Autenticar y extraer rol del JWT
  const authHeader = req.headers.get('authorization');
  if (!authHeader?.startsWith('Bearer ')) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
  }

  const { payload } = await jwtVerify(
    authHeader.slice(7),
    JWT_SECRET
  );

  const role = (payload.role as UserRole) ?? 'viewer';
  const userId = payload.sub as string;

  // 2. Filtrar tools según el rol — antes de llamar al LLM
  const tools = getToolsForRole(role, allTools);

  // 3. Parsear el cuerpo de la petición
  const { messages } = await req.json();

  // 4. El agente solo ve las tools permitidas para este rol
  const { text, toolCalls } = await generateText({
    model: anthropic('claude-sonnet-4-6'),
    system: buildSystemPrompt(role),
    messages,
    tools: Object.fromEntries(tools.map(t => [t.name, t])),
    maxSteps: 5,
  });

  // 5. Audit log de qué tools se llamaron
  if (toolCalls?.length) {
    await logToolUsage(userId, role, toolCalls);
  }

  return NextResponse.json({ text });
}

Tres aspectos importantes de este patrón:

El filtrado ocurre antes del LLM. No es una guardia posterior a la respuesta — es que el modelo nunca recibe las tools que no le corresponden.

El rol viene del JWT verificado, no del body. El cliente no puede autodeclararse admin enviando { role: 'admin' } en el payload.

El audit log registra lo que se llamó. Cuando algo sale mal, sabes qué herramientas tuvo disponibles ese usuario y cuál se ejecutó.

RBAC frente a ABAC: cuándo necesitas más granularidad

RBAC funciona para restricciones por tipo de usuario. Pero hay situaciones donde la restricción depende de los datos, no del rol:

  • Un manager puede cancelar pedidos, pero solo los de su región
  • Un customer puede ver su historial, pero no el de otras cuentas
  • Un viewer puede exportar reportes, pero solo los de los últimos 30 días

Esto es ABAC (Attribute-Based Access Control): la autorización depende de atributos del recurso y del usuario, no solo del rol. Implementarlo dentro del agente requiere una capa adicional en cada herramienta, no solo en el filtro de acceso.

// Dentro de cancel_order() — validación ABAC
async function cancelOrder({ orderId }: { orderId: string }) {
  const order = await db.orders.findById(orderId);

  // La tool puede existir para el rol, pero la operación específica
  // puede estar restringida por atributos del recurso
  if (order.region !== currentUser.region) {
    throw new ToolAuthorizationError(
      `Usuario ${currentUser.id} sin acceso a pedidos de región ${order.region}`
    );
  }

  return await db.orders.cancel(orderId);
}

La diferencia práctica: RBAC filtra las tools antes del LLM, ABAC valida dentro de cada tool durante la ejecución. Ambas capas son complementarias. Para la mayoría de los sistemas que construimos en proyectos de integración de agentes IA, empezamos con RBAC en el acceso y añadimos ABAC solo donde la lógica de negocio lo exige.

Por qué esto también mejora el comportamiento del modelo

Hay un efecto secundario positivo que los equipos no anticipan: el modelo toma mejores decisiones cuando tiene menos herramientas.

Con una lista de 20 tools, el modelo tiene más ambigüedad para decidir cuál usar. Con 4 o 5 tools específicas para ese rol, el espacio de decisión es más pequeño y la selección más precisa. Los fallos por tool selection incorrecta —muy comunes en agentes con muchas herramientas— se reducen de forma natural.

Esto conecta directamente con los problemas de ambigüedad en schemas de herramientas: cuanto menos tools tiene que elegir el modelo, más fácil le resulta elegir bien.

Lo que cambia cuando esto está bien implementado

  • El agente de cliente no puede cancelar ni modificar nada que no sea leer
  • El manager no ve la opción de borrar registros porque no existe para él
  • Si alguien intenta explotar el contexto del prompt para forzar una acción restringida, la herramienta no existe — no hay nada que forzar
  • Cada tool call queda registrada con el rol que la hizo, lo que hace el audit de seguridad trivial

Este es el tipo de arquitectura que hace que un agente IA sea viable en producción real, con usuarios reales que no siempre hacen exactamente lo esperado.

Si estás construyendo un agente que va a servir a varios tipos de usuario y quieres que el diseño de acceso sea correcto desde el principio, cuéntanos cómo está montado ahora →

Compartir artículo

LinkedInXWhatsApp

¿Procesos repetitivos en tu empresa?

Descarga gratis el Mapa de Automatización IA — los 5 procesos que más tiempo roban y cómo resolverlos.

Responsable: DailyMP (Daily Miranda Pardo). Usamos tu email solo para enviarte el PDF, salvo que marques la casilla de abajo. Más info en la política de privacidad.

Escrito por Daily Miranda Pardo

Ayudo a empresas a automatizar procesos, crear agentes IA y conectar sistemas inteligentes.