El contexto no es memoria: Por qué la memoria durable debe ser infraestructura

Los Modelos de Lenguaje Grande (LLMs) son extraordinarios motores de razonamiento. Dado un contexto estructurado, pueden sintetizar intenciones ambiguas, planificar flujos de trabajo de múltiples pasos y seleccionar herramientas relevantes.

Sin embargo, en el entusiasmo por construir sistemas autónomos, la industria ha confundido dos conceptos fundamentalmente distintos: Contexto de Trabajo y Memoria Durable.

Cuando tratas el historial de conversación como la base de datos de tu aplicación, tus agentes inevitablemente se vuelven frágiles, costosos y no deterministas.

La ilusión del contexto

En las demos iniciales de agentes, los desarrolladores suelen concatenar cada evento en un arreglo de mensajes dentro del prompt:

// El patrón ingenuo: Almacenar el mundo en el prompt
const messages = [
  { role: "system", content: "Eres un asistente autónomo..." },
  { role: "user", content: "Procesa el lote de facturas #892" },
  { role: "assistant", tool_calls: [...] },
  { role: "tool", content: JSON.stringify(rawDatabaseDump) },
  // ... 40 turnos después ...
];

Este patrón crea una ilusión de memoria. El modelo parece "recordar" porque los tokens anteriores se reenvían en cada llamada de inferencia. Sin embargo, en producción esto desencadena modos de falla críticos:

1. Inflación de tokens y degradación de latencia

A medida que el flujo avanza, el tamaño del prompt crece linealmente con el tiempo y cuadráticamente con las respuestas de las herramientas. Un flujo de conciliación de 50 pasos puede consumir fácilmente 90,000 tokens por paso, convirtiendo operaciones de submilisegundos en esperas de 12 segundos con costos acumulativos.

2. Pérdida de autoridad del estado

Si el modelo alucina un ID de transacción previo o malinterpreta un payload JSON de hace 30 turnos, no existe una capa de validación que lo corrija. El prompt es texto no tipado ni estructurado.

3. Fallas catastróficas de recuperación

Si el proceso de Node.js se cae, ¿dónde se reanuda la ejecución? Si el servidor reinicia a la mitad de una operación de 10 pasos, volver a ejecutar el prompt provocará efectos secundarios duplicados (por ejemplo, cobros dobles con tarjeta o correos duplicados a clientes).

La separación de responsabilidades

Para construir sistemas de agentes listos para producción, debemos desacoplar el razonamiento probabilístico de la persistencia determinista.

Contexto de Trabajo (Probabilístico)

El contexto es la porción efímera de información necesaria para que el modelo tome un paso específico de razonamiento. Debe ser:

• Mínimo y enfocado (reduciendo distracciones y consumo de tokens)
• Sintetizado dinámicamente desde el estado actual del sistema
• Descartado o comprimido estrictamente tras la inferencia

Memoria Durable (Determinista)

La memoria durable es el registro auditable y reproducible de la verdad. Debe estar:

• Respaldada por persistencia relacional o event-sourced (como PostgreSQL)
• Gobernada por esquemas estrictos y transiciones de máquinas de estado
• Completamente desacoplada del proveedor de LLM o del tamaño de la ventana de contexto

Cómo lo resuelve Invariant: Hidratación de Sesión y Event Sourcing

En el modelo de estado de Invariant, el estado autoritativo del workflow no se guarda en cadenas de prompt. Se deriva de hechos de ejecución confirmados:

import { invariant } from '@invariant-tech/sdk';
import { sqlite } from '@invariant-tech/sqlite';
import { z } from 'zod';

const app = invariant({ storage: sqlite('./data/invoices.db') });

export const conciliacionFacturas = app
  .workflow('invoice-reconciliation', {
    inputSchema: z.object({
      invoiceId: z.string(),
      matchedItems: z.array(z.string()),
    }),
  })
  .step('record-reconciliation', ({ input }) => ({
    invoiceId: input.invoiceId,
    matchedItems: input.matchedItems,
    status: 'VERIFIED' as const,
  }))
  .capability('persist-reconciliation', {
    idempotencyKey: 'invoice-reconciliation:{{runId}}',
    handler: async ({ state }) => persistReconciliation(state),
  });

export const proyeccionFactura = app.projection('invoice-summary', ({ runtime }) => ({
  status: runtime.activeExecution?.status ?? null,
  currentNodeId: runtime.activeExecution?.currentNodeId ?? null,
  accionesPermitidas: runtime.validActions.map((action) => action.name),
}));

Cuando un agente necesita razonar, Invariant puede exponer una vista limpia y compacta derivada de la verdad durable de Session y ejecución (Proyecciones).

El historial persistido permite reconstruir la verdad confirmada tras un reinicio. La Beta actual no adjunta automáticamente un proceso nuevo a una ejecución activa ni reclama comandos pendientes; los efectos externos siguen siendo at-least-once si se vuelven a despachar. El proveedor debe respetar claves estables de idempotencia.

Siguiente artículo

Tratar el contexto como memoria fue un paso natural en los inicios de la IA generativa. Pero a medida que construimos agentes que mueven dinero real, datos confidenciales y flujos críticos de negocio, nuestra infraestructura debe evolucionar.

En la Parte 2 de esta serie, analizamos la frontera de ejecución: Por qué los agentes necesitan un runtime determinista.