Mantén útil el contexto a medida que crece la tarea
Unos 19 minutos de lectura, con 5 ejemplos en 10 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.2. Lee el original
En esta página
- La ventana que tiene el modelo
- Dónde las ejecuciones registradas se acercaron más al presupuesto
- Estima el prompt cuando el arnés no puede contarlo
- Coloca el último resultado al final
- Compacta los pasos más antiguos y conserva el último par
- Guarda las notas fuera del contexto
- Qué hizo el modelo registrado con el presupuesto
- Mide el efecto en lugar de citarlo
- Cómo falla un presupuesto, y cómo notarlo
- Decisiones que tomó este capítulo
Al final de este capítulo podrás calcular cuánto espacio le queda al prompt de una ejecución, estimar el tamaño de un prompt cuando el arnés no puede contarlo con exactitud, y compactar los pasos más antiguos de una ejecución sin separar una llamada a herramienta de su resultado.
El modelo lee todo su prompt en cada paso: el prompt del sistema, los esquemas de las herramientas, la incidencia y todo lo que la ejecución ha hecho hasta entonces. Ese prompt tiene que caber en la ventana con la que se cargó el modelo, y la respuesta tiene que caber en la misma ventana. Una ejecución que sigue leyendo archivos acaba quedándose sin espacio.
El problema aparece en las ejecuciones más largas del caso. El agente de mantenimiento de unitcraft, la biblioteca del capítulo 1, lee archivos, ejecuta las pruebas e intenta una edición, y cada lectura añade un archivo completo al prompt. En el conjunto de tareas registrado, T-16 llegó al límite de 16 pasos del capítulo 2, y su último prompt fue el más grande de todos los pasos del conjunto. Según los recuentos registrados, ese último prompt dejó 612 tokens libres, así que allí las ejecuciones registradas estuvieron más cerca de la ventana. El resto del capítulo explica lo que el arnés debe hacer cuando un prompt no cabe.
La ventana que tiene el modelo
El modelo grabado es Qwen3-4B-Instruct-2507, ejecutado desde el archivo GGUF que el capítulo 1 presentó. El arnés lo carga con un contexto de 8192 tokens, y el manifiesto de la grabación guarda ese mismo valor como n_ctx. Es un ajuste de carga que eligió el arnés. El modelo en sí admite mucho más: su tarjeta de modelo indica una longitud de contexto nativa de 262,144 tokens (tarjeta de modelo), consultada en la rama principal de la tarjeta. Este libro ejecuta el modelo con la ventana más pequeña, así que el número que necesita el presupuesto es el que carga la ejecución.
El manifiesto también guarda max_tokens, el máximo que puede ocupar la respuesta: 1024 tokens. La respuesta sale de la misma ventana que el prompt, así que el prompt recibe lo que la respuesta deje libre.
La aritmética es sencilla. 8192 tokens, menos 1024 para la respuesta, dejan 7168 tokens para todo lo que el modelo lee en un paso. El prompt contiene el prompt de sistema, los esquemas de herramientas, la incidencia, las notas, los pasos anteriores y el último resultado de herramienta, y todo cuenta contra ese presupuesto. Una negativa también es un resultado de herramienta como cualquier otro: el arnés devuelve su texto al modelo como mensaje de herramienta, así que también cuenta contra el presupuesto. Este capítulo lo llama el presupuesto del prompt.
1"""The context the harness loads the model with, the room the reply keeps, and each run's largest prompt against them.2The point rests on the line of steps over the prompt budget: no recorded step reached it."""3import json45from lib.context import PROMPT_BUDGET, REPLY, WINDOW6from lib.models import RECORDED78folder = RECORDED / "task-set"9manifest = json.loads((folder / "manifest.json").read_text(encoding="utf-8"))10steps = [json.loads(line) for line in (folder / "replies.jsonl").read_text(encoding="utf-8").splitlines()]11assert manifest["n_ctx"] == WINDOW and manifest["max_tokens"] == REPLY, "the budget comes from the recorded load settings"1213print("load setting, n_ctx, in tokens:", WINDOW) # the harness's own load setting, not the model's native length14print("reply reservation, max_tokens, in tokens:", REPLY)15print("prompt budget, in tokens:", PROMPT_BUDGET)16print("steps recorded:", len(steps))17# ties go to the later run and step, so the same step is named on every run18largest = max(steps, key=lambda s: (s["prompt_tokens"], s["run"], s["step"]))19print("largest prompt, in tokens:", largest["prompt_tokens"])20print("largest prompt, run:", largest["run"])21print("largest prompt, step:", largest["step"])22print("room left for the reply at the largest step:", WINDOW - largest["prompt_tokens"] - REPLY)23print("steps over the prompt budget:", sum(s["prompt_tokens"] > PROMPT_BUDGET for s in steps))24for task in sorted(manifest["tasks"], key=lambda t: t["task"]):25 mine = [s["prompt_tokens"] for s in steps if s["run"] == task["task"]]26 print(f"{task['task']}: steps {len(mine)}, largest prompt {max(mine)}")27 assert len(mine) == task["steps"], "the stored step count must match the replies"
python budget-counts-tokens.pyload setting, n_ctx, in tokens: 8192
reply reservation, max_tokens, in tokens: 1024
prompt budget, in tokens: 7168
steps recorded: 220
largest prompt, in tokens: 6556
largest prompt, run: T-16
largest prompt, step: 16
room left for the reply at the largest step: 612
steps over the prompt budget: 0
T-01: steps 16, largest prompt 4519
T-02: steps 16, largest prompt 4419
T-03: steps 12, largest prompt 3429
T-04: steps 5, largest prompt 2545
T-05: steps 5, largest prompt 2389
T-06: steps 16, largest prompt 6143
T-07: steps 9, largest prompt 4919
T-08: steps 7, largest prompt 3123
T-09: steps 6, largest prompt 2400
T-10: steps 16, largest prompt 5493
T-11: steps 16, largest prompt 3139
T-12: steps 12, largest prompt 3997
T-13: steps 16, largest prompt 4880
T-14: steps 7, largest prompt 2763
T-15: steps 10, largest prompt 3052
T-16: steps 16, largest prompt 6556
T-17: steps 9, largest prompt 2878
T-18: steps 4, largest prompt 1559
T-19: steps 9, largest prompt 4204
T-20: steps 13, largest prompt 4183
Antes de imprimir nada, el código comprueba que el manifiesto de la grabación indica la misma ventana y el mismo límite de respuesta que el arnés, y detiene la ejecución si no coinciden. Después imprime el presupuesto y el prompt más grande de cada ejecución frente a él.
Una API alojada tiene una ventana mucho más grande. La página de edición de contexto de la documentación de la API de Anthropic indica 100,000 tokens de entrada como el disparador por defecto para borrar resultados de herramientas antiguos (edición de contexto). Un disparador de 100,000 tokens nunca se activaría en una ventana de 8192 tokens, así que este libro toma su presupuesto del ajuste de carga del modelo que graba, y nunca del valor por defecto de un proveedor.
Regla práctica: Toma la ventana del ajuste de carga que usó la ejecución, tal como lo registra el manifiesto, y resta el límite de la respuesta antes de fijar cualquier presupuesto. Nunca la tomes de la longitud anunciada de un modelo ni del valor por defecto de un proveedor, porque un presupuesto copiado de un modelo más grande permite que una ejecución llene la ventana antes de que el presupuesto actúe.
Dónde las ejecuciones registradas se acercaron más al presupuesto
La grabación guarda, para cada paso, el recuento de prompt que informó el modelo, en replies.jsonl. El adaptador devuelve ese recuento como prompt_tokens, tal como el capítulo 4 define la respuesta, así que estos son los propios recuentos del modelo. El arnés no los estimó.
Con esos recuentos, ningún paso registrado alcanzó el presupuesto de prompt. De los 220 pasos registrados, 0 lo superaron. El mayor fue el último paso de T-16, y dejó 612 tokens de la ventana libres una vez reservado el espacio para la respuesta. La comprobación lee la grabación y no carga ningún modelo, así que cualquiera puede ejecutarla sin el hardware que produjo la grabación. La misma comprobación, aplicada a cualquier grabación nueva, muestra de inmediato si sus prompts siguen cabiendo en el presupuesto, por lo que es lo primero que conviene volver a ejecutar tras un cambio de modelo.
Ese resultado dice menos de lo que parece. El conjunto de tareas registrado usó el conjunto de herramientas v1 sin nada entre el bucle y el modelo que pudiera acortar o rechazar un prompt. Nada se compactó, y ningún paso se recortó para encajar. Los recuentos muestran que estos prompts caben. No muestran qué hace el arnés cuando un prompt no cabe, y el resto de este capítulo trata de ese caso.
Regla práctica: Compara el recuento de cada paso con el presupuesto de prompt antes de sacar conclusiones de una ejecución.
Estima el prompt cuando el arnés no puede contarlo
El recuento exacto proviene del tokenizador propio del modelo, que forma parte del archivo del modelo. Los ejemplos de este libro se ejecutan sin conexión y nunca abren ese archivo, que pesa unos 2.5 GB y no aparece en el libro. Por eso el arnés estima. Cuenta los caracteres de cada mensaje y de los esquemas de las herramientas, y divide entre tres, redondeando hacia arriba: un token por cada 3 caracteres.
Elegimos tres después de observar la grabación del conjunto de tareas. La primera regla que probamos fue de cuatro caracteres por token. En los 220 pasos del conjunto de tareas, con cuatro caracteres por token la estimación quedó por debajo del recuento real en 216 de ellos. Una estimación por debajo del recuento es la dirección peligrosa, porque el arnés creería que tiene espacio que el modelo no tiene. Por eso pasamos a tres.
La estimación de cada paso puede compararse con el recuento que el modelo informó para ese mismo paso.
1"""The estimate of each recorded request against the prompt count the model reported for it. The rule was chosen on2task-set; chapter-5-notes was recorded after the rule was fixed, so its lines are the held-out check. The point rests3on the steps below the recorded count: none, in either recording."""4import json56from lib.case import load_tasks7from lib.context import CHARS_PER_TOKEN, PROMPT_BUDGET, Measured, Notes, characters, estimate, notes_toolset8from lib.loop import Stops, run_task9from lib.models import RECORDED, ReplayModel10from lib.tools import V111from lib.trace import IdCounter121314def replay(recording, tasks, tools, **limits):15 """Every request the recorded runs sent: its messages, its tool schemas and the count the model reported."""16 ids, requests = IdCounter(), [] # the replay rebuilds each request, so each estimate sees the messages the model saw17 for task in tasks:18 model = Measured(ReplayModel(recording, task.id))19 run_task(model, task, tools, ids=ids, **limits).close()20 requests += model.requests21 return requests222324def report(name, requests):25 """Prints the comparison of the estimate with the count, labelled with the recording's name, and returns the pairs."""26 pairs = [(estimate(m, t), n) for m, t, n in requests]27 print(f"{name} steps compared:", len(pairs))28 print(f"{name} characters per token, recorded (all steps):",29 f"{sum(characters(m, t) for m, t, _ in requests) / sum(n for _, n in pairs):.2f}")30 print(f"{name} steps where the estimate is above the recorded count:", sum(e > n for e, n in pairs))31 print(f"{name} steps where the estimate is below the recorded count:", sum(e < n for e, n in pairs))32 print(f"{name} lowest estimate divided by the recorded count: {min(e / n for e, n in pairs):.2f}")33 print(f"{name} highest estimate divided by the recorded count: {max(e / n for e, n in pairs):.2f}")34 assert all(e >= n for e, n in pairs), f"{name}: the rule should never count fewer tokens than the model did"35 return pairs363738manifest = json.loads((RECORDED / "chapter-5-notes" / "manifest.json").read_text(encoding="utf-8"))39assert manifest["context"]["chars_per_token"] == CHARS_PER_TOKEN, "the held-out recording used the same rule"40print(f"estimate rule, characters per token: {CHARS_PER_TOKEN}")41task_set = replay("task-set", load_tasks(), V1, max_steps=V1.step_cap)42pairs = report("task-set", task_set)43# four is the rule a reader would try first: it is the one the comparison is against44print("task-set with 4 characters per token, steps below the recorded count:",45 sum(estimate(m, t, 4) < n for m, t, n in task_set))46print("task-set steps whose estimate is over the prompt budget:", sum(e > PROMPT_BUDGET for e, _ in pairs))47print("of those, steps whose recorded count is within the budget:",48 sum(e > PROMPT_BUDGET and n <= PROMPT_BUDGET for e, n in pairs))49report("held-out", replay("chapter-5-notes", load_tasks(only=["T-01", "T-02", "T-06"]), notes_toolset(Notes()),50 max_steps=16, stops=Stops(repeat_limit=3, no_progress_limit=2)))
python estimate-vs-recorded.pyestimate rule, characters per token: 3
task-set steps compared: 220
task-set characters per token, recorded (all steps): 3.67
task-set steps where the estimate is above the recorded count: 220
task-set steps where the estimate is below the recorded count: 0
task-set lowest estimate divided by the recorded count: 1.14
task-set highest estimate divided by the recorded count: 1.35
task-set with 4 characters per token, steps below the recorded count: 216
task-set steps whose estimate is over the prompt budget: 3
of those, steps whose recorded count is within the budget: 3
held-out steps compared: 18
held-out characters per token, recorded (all steps): 3.74
held-out steps where the estimate is above the recorded count: 18
held-out steps where the estimate is below the recorded count: 0
held-out lowest estimate divided by the recorded count: 1.22
held-out highest estimate divided by the recorded count: 1.29
La estimación estuvo por encima del recuento registrado en los 220 pasos, y nunca por debajo. La razón entre estimación y recuento osciló entre 1.14 y 1.35. Los recuentos registrados incluyen los tokens de la plantilla de chat, que la estimación no cuenta, así que el promedio de 3.67 caracteres por token es una razón para este formato de prompt, no para el texto solo.
El precio del lado seguro también es visible. Tres pasos tuvieron una estimación por encima del presupuesto del prompt, y en los tres el recuento propio del modelo estaba dentro de él. Un arnés que confiara en la estimación habría compactado esos pasos sin motivo.
La regla se eligió con los pasos del conjunto de tareas, así que esos pasos no pueden ponerla a prueba. La comprobación con datos reservados (held-out) es la grabación de las notas del capítulo 5. Se hizo después de fijar la regla, y sus recuentos no se usaron para elegirla. Sus 18 pasos reservados muestran el mismo patrón: ninguno por debajo del recuento, con razones de 1.22 a 1.29, y 3.74 caracteres por token. Es el mismo modelo y un texto similar, así que no demuestra que la regla valga para otro tokenizador, otro idioma o código lleno de símbolos.
Regla práctica: Estima con tres caracteres por token, y compara la estimación con los recuentos que el modelo informa en las primeras ejecuciones de cualquier modelo nuevo. Si alguna vez la estimación queda por debajo del recuento informado, usa un número menor de caracteres por token antes de confiar en el presupuesto.
Coloca el último resultado al final
Dónde se ubica un dato dentro de un prompt importa tanto como si está o no. En un artículo de 2023, Liu y colaboradores encontraron que el rendimiento solía ser más alto cuando la información relevante aparecía al principio o al final de una entrada larga, y que caía cuando quedaba en el medio (Lost in the Middle). Esos modelos son más antiguos que el que este libro registra, así que el artículo describe un patrón en modelos antiguos, no lo que Qwen3-4B-Instruct-2507 hace con un prompt largo.
El diseño del libro coloca la incidencia y las notas cerca del inicio, y el último resultado de herramienta al final, donde el modelo lo lee por última vez antes de responder. Esa es la regla de diseño del libro. Ninguna fuente aquí dice que el último resultado deba ir al final, y el libro no ha medido esta disposición en este modelo. El artículo es la razón de la elección. El ejemplo de compactación más abajo imprime cada mensaje que recibe el modelo en la última llamada, en orden: el prompt del sistema, el problema, el resumen, la última llamada y su resultado.
La disposición tiene un costo. La compactación pone el resumen de los pasos anteriores entre el problema y la última llamada con su resultado, que es el medio del prompt. Según el patrón que describe el artículo, ahí es donde un modelo usaría peor la información. El libro acepta ese costo.
Regla práctica: Coloca el problema y las notas primero, y el último resultado de herramienta al final. Considera eso una decisión de diseño, y atribuye una mejora solo cuando una ejecución con tus propias tareas la demuestre.
Compacta los pasos más antiguos y conserva el último par
Cuando la estimación supera el presupuesto de prompt, el harness compacta. La compactación aquí es local: el harness escribe el resumen por sí mismo, y el modelo nunca ve cómo se escribe. Los pasos más antiguos se convierten en un solo mensaje con una línea por paso: la llamada, sus argumentos recortados a 60 caracteres y la primera línea de su resultado, también recortada a 60 caracteres. El prompt del sistema y el issue se mantienen tal como están. El último paso, su llamada y su resultado, se incluye palabra por palabra, de modo que el modelo vea la evidencia más reciente completa.
Los proveedores también ofrecen compactación en sus servidores. La guía de compactación de Anthropic describe una: la compactación "reemplaza los turnos más antiguos de una conversación con un resumen que Claude escribe en el servidor" (compactación). Su forma bajo demanda es una beta, detrás del encabezado compact-2026-09-04. El libro no usa la forma del servidor, y nada de este capítulo depende de cómo se comporte. Leímos esa página y no la ejecutamos.
La regla de corte es la que más importa en un harness local. La guía del proveedor sobre cómo conservar los turnos recientes lo dice con claridad: "Coloca el corte donde no quede abierta ninguna llamada a herramienta, con cada llamada a herramienta y su resultado del mismo lado" (conservar turnos recientes). Un corte que cae sobre un resultado de herramienta deja ese resultado sin la llamada que lo pidió, así que el harness rechaza ese corte.
Cuatro lecturas y un cierre, con un presupuesto de 2000 tokens estimados, bastan para superarlo. Ese presupuesto está muy por debajo del 7168 real, a propósito, para que la compactación ocurra en una tarea pequeña. La tarea no alcanza el presupuesto real.
1"""Four reads of the case, then finish, under a small budget that the reads cross. The point rests on the calls2compacted line and the last two lines: the summary replaces the older steps, and a cut that would leave the last3call's result on its own is refused."""4from lib.case import load_tasks5from lib.chapter1 import call6from lib.context import Compacting, Context, Measured, clean_cut, estimate7from lib.loop import run_task8from lib.models import ScriptedModel9from lib.tools import V210from lib.trace import IdCounter1112# estimated tokens: above the fixed part and one result, below the full transcript; the chapter's budget is 7168,13# which the case's files never reach14BUDGET = 200015replies = [call("read_file", path=p) for p in ("unitcraft/convert.py", "unitcraft/units.py", "unitcraft/parse.py",16 "README.md")] + [call("finish", summary="Read four files.")]17ctx = Context(prompt_budget=BUDGET)18model = Compacting(Measured(ScriptedModel(replies)), ctx)19run = run_task(model, load_tasks(only=["T-01"])[0], V2, max_steps=V2.step_cap, ids=IdCounter())20sent, tools, _ = model.inner.requests[-1]21# the last request: system prompt, issue, summary, the last call, its result22print("budget, in estimated tokens:", BUDGET)23print("steps:", run.steps)24print("ended:", run.ended)25print("calls compacted:", ctx.compactions)26print("calls still over the budget:", ctx.over_budget)27print("fixed part (system prompt, tool schemas, issue), estimated tokens:", estimate(sent[:2], tools))28print("messages sent on the last call:", len(sent))29for number, message in enumerate(sent, start=1):30 print(f"message {number}, {message['role']}:", " ".join(message["content"].split()[:4]))31# the summary's first line is its heading, so the steps start at the second line32print("summary of the older steps:", *sent[2]["content"].splitlines()[1:], sep="\n ")33# the call is wrapped in <tool_call> tags, so its JSON is the second line34print("kept call:", sent[3]["content"].strip().splitlines()[1][:60])35print("kept result, in lines:", len(sent[4]["content"].splitlines()))36print("cut before the last result alone, clean:", clean_cut(sent, len(sent) - 1))37print("cut before the last call, clean:", clean_cut(sent, len(sent) - 2))38assert ctx.compactions > 0 and not clean_cut(sent, len(sent) - 1) and clean_cut(sent, len(sent) - 2)
python compact-keeps-last-result.pybudget, in estimated tokens: 2000
steps: 5
ended: finish
calls compacted: 3
calls still over the budget: 0
fixed part (system prompt, tool schemas, issue), estimated tokens: 1289
messages sent on the last call: 5
message 1, system: You are a maintenance
message 2, user: `format_quantity` drops the trailing
message 3, user: Earlier steps, summarised by
message 4, assistant: <tool_call> {"name": "read_file", "arguments":
message 5, tool: # unitcraft unitcraft parses,
summary of the older steps:
step 1: read_file({"path": "unitcraft/convert.py"}) -> """convert: change a quantity to another unit of the same di
step 2: read_file({"path": "unitcraft/units.py"}) -> """The unit table: each symbol with its dimension and its fa
step 3: read_file({"path": "unitcraft/parse.py"}) -> """parse_quantity: read a quantity written as text, such as
kept call: {"name": "read_file", "arguments": {"path": "README.md"}}
kept result, in lines: 42
cut before the last result alone, clean: False
cut before the last call, clean: True
La ejecución compactó 3 llamadas antiguas, y la última llamada y su resultado llegaron completos: una lectura de README.md, cuyo resultado tenía 42 líneas. La parte fija, el prompt del sistema, los esquemas de las herramientas y el issue, sumó 1289 tokens estimados. La compactación no puede recortar esa parte, así que un presupuesto por debajo de ella no puede cumplirse con ninguna compactación.
Al final se imprimen dos cortes. Un corte antes del último resultado, por sí solo, se rechaza, y un corte antes de su llamada es válido. El código verifica ambos, de modo que un cambio en cualquiera de ellos hace fallar la ejecución.
Regla práctica: Conserva juntos la última llamada y su resultado, rechaza cualquier corte que caiga sobre un resultado de herramienta y comprueba que la parte fija quepa en el presupuesto antes de confiar en la compactación para que el resto quepa.
Guarda las notas fuera del contexto
La compactación pierde detalle por diseño. La entrada de Anthropic sobre ingeniería de contexto lo plantea como una elección: "El arte de la compactación está en seleccionar qué conservar y qué descartar, porque una compactación demasiado agresiva puede hacer perder contexto sutil pero crítico, cuya importancia solo se hace evidente más adelante" (Effective context engineering for AI agents). La misma entrada describe la forma de evitarlo, con notas guardadas fuera de la ventana, y no informa de ninguna medición sobre ellas.
El arnés añade una herramienta note. El modelo escribe una línea por cada hecho, y el arnés envía las notas junto con el problema en cada paso. La compactación no las recorta, porque no forman parte de los pasos antiguos. Un hecho que el modelo escribe como nota sobrevive a cualquier compactación. Un hecho que solo permanece en un resultado antiguo se conserva como mucho como primera línea de ese resultado.
1"""A note the agent writes keeps a fact that an older read result had, after a compaction. The summary keeps only the2first line of each read, and the fact sits on line 18 of format.py, so the read's summary line lacks it while the note3keeps it whole. The point rests on the last assertions: the fact is in the notes block and not in the read's line."""4from lib.case import load_tasks5from lib.chapter1 import call6from lib.context import Compacting, Context, Measured, Notes, notes_toolset7from lib.loop import run_task8from lib.models import ScriptedModel9from lib.trace import IdCounter1011BUDGET = 2000 # estimated tokens: the notes and the reads cross it, the last request fits under it12# each note states a fact the run has just read in the case, so every note is true of unitcraft13notes = [14 "format_quantity strips trailing zeros on line 18 of format.py (frac.rstrip), so 3.50 kg prints as 3.5 kg",15 "test_pads_to_two_places in tests/test_format.py expects 3.5 kg to print as 3.50 kg, so the strip fails it",16 "round_places goes through float, so 2.675 rounds to 2.67, and test_tie_at_a_binary_float_edge expects 2.68",17]18replies = [call("read_file", path="unitcraft/format.py"), call("note", text=notes[0]),19 call("read_file", path="tests/test_format.py"), call("note", text=notes[1]),20 call("read_file", path="unitcraft/rounding.py"), call("note", text=notes[2]),21 call("read_file", path="README.md"), call("finish", summary="Read the case and noted the failing tests.")]22store = Notes()23ctx = Context(notes=store, prompt_budget=BUDGET) # the notes are kept outside the older steps, so compaction keeps them24model = Compacting(Measured(ScriptedModel(replies)), ctx)25run = run_task(model, load_tasks(only=["T-01"])[0], notes_toolset(store), max_steps=16, ids=IdCounter())26sent = model.inner.requests[-1][0]27block = next(m["content"] for m in sent if m["content"].startswith("Your notes so far"))28summary = next(m["content"] for m in sent if m["content"].startswith("Earlier steps"))29read_line = summary.splitlines()[1] # the first step: the read of format.py, with its first result line cut short30print("steps:", run.steps)31print("ended:", run.ended)32print("compactions:", ctx.compactions)33print("notes written:", len(store.lines))34print("notes whole in the notes block:", sum(line in block for line in store.lines))35print("lines in the notes block that name the fact (rstrip):", sum("rstrip" in line for line in block.splitlines()))36print("summary line for the read of format.py:", read_line)37assert ctx.compactions > 0, "the run should compact"38assert all(line in block for line in store.lines), "every note should be whole in the notes block"39assert "format.py" in read_line and "rstrip" not in read_line, "the read's summary line must lack the fact"40assert "rstrip" in block, "the note must keep the fact"
python notes-survive.pysteps: 8
ended: finish
compactions: 5
notes written: 3
notes whole in the notes block: 3
lines in the notes block that name the fact (rstrip): 1
summary line for the read of format.py: step 1: read_file({"path": "unitcraft/format.py"}) -> """format_quantity: write a quantity as text, such as ``3.50
Este ejemplo es un script, no el modelo. Un ScriptedModel lee cuatro archivos y escribe tres notas, cada una justo después de la lectura de la que procede. El hecho está en la línea 18 del archivo, y el resumen solo conserva la primera línea del archivo, así que en el resumen la línea correspondiente a esa lectura contiene la docstring y no el hecho. La ejecución compactó 5 veces. Las 3 notas aparecen completas en el bloque de notas de la última petición, y 1 de esas líneas nombra el hecho. Cada nota recoge algo que la ejecución había leído en el caso, así que puedes comprobar cada una contra los archivos del caso.
Eso muestra el mecanismo. No demuestra que un modelo vaya a escribir las notas. La siguiente sección lo comprueba con una grabación del modelo.
Regla práctica: Escribe en una nota todo hecho que un paso posterior necesite, no solo en el resumen. Un resumen conserva una selección, y las notas son el único lugar donde el libro guarda un hecho completo.
Qué hizo el modelo registrado con el presupuesto
La grabación chapter-5-notes se hizo con el conjunto de herramientas v2 del capítulo 3, la herramienta de notas y las reglas de parada del capítulo 2. Sus tres ejecuciones son T-01, T-02 y T-06. Siete ejecuciones del conjunto de tareas alcanzaron el límite de pasos de 16 (T-01, T-02, T-06, T-10, T-11, T-13, T-16), y el guion de la grabación nombra estas tres como las ejecuciones largas que llegaron cada una a ese límite. No ejecuta las otras cuatro. Repetimos las tres ejecuciones con la compactación activada, para ver qué hizo el modelo con las herramientas y el presupuesto.
1"""The three recorded runs of chapter 5, replayed with the compaction on: how each ended, whether its check passed,2its note calls and compactions, and its largest prompt by the estimate and by the count the model reported. The point3rests on the check lines and the zero counts: no run passed its check, and no run wrote a note or was compacted."""4import json56from lib.case import load_tasks7from lib.context import Compacting, Context, Measured, Notes, estimate, notes_toolset8from lib.loop import Stops, run_task9from lib.models import RECORDED, ReplayModel10from lib.trace import IdCounter1112manifest = json.loads((RECORDED / "chapter-5-notes" / "manifest.json").read_text(encoding="utf-8"))13recorded = {t["task"]: t for t in manifest["tasks"]} # the recording's own check result, stored with each run14ids, passed, notes_total, compact_total, est_max, rec_max = IdCounter(), 0, 0, 0, 0, 015for task in load_tasks(only=["T-01", "T-02", "T-06"]):16 notes = Notes()17 context = Context(notes=notes) # the default budget, 7168 tokens, which no run reaches18 model = Compacting(Measured(ReplayModel("chapter-5-notes", task.id)), context)19 # the step cap of 16 and the stop rules are those the recording was made with20 run = run_task(model, task, notes_toolset(notes), max_steps=16, ids=ids,21 stops=Stops(repeat_limit=3, no_progress_limit=2))22 run.close()23 print(f"{task.id} kind: {recorded[task.id]['kind']}")24 print(f"{task.id} ended: {run.ended}")25 print(f"{task.id} check passed: {'yes' if recorded[task.id]['done'] else 'no'}")26 print(f"{task.id} note calls: {sum(r['tool'] == 'note' for r in run.trace.records)}")27 print(f"{task.id} compactions: {context.compactions}")28 passed += recorded[task.id]["done"]29 notes_total += sum(r["tool"] == "note" for r in run.trace.records)30 compact_total += context.compactions31 est_max = max([est_max] + [estimate(m, t) for m, t, _ in model.inner.requests])32 rec_max = max([rec_max] + [n for _, _, n in model.inner.requests])33print("total note calls:", notes_total)34print("total compactions:", compact_total)35print("runs whose check passed:", passed)36print("largest estimated prompt over the three runs, in tokens:", est_max)37print("largest recorded prompt over the three runs, in tokens:", rec_max)38assert notes_total == 0, "the recorded runs made no note calls"39assert compact_total == 0, "the recorded runs were never compacted"40assert passed == 0, "none of the three recorded runs passed its check"
python recorded-context-use.pyT-01 kind: fix
T-01 ended: ask_user
T-01 check passed: no
T-01 note calls: 0
T-01 compactions: 0
T-02 kind: fix
T-02 ended: finish
T-02 check passed: no
T-02 note calls: 0
T-02 compactions: 0
T-06 kind: implement
T-06 ended: no_progress
T-06 check passed: no
T-06 note calls: 0
T-06 compactions: 0
total note calls: 0
total compactions: 0
runs whose check passed: 0
largest estimated prompt over the three runs, in tokens: 4012
largest recorded prompt over the three runs, in tokens: 3189
El modelo no escribió notas en ninguna de las tres ejecuciones, y no se compactó ninguna. El prompt más grande que vio la estimación fue de 4012 tokens, y el más grande que informó el modelo fue de 3189. Ambos están por debajo del presupuesto de prompt.
Cada ejecución terminó antes de que su contexto se acercara al presupuesto, y ninguna superó su comprobación. T-01 terminó como ask_user, cuando el modelo le hizo una pregunta a la persona. T-01 es una tarea de corrección, así que esa pregunta fue un traspaso incorrecto. T-02 terminó como finish, cuando el modelo llamó a finish, y su comprobación no se superó. T-06 terminó como no_progress, que es la regla de parada del capítulo 2: dos ediciones seguidas dejaron sin cambios los recuentos de pruebas. Así, el modelo detuvo por sí mismo dos ejecuciones, ambas de forma incorrecta, y una regla de parada detuvo la tercera. Al imprimir los resultados de comprobación ejecución por ejecución, se obtienen 0 aprobadas de las tres.
Tres ejecuciones en tres tareas muestran lo que ocurrió en esas tareas, y nada sobre las otras diecisiete. Estas ejecuciones no ponen a prueba ni el presupuesto ni las notas.
Regla práctica: Antes de juzgar un presupuesto o una herramienta por una grabación, revisa cómo terminó cada ejecución. Una ejecución que se detiene pronto nunca pone a prueba el presupuesto, y un modelo que nunca llama a una herramienta nunca pone a prueba la herramienta.
Mide el efecto en lugar de citarlo
Un informe técnico de Chroma de julio de 2025, "Context Rot" de Hong, Troynikov y Huber, encontró que "el rendimiento del modelo varía significativamente a medida que cambia la longitud de la entrada, incluso en tareas sencillas" (Context Rot). El informe evalúa 18 LLM de varios proveedores, entre ellos Qwen3, sobre sus propias tareas. Este capítulo no vuelve a ejecutar esas tareas, así que no cita ningún tamaño de efecto de ellas.
En cambio, el libro mide sus propias ejecuciones. El capítulo 10 ejecuta el conjunto de tareas en dos versiones del arnés y compara los resultados como recuentos de tareas terminadas. El arnés v2 añade el presupuesto entre otros varios cambios, de modo que esa comparación no puede atribuir el resultado solo al presupuesto. Una ejecución hija en el capítulo 8 mantiene un presupuesto propio, contado sobre sus propios pasos.
Cada ejemplo de aquí mide otra cosa. El ejemplo del presupuesto mide dónde se situaban los prompts registrados, y los ejemplos de compactación y de notas miden lo que el arnés conserva. Ninguno mide cómo la longitud afecta las respuestas de un modelo, así que este capítulo no afirma que un prompt largo cueste precisión.
Regla práctica: Mide cómo un presupuesto cambia tu propio conjunto de tareas, con los recuentos que informan las ejecuciones, antes de afirmar que ayuda. Cita un efecto publicado solo con su configuración y su fuente, y únicamente como resultado de ese informe.
Cómo falla un presupuesto, y cómo notarlo
Cuatro cosas salen mal con los presupuestos en la práctica, y cada una puede notarse.
La primera es un modelo cambiado. Un modelo nuevo puede tener una ventana, un tokenizador o un límite de respuesta distintos. El presupuesto queda entonces mal sin que aparezca ningún error, porque la comprobación sigue ejecutándose y sigue pasando con el número antiguo. Lo notas cuando la ventana del manifiesto de la grabación ya no coincide con la constante que usa el arnés, así que mantén ambos vinculados y haz fallar una ejecución cuando difieran. La sección sobre la ventana explica la comprobación.
La segunda es una estimación que se desvía. La estimación es solo tan buena como la regla de caracteres por token para el modelo y el texto que tiene delante. La respuesta ya trae el recuento propio del modelo, así que compara ambos en cada paso de las primeras ejecuciones reales y registra los pares. Una estimación por debajo del recuento es la señal para actuar, porque entonces el arnés cree que tiene espacio que en realidad no tiene.
La tercera es un resumen que elimina lo que un paso posterior necesita. Una ejecución compactada puede volver a llamar a la misma herramienta, porque el primer resultado ahora es una línea dentro de un resumen. Las reglas de parada del capítulo 2 detectan repeticiones exactas, pero una casi repetición, como una lectura del mismo archivo con una ruta ligeramente distinta, las supera. Cuenta las lecturas que hace una ejecución del mismo archivo, y trata una repetición como señal de que el resumen perdió algo.
La cuarta es un bloque de notas que crece. Las notas se envían en cada paso y la compactación nunca las recorta, y nada limita la longitud de una nota ni cuántas hay. Una ejecución que escribe muchas notas hace crecer su parte fija hasta que la compactación ya no puede cumplir el presupuesto. El contexto cuenta en over_budget las llamadas que siguen sobre el presupuesto después de la compactación, y un recuento mayor que cero es la señal.
Regla práctica: Registra la estimación y el recuento informado en cada paso de una ejecución real, y trata una estimación por debajo del recuento como un fallo. Cuando una ejecución pida un archivo que su propio resumen ya cubre, revisa qué conservó el resumen antes de que la ejecución vuelva a leer el archivo.
Decisiones que tomó este capítulo
- El presupuesto de prompt es el ajuste de carga menos el espacio reservado para la respuesta, y sigue al ajuste de carga, no a la longitud anunciada por el modelo.
- El arnés estima el prompt en tres caracteres por token. Los pasos del conjunto de tareas eligieron esa regla, y la grabación posterior de las notas del capítulo 5, que no la eligió, muestra el mismo patrón.
- La compactación es local y determinista, de modo que una ejecución reproducida se compacta exactamente igual que la original. Los pasos más antiguos se convierten en una línea cada uno, y la última llamada y su resultado se conservan palabra por palabra. Un corte que cae sobre el resultado de una herramienta se rechaza.
- Las notas son una herramienta que el modelo puede usar. Se envían después de la incidencia en cada paso, de modo que la compactación nunca las corta, y el modelo decide si las escribe.
- El libro no usa la compactación del lado del servidor del proveedor.
Las grabaciones muestran que los prompts caben, y que la estimación se mantuvo por encima del recuento en ambos conjuntos de pasos. Capítulo 10 compara dos versiones del arnés como recuentos, y no puede atribuir mérito solo al presupuesto.
Regla práctica: Indica en qué ejecuciones se probó un presupuesto o una herramienta. Una afirmación sobre un presupuesto que ninguna ejecución alcanzó es una afirmación sobre el diseño, no sobre el modelo.
Este capítulo, en esta edición
Edición 2026.11.2Ejemplos verificados el 20 de nov de 2026Superan la prueba 5 de 5 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.2.