Arquitectura de LLMs: Tokens, Contexto, Skills y Agentes

La integración de IA generativa ha dejado de ser solo sobre interfaces de chat y se ha convertido en un desafío directo de arquitectura de software. Entender el funcionamiento del motor de estas herramientas es lo que separa una llamada de API ineficiente de un sistema autónomo real. El hype pasó; ahora la discusión es pura ingeniería.

A continuación, los cuatro pilares técnicos que estructuran esta capa.

Tokens

La unidad fundamental de procesamiento. Los modelos de lenguaje no interpretan texto corrido, procesan matrices numéricas. El texto crudo de entrada y salida se fracciona en estos fragmentos llamados tokens. La facturación, el tiempo de latencia y el costo computacional de cualquier petición dependen estrictamente de este volumen. La eficiencia de una integración se mide por la densidad de información útil por token gastado, lo que exige una optimización constante de lo que viaja por la red.

Context Window

Es la memoria a corto plazo de la petición. Cada modelo posee un límite arquitectural estricto de tokens que puede retener y procesar simultáneamente en una sola llamada. Sobrepasar este límite resulta en la pérdida silenciosa de las instrucciones iniciales. En proyectos reales, eludimos esta limitación estructural evitando el envío de bases de datos enteras. En su lugar, implementamos pipelines de recuperación de datos que inyectan en el contexto solo el alcance estrictamente necesario milisegundos antes del envío final al modelo.

Skills (Function Calling)

El mecanismo para salir del aislamiento estructural del modelo. Es el puente entre la capacidad analítica de la IA y la ejecución de tu código. El modelo recibe las firmas de las funciones y rutinas disponibles en tu sistema. Al procesar la petición, en lugar de generar texto libre, genera un payload de datos estructurado indicando qué función de tu software debe ser ejecutada. El sistema procesa la lógica de negocio y devuelve el output para que el modelo continúe la operación. Es el punto de contacto donde la abstracción obtiene acceso al entorno de producción.

Agentes

La cima de la abstracción de control. A diferencia de los flujos imperativos tradicionales, la arquitectura basada en agentes invierte la gestión del sistema. En lugar de declarar un paso a paso lineal, se define un estado final o un objetivo. El modelo evalúa la intención, selecciona las Skills declaradas en el sistema, recibe el retorno de la ejecución de cada una y decide de forma recursiva la siguiente acción. Representa la transición de un sistema puramente reactivo a un sistema autónomo, sirviendo de base para arquitecturas donde múltiples agentes aislados colaboran en la misma solución.

---

Uniendo las piezas: Cómo aplicar esto en la práctica

La teoría es elegante, pero la ingeniería ocurre en las trincheras. Cuando llevas estos cuatro pilares al desarrollo de un producto real —como un SaaS multi-tenant o una arquitectura de micro-frontends—, el flujo de trabajo cambia radicalmente.

Aquí tienes ejemplos reales de cómo orquestar estos elementos.

1. Optimizando Tokens y Contexto en Logs de Migración

Imagina que estás liderando una migración compleja de sistemas legados hacia una nueva arquitectura y necesitas usar la IA para analizar fallos. Si lanzas un archivo de log de 50MB en el prompt, vas a reventar la Context Window y quemar dinero con Tokens inútiles.

La solución real: Creas un script intermediario que filtra el log localmente. El sistema extrae solo las líneas que contienen las etiquetas [ERROR] o [TIMEOUT] referentes a un tenant_id específico. Empaquetas solo este extracto de texto refinado (ahora con apenas 800 tokens) y lo inyectas en la Ventana de Contexto de la petición. La IA recibe solo la señal limpia, sin el ruido, y devuelve el diagnóstico del problema de forma rápida y barata.

2. Controlando el Frontend con Skills (Function Calling)

Quieres poner una barra de búsqueda inteligente en un dashboard gerencial. El usuario escribe: "Filtra los usuarios inactivos del mes pasado".

La IA no tiene acceso a tu base de datos para hacer esto. Aquí es donde entran las Skills.

• El Flujo: Envías el input del usuario a la IA, pasando junto un esquema JSON de una Skill llamada applyUserFilter(status, dateRange).
• La Magia: La IA no responde con texto amigable. Devuelve un JSON estructurado: { "function": "applyUserFilter", "args": { "status": "inactive", "dateRange": "2026-06" } }.
• En el Frontend: Tu código intercepta esta respuesta, aplica estos argumentos directamente en el estado de tu aplicación (por ejemplo, actualizando un Signal en Angular), y la tabla en la pantalla se renderiza al instante con los datos correctos. La IA operó la interfaz por ti.

3. Orquestando Agentes para Tareas Autónomas

Piensa en un flujo de onboarding para un nuevo cliente en tu sistema SaaS. En lugar de crear un código rígido que llama a 5 APIs diferentes en secuencia, defines un Agente de Aprovisionamiento.

Le das un objetivo: "Configura el entorno para el nuevo Tenant X". El Agente, ejecutándose en el backend, analiza la tarea y decide sus propias acciones:

1. Acciona la Skill createDatabaseSchema().
2. Evalúa la respuesta (¿fue exitosa?).
3. Acciona la Skill provisionMicroFrontendRoute().
4. Se da cuenta de que la API de rutas devolvió un error de timeout. Como es un Agente, tiene autonomía para razonar sobre el error y decide accionar la Skill nuevamente (retry) sin que tú hayas programado ese if/else específico.
5. Cuando todo finaliza, acciona la Skill sendSlackNotification() avisando que el entorno está activo.

Dejaste de ser un programador de flujos imperativos y pasaste a ser un orquestador de capacidades.