Todo lo que un modelo "sabe" en una respuesta cabe en una única región de tokens acotada que se llena y se reprocesa en cada llamada. Prompt de sistema, historial, skills, memoria, tu mensaje y el espacio para responder comparten el mismo presupuesto. Piénsalo como el límite de memoria de un pod: cuando se llena, algo hay que desalojar.
No hay carpetas ni disco: todo es texto tokenizado en una misma cola. El orden importa (el sistema va primero) y cada categoría gasta parte del mismo presupuesto. Estos son los colores que verás en todo el documento.
Regla mental: ventana de contexto = presupuesto compartido. Si algo entra, algo tiene menos sitio. El "output reservado" (el max_tokens que dejas libre para que el modelo responda) también cuenta: por eso el contexto útil siempre es menor que el techo nominal.
El modelo es sin estado: entre llamadas no recuerda nada. La app de chat crea la ilusión de memoria reenviando toda la conversación (sistema + cada turno anterior + tu mensaje nuevo) en cada petición. Avanza turno a turno y míralo crecer.
Cada turno añade tu mensaje y la respuesta del modelo al historial.
Turno 0. Solo está el prompt de sistema. El modelo aún no ha visto nada tuyo.
El prompt de sistema es un prefijo estable: no cambia entre turnos. Justo por eso es el candidato perfecto para la caché (siguiente sección) — se reenvía siempre igual, así que no hace falta reprocesarlo cada vez.
El input se lee en una sola pasada paralela (prefill): rápido y barato por token. El output se genera de a un token, y cada nuevo token vuelve a mirar todos los anteriores (decode autoregresivo): lento y caro por token. Dale a reproducir.
Fíjate: el input entero se ilumina casi de golpe; el output aparece letra a letra. Por eso los tokens de salida se cobran más caros y dominan la latencia percibida.
Reprocesar el mismo prefijo largo en cada llamada es tirar cómputo. Hay dos cachés distintas — una interna al modelo, otra que tú controlas.
Prefijo estable (sistema + herramientas + skills) = 10 300 tokens, idéntico en cada petición.
Caché KV · interna
Al generar, el modelo guarda las claves/valores de atención de cada token ya procesado, para no recalcular la atención sobre toda la secuencia en cada token nuevo. Es lo que hace viable el decode.
Caché de prompt · API
Persiste el estado ya "precargado" de un prefijo estable para reutilizarlo en peticiones siguientes. La lectura cuesta una fracción del input normal. Tú marcas dónde cortar y tiene un TTL (p. ej. 5 min).
Un agente vuelve a llamar al modelo en bucle: el modelo pide una herramienta, el runtime la ejecuta y devuelve el resultado al contexto. Ese resultado (logs, respuestas de API, YAML de un recurso) suele ser grande — y se acumula en cada iteración. Avanza el bucle y observa la presión.
Cada iteración = una llamada a herramienta + su resultado, anexados a la ventana.
Iteración 0 · el contexto arranca con el prefijo del agente (sistema + herramientas + skills + memoria + objetivo).
Nota cómo el prefijo de un agente ya es mucho más pesado que el de un chat: las definiciones de herramientas y las skills viven ahí. Y cada resultado de herramienta es un bloque naranja que no se va solo.
Así se ve el bucle en un producto real. En KubeBolt, el copilot Kobi no llama al LLM a la primera: una capa de Skills deterministas (L1–L6) decide si hace falta el modelo. Cuando escala, propone un comando, un humano lo aprueba y un proxy agent-outbound lo ejecuta contra el cluster — sin exponer el API server. Todo medido en la misma ventana.
Escenario: alerta CrashLoopBackOff en pago-svc.
Determinismo primero
La capa de Skills L1–L6 se ejecuta antes de cualquier llamada al modelo. Si una regla resuelve el incidente, la ventana ni se toca: cero tokens de LLM, coste ~$0. Es una inversión de control — lo contrario a "todo pasa por el modelo".
Proxy agent-outbound
El agente abre la conexión saliente; el API server nunca queda expuesto. Habilita toda la superficie kubectl con la aprobación humana como gate de control — que cuesta 0 tokens. El resultado que vuelve (logs, describe, YAML) es el bloque naranja que engorda el contexto.
El agente de abajo arranca en sobrecarga: un objetivo largo llenó el contexto. Activa cada estrategia y mira cuánto presupuesto recupera. Son exactamente las palancas que expone un Agent SDK.
Con todo desactivado, el transcript no cabe. Las cuatro estrategias son complementarias: mueven tokens fuera de la ventana o los comprimen, sin perder lo esencial.
Todo — sistema, historial, skills, memoria, input y hueco para el output — comparte una sola cuenta de tokens. Llenar una parte vacía otra.
No recuerda entre llamadas. La "memoria" del chat es la app reenviando la conversación completa cada turno.
El prompt se lee en paralelo (prefill); la respuesta se genera token a token (decode). El output domina costo y latencia.
La caché KV acelera una respuesta; la caché de prompt reutiliza el prefijo entre llamadas y recorta costo y TTFT.
El bucle acumula resultados de herramienta, no turnos de chat. Ese es el principal motor de consumo de contexto.
Carga progresiva de skills, memoria externa, compactación y subagentes: sacar tokens fuera o comprimirlos es lo que mantiene la ventana viva.
Kobi, el copilot de KubeBolt, aplica todo lo de arriba al diagnóstico de Kubernetes: gate determinista, suggest→approve→execute y la ventana siempre bajo control.