Cómo gestionar ventanas de contexto limitadas en agentes de IA: 7 estrategias prácticas

Cualquiera que haya construido un agente que dure más de unos pocos pasos conoce el momento. Un error avisa de que se ha superado la ventana de contexto, o el modelo actúa de repente como si la conversación de hace veinte mensajes no hubiera existido. Las llamadas a herramientas, las largas cadenas de razonamiento y las voluminosas respuestas JSON se comen los tokens a un ritmo alarmante.

El problema crece con la complejidad del agente. Cuanto más tiempo trabaja, más estado tiene que arrastrar, y tarde o temprano la ventana se convierte en el cuello de botella. Aquí ayudan siete técnicas. No necesitarás todas: a menudo dos o tres ya cambian de forma notable el coste, la velocidad y la fiabilidad. El objetivo es hacer más dentro de la misma ventana.

1. Comprime el historial

Es la técnica más común en sistemas reales. En lugar de reenviar toda la conversación, mantienes un resumen continuo de lo que importa:

• las decisiones tomadas
• el razonamiento que merece conservarse
• los resultados finales de las herramientas
• las preferencias del usuario y el estado actual

Los turnos antiguos se condensan y solo los más recientes se quedan con todo detalle. Descarta los ejemplos y la charla, y quédate con las decisiones y los resultados.

Tras veinte mensajes, por ejemplo, todo lo acumulado podría reducirse a una nota como esta: el usuario quiere una aplicación de línea de comandos en Python, se eligió Click, hay tres comandos, faltan las pruebas y la documentación. El modelo no necesita cada mensaje anterior. Necesita lo que afecta a su siguiente paso.

La compresión también puede hacerse por capas: un resumen por paso, otro por tarea y, por encima, una memoria global del proyecto.

2. Poda mensajes y filtra por relevancia

No todos los mensajes merecen quedarse para siempre. A medida que un agente trabaja, su contexto se llena de material que ha dejado de ser útil. Puedes:

• descartar los registros antiguos de herramientas cuando sus resultados ya se han incorporado
• eliminar enormes cargas JSON después de extraer los campos clave
• conservar las respuestas finales y quitar la charla intermedia

Imagina una búsqueda web que devuelve una página HTML de 20.000 tokens. Mantener la página en bruto en el contexto no tiene sentido. Analízala una vez, extrae lo necesario y tira el marcado. El modelo sigue recibiendo los datos útiles sin cargar con miles de tokens inútiles.

3. Delega el cálculo pesado en herramientas

Las matemáticas, las simulaciones y las transformaciones de datos no deberían razonarse token a token. Una herramienta en Python o un servicio de backend puede hacer ese trabajo, y el modelo solo recibe un resultado compacto, como un número, un pequeño resumen estructurado o unas pocas estadísticas clave.

Supón que hay que analizar un CSV enorme. No lo pegues en el prompt. Deja que una herramienta calcule las estadísticas e informe algo como «100.000 filas, precio medio 23.4, 5 % de nulos en la columna X». Es muchísimo más barato que meter el conjunto de datos completo en la ventana. El modelo razona y las herramientas calculan.

4. Guarda las reglas estables en el prompt de sistema

Algunas instrucciones no cambian nunca durante una conversación:

• el tono del asistente
• las herramientas disponibles
• los requisitos de formato
• los ejemplos de referencia

Exprésalas una vez en el mensaje de sistema y deja de repetirlas. Si un agente siempre tiene que responder con una estructura JSON concreta, no hay motivo para recordarlo en cada turno del usuario. Según el tamaño de la instrucción y la frecuencia con que se llama al modelo, el ahorro en una sesión larga puede llegar a cientos o incluso miles de tokens.

5. Pasa referencias, no bloques enteros

Imagina un esquema de base de datos formado por miles de líneas de SQL, unos 20.000 tokens. En lugar de colocarlo en la ventana, dile al agente que el esquema está guardado con un nombre como schema_v2 y que puede obtenerlo con una herramienta get_schema cuando lo necesite.

Ahora el esquema reside en una herramienta o en un recurso aparte, y el agente solo lo carga cuando de verdad le hace falta. Este enfoque sirve para cualquier recurso grande:

• esquemas de bases de datos
• documentos largos
• archivos de configuración
• documentación de API
• bases de conocimiento

El agente mantiene una pequeña referencia y trae el contenido real cuando lo pide.

6. Reduce la salida de las herramientas antes de que la vea el modelo

Siempre que se pueda, la salida bruta y enorme de una herramienta no debería ir directa al modelo. Algunas reducciones típicas:

• un conjunto de datos grande se convierte en el número de filas más las columnas relevantes
• una página web completa se convierte en su título, sus encabezados y sus metadatos
• un documento JSON enorme se queda solo con las claves y campos que importan para la decisión

Supón que una herramienta de base de datos encuentra miles de filas, pero el agente solo necesita cuántas hay y la media de una columna. Devolver todas las filas sería un derroche. En su lugar, la herramienta puede responder con unas pocas líneas:

100,000 rows
Average price: 23.4
Null values in column X: 5%

Ahora el modelo puede razonar sobre el resultado con un presupuesto de tokens mínimo. Las herramientas funcionan mejor como preprocesadores que convierten montañas de datos en bruto en la pequeña porción que el modelo necesita de verdad, y no como simples tuberías de datos.

7. Usa una ventana deslizante

La última técnica conserva solo los N mensajes más recientes, por ejemplo los diez últimos, junto con un resumen de los turnos anteriores y un pequeño almacén de datos importantes. Cada petición lleva una ventana reciente limitada más lo esencial del pasado, en lugar de la transcripción completa.

La parte reciente podría tener este aspecto:

Recent context:
Message 31
Message 32
...
Message 40

y la parte que lleva la información antigua, este:

Earlier summary:
User is building a Python CLI app.
Click was selected.
Three commands have been implemented.Important memory:
Tests and documentation are still pending.

Es un enfoque sencillo que se sostiene bien y encaja en una enorme variedad de casos de uso. Muchos chatbots usan alguna variante porque equilibra de forma práctica el contexto, el coste y la calidad.

Por dónde empezar

En resumen, las siete técnicas son:

1. compresión del contexto
2. poda de mensajes y filtrado por relevancia
3. delegación del cálculo en herramientas
4. prompts de sistema para las reglas estables
5. referencias en lugar del texto completo
6. salida condensada de las herramientas
7. una ventana deslizante

La compresión, la poda y la salida condensada de las herramientas forman un trío inicial muy sólido, y por sí solas suelen dar grandes mejoras. La lección de fondo es que un agente no tiene que arrastrarlo todo. Tiene que llevar la información correcta. En cuanto se trata el contexto como un recurso escaso y no como una memoria ilimitada, diseñar agentes que escalen resulta mucho más fácil.