Recuperación medida (mastery gate C1)

5.1La pregunta incómoda del sprint

En N0 tu informe decidió la discusión del equipo. No migrasteis de modelo: invertisteis en gestionar el contexto. Esa fue tu recomendación, con su curva y su punto de inflexión debajo.

Han pasado tres lecciones de inversión. Trimming (L2), compaction (L3) y la poda del prompt (L4). Código escrito, nodos añadidos al grafo de Magallanes, decisiones tomadas.

Ahora llega la pregunta que cierra cualquier sprint real: ¿pagó? No "¿se siente mejor?". No "¿parece más estable?". ¿Pagó, en una métrica que alguien pueda discutir?

Hay una sola respuesta admisible, y es la misma curva de entonces — desplazada, con su factura al lado. Esta lección no enseña una técnica nueva. Enseña a cerrar el experimento: medir lo que construiste contra el baseline que mediste, sin engañarte por el camino.

El error que vas a aprender a no cometer es sutil. No es escribir mal el nodo de compaction. Es declararlo bueno midiendo otra cosa — o midiendo bien y olvidando reportar lo que costó.

5.2Qué vas a poder hacer

Al terminar serás capaz de:

• Re-ejecutar el sweep de C0 EXACTO sobre tu Magallanes gestionado y superponer su curva al baseline.
• Construir el caso de control que demuestra que la compaction ingenua rompe lo que la tuya preserva.
• Reportar el coste — tokens y latencia del agente gestionado frente al original — junto a la mejora.
• Autoevaluar un entregable C1 con la rúbrica de 5 dimensiones y detectar dónde flojea.

Necesitas saber antes:

• De L1 (Cuatro palancas, un presupuesto): el mapeo síntoma→palanca y el orden por coste. Lo recuperas en 5.3.
• De L2 y L3: el trimming con trim_messages y el nodo de compaction con preservación explícita. Son las piezas que aquí mides.
• De N0: el sweep reproducible (mismo encargo, ≥4 longitudes, seed fijo) y la curva baseline de Magallanes. Es tu experimento de control.

5.3Recupera (interleave del nivel)

Antes de seguir, responde de memoria. Estas cuatro preguntas mezclan las cuatro lecciones del nivel más una de N0. Recuperar de memoria, mezclado, consolida mejor que releer en orden.

1. Mapeo (L1): un agente repite búsquedas que ya hizo. ¿Qué síntoma es y a qué palanca lo mandas?
2. Trimming (L2): un compañero trimea con include_system=False. ¿Qué fallo concreto esperas?
3. Compaction (L3): tu nodo de compaction preserva tres cosas. ¿Cuáles, y por qué cada una?
4. Altitud (L4): una regla del prompt dice "si la búsqueda devuelve 0 resultados, prueba sinónimos". ¿Señal o lógica frágil?
5. Backward (N0): un agente contradice su sección 2 en la sección 4. ¿Cómo clasificas ese fallo?

5.4El concepto: el checkpoint como experimento controlado

Qué medimos, y contra qué

Aquí está la idea que vertebra todo el nivel. El checkpoint C1 es un experimento controlado, no una demo. Un experimento controlado es una comparación donde se cambia una sola variable y se mide su efecto frente a un control fijo.

El control es el sweep de C0: el mismo encargo, las mismas ≥4 longitudes, el mismo seed que mediste en N0. Esa curva baseline es la referencia inmóvil. Cada intervención que aplicaste se valida re-ejecutando ese sweep sin cambiarle nada y superponiendo la curva nueva a la vieja.

La analogía: es el grupo de control de un ensayo clínico. Mides al mismo paciente, con la misma prueba, antes y después del tratamiento. Dónde falla la analogía: el ensayo clínico controla la confusión con aleatorización entre sujetos. Aquí controlas con un seed fijo sobre el mismo encargo — más barato, pero solo aísla lo que el seed alcanza a fijar.

La regla de oro del nivel, que ya conociste en L1: una intervención por re-ejecución. Si cambias el trimming y la compaction y el prompt a la vez, y la curva sube, no sabes cuál la movió. Podrías estar atribuyendo a la compaction una mejora que dio la poda del prompt.

La rúbrica C1, dimensión a dimensión

El entregable C1 se juzga en cinco dimensiones (03-arquitectura.md, rúbrica fiel). Léelas como un checklist de lo que tu entregable debe demostrar:

Dim 1 — Mapeo síntoma→palanca. Cada intervención justificada desde el diagnóstico de C0. No "apliqué trimming porque sí", sino "el presupuesto de N0 mostró que el historial domina el crecimiento; distraction → compress, y compress es la palanca más barata, por eso primero". El mapeo de L1, con la evidencia de tu traza detrás.

Dim 2 — Compaction con preservación. Lo crítico sobrevive al resumen, demostrado con un caso de control: una compaction ingenua que rompe algo concreto que la tuya no rompe. Esta es la dimensión donde más entregables flojean, y la trataremos aparte en 5.5.

Dim 3 — Altitud del prompt. Zona Goldilocks, secciones organizadas, sin reglas muertas. El prompt podado de L4, ni vago ni sobre-especificado, validado con el harness y no con impresiones.

Dim 4 — Mejora medida. La curva se desplaza. Y "desplazarse" tiene un significado preciso, que vemos ahora.

Dim 5 — Coste reportado. Tokens y latencia del agente gestionado frente al original. La compaction añade un paso de sampling — el resumen es una llamada extra al modelo, y se paga. Reportar la mejora sin la factura es media verdad. · fuente: corpus B.4.

Qué significa "la curva se desplaza"

Una curva mejor no es "más alta en todas partes" necesariamente. Hay dos formas válidas de desplazamiento, y conviene poder nombrarlas:

• Más longitud a la misma calidad: el codo se mueve a la derecha. Magallanes aguanta más documentos inyectados antes de desplomarse. En el sweep de N0, el codo aparecía en las longitudes medias (alrededor de 10–25 documentos, según los datos de tu lab); ahora resiste hasta más.
• Más calidad a la misma longitud: la curva sube en el tramo donde antes caía. A las mismas 50 longitudes, el informe es mejor.

Las dos cuentan como mejora. Tu entregable nombra cuál de las dos consiguió tu gestión — o ambas. Decir solo "mejoró" sin señalar dónde y cómo no supera la dim 4.

Los cuatro errores que invalidan la medición

Normaliza esto, porque cada uno se comete sin darte cuenta y se detecta tarde. Son la versión "con corbata" de medir mal.

1. Cambiar el encargo o el seed al medir la mejora. Si tocas el encargo entre baseline y after, mides otra tarea. Si cambias el seed, mides el azar. La comparación deja de ser válida — y la curva miente con cara de honesta. Es el error nº1 del sweep, que ya viste en el-context-sweep.
2. Un caso de control trivial. Una compaction ingenua que casualmente no rompe nada no demuestra nada. Si tu "ingenua" sale igual de bien que la tuya, no has construido un control: has construido dos cosas que funcionan. El control debe fallar de verdad, en un punto concreto.
3. Atribuir la mejora a dos intervenciones a la vez. Aplicaste trimming y compaction en la misma re-ejecución, la curva subió, y se lo cuelgas a la compaction. No lo sabes. Una intervención por re-ejecución, o no atribuyas.
4. Reportar la mejora sin la factura. La curva sube, pero no dices cuántos tokens costó el nodo de compaction ni cuánta latencia añadió el sampling extra. Una mejora sin coste reportado es un entregable a medias — y en un sprint real, el coste es justo lo que el equipo va a preguntar.

Lo que NO es el checkpoint C1

No es "el agente va mejor, lo noto". Una impresión no es una curva. Tampoco es una curva sin baseline: si no superpones la de N0, no tienes con qué comparar, y "0.85 de calidad" a solas no dice nada. Y no es una curva con la factura escondida: la rúbrica pide las cinco dimensiones, no cuatro.

5.5Míralo: el caso de control de compaction

La dim 2 es donde más entregables se caen, así que la montamos despacio. Lo difícil aquí no es el código del nodo —ese lo escribiste en L3— sino diseñar un control que falle de verdad. Lee el bloque entero una vez antes de la explicación.

La estructura del A/B

El caso de control es un A/B sobre el mismo sweep. Dos nodos de compaction, mismas longitudes, mismo seed, mismo encargo. La única variable que cambia es el prompt de preservación.

• A — compaction ingenua: el prompt dice "resume la conversación hasta ahora". Nada más.
• B — compaction con preservación: el prompt lista qué debe sobrevivir — decisiones tomadas, estado del informe, subtemas pendientes, doc_ids ya leídos.

1# control_compaction.py — A/B sobre el grafo de Magallanes (esqueleto del nivel)
2from magallanes import construir_grafo   # el grafo congelado de N0
3
4# A — el prompt que parece inocuo y es la versión con corbata de tirar el historial
5PROMPT_INGENUO = "Resume la conversación hasta ahora."
6
7# B — preservación EXPLÍCITA: enumera lo que el resumen no puede perder
8PROMPT_PRESERVACION = (
9    "Resume la conversación preservando explícitamente, sin omitir ninguno:\n"
10    "- las DECISIONES ya tomadas sobre el informe (qué se afirmó en cada sección),\n"
11    "- el ESTADO del informe (qué secciones existen y qué dicen),\n"
12    "- los SUBTEMAS PENDIENTES del encargo aún sin cubrir,\n"
13    "- los doc_ids YA LEÍDOS (para no volver a leerlos).\n"
14    "Descarta solo tool outputs redundantes o recuperables."
15)

El PROMPT_PRESERVACION no es decoración. Cada línea blinda contra un síntoma concreto de la taxonomía de N0. Quita la línea de doc_ids y reaparece la distraction (re-lee). Quita la de decisiones y reaparece el clash (se contradice).

Inyectar cada prompt en el nodo del grafo

El nodo de compaction es el que montaste en L3. LangGraph llama a cada nodo como fn(state) — no admite un segundo parámetro arbitrario. Así que el prompt no entra por la firma del nodo: entra por un closure, una función que recuerda el prompt_resumen con el que la creaste. El resto del nodo —el umbral, el RemoveMessage de lo viejo— no cambia.

1# El nodo de compaction del esqueleto del nivel, parametrizado por el prompt de resumen.
2# trim_messages / RemoveMessage: corpus F.1. RemoveMessage exige el reducer add_messages,
3# que MessagesState ya trae.
4from langchain_core.messages import RemoveMessage
5
6def make_nodo_compaction(prompt_resumen: str):
7    # Devuelve un nodo fn(state) válido para LangGraph; el prompt vive en el closure.
8    def nodo_compaction(state):
9        ...  # 1) si el historial supera el umbral (decidido con los datos de N0):
10        viejos = ...                     # los mensajes a destilar
11        ...  # 2) un LLM resume bajo prompt_resumen (A: ingenuo / B: con preservación):
12        mensaje_resumen = ...            # el resumen producido por el LLM
13        # 3) borra lo viejo y deja el resumen en su lugar:
14        return {"messages": [RemoveMessage(id=m.id) for m in viejos] + [mensaje_resumen]}
15    return nodo_compaction
16
17nodo_a = make_nodo_compaction(PROMPT_INGENUO)      # A: compaction ingenua
18nodo_b = make_nodo_compaction(PROMPT_PRESERVACION) # B: compaction con preservación

El bloque de borrado es la línea verificada: RemoveMessage(id=m.id) por cada mensaje viejo, más el mensaje-resumen. El reducer add_messages ejecuta el borrado cuando detecta los RemoveMessage (corpus F.1). El cuerpo del resumen va como ... porque su contenido exacto es decisión de tu lab, no una firma de API.

Cada variante se registra en el grafo como un nodo normal. Construyes el grafo dos veces —una con nodo_a, otra con nodo_b— y compilas cada uno por separado. El sweep es idéntico para ambos: solo cambia qué nodo registras.

1# Mismo grafo, dos compilaciones: la única diferencia es el nodo de compaction.
2def construir(nodo_compaction):
3    builder = construir_grafo()                    # el builder congelado de N0
4    builder.add_node("compaction", nodo_compaction)
5    return builder.compile()
6
7grafo_a = construir(nodo_a)   # ejecución A del sweep
8grafo_b = construir(nodo_b)   # ejecución B del sweep, mismo encargo / longitudes / seed

Correr el A/B sobre el sweep y leer dónde rompe

Reutilizas el sweep.py de el-context-sweep. Lo corres dos veces — una con A, otra con B — y superpones las dos curvas sobre el baseline. La métrica determinista (cobertura de subtemas + citas a doc_ids reales) la tienes ya escrita.

calidad
1.0 |  *                            * = baseline (N0, sin gestión)
    |     o  +                      + = B: compaction con preservación
    |        +     o                o = A: compaction ingenua
0.5 |           +        o
    |              +           o
0.0 +----+----+----+----+----
     0   10   25   50   docs irrelevantes

Lee la forma. La curva B (preservación) aguanta arriba: el codo se ha movido a la derecha frente al baseline. La curva A (ingenua) se cae casi tan pronto como el baseline. Las trazas dicen por qué: a 50 documentos, Magallanes re-lee documentos que ya había leído y contradice su sección 2. El mismo run muerto de N0, ahora con resumen.

Ese punto donde A rompe y B no — documentado con la traza concreta — es la dim 2 de la rúbrica. No vale que B sea mejor en promedio: necesitas el sitio exacto donde la ingenua falla.

Self-explanation

Antes de leer la respuesta, intenta tú: ¿por qué el prompt de preservación lista los doc_ids ya leídos? ¿Qué síntoma de N0 reaparecería sin esa línea?

Ese punto donde A rompe y B no —con la traza— es exactamente la dim 2 de la rúbrica C1, la más difícil de conseguir. La acabas de cerrar.

5.6Míralo: reportar la factura

La dim 5 es la que más se olvida. La curva sube, el equipo aplaude, y nadie preguntó cuánto costó. En un sprint real, esa pregunta llega siempre — y la compaction tiene una respuesta incómoda: añade un paso de sampling. El resumen es una llamada extra al modelo en cada compactación. · fuente: corpus B.4.

Para reportar la factura necesitas contar tokens del agente gestionado y compararlos con el original. El SDK de Anthropic cuenta tokens sin consumir generación:

1# Contar tokens del estado actual del agente (corpus F.6).
2# count_tokens devuelve {"input_tokens": N}; tiene rate limits propios.
3import anthropic
4
5client = anthropic.Anthropic()
6
7count = client.messages.count_tokens(
8    model="claude-opus-4-6",        # el modelo de los ejemplos del nivel; usa el de tu lab
9    system=system_prompt_podado,    # el prompt a la altitud de L4
10    messages=mensajes_del_estado,   # el historial gestionado en este turno
11)
12tokens_input = count.input_tokens   # tokens que pagarías por este turno

Si usaste la compaction server-side de la API (beta compact-2026-01-12), el coste del resumen viaja en la respuesta. El bloque usage.iterations desglosa cada paso de sampling — el de compaction y el del mensaje — y se suman para la factura real del turno. · fuente: corpus F.6 / B.4.

1# Con compaction server-side, el coste del resumen es un iteration extra en usage.
2# Sumar usage.iterations da el coste real del turno (sampling de compaction + mensaje).
3# (Firma exacta del request: corpus F.6 — betas=["compact-2026-01-12"], compact_20260112.)
4# OJO: el JSON de la doc es ilustrativo; el SDK devuelve objetos Pydantic.
5# Se accede por ATRIBUTO (it.input_tokens), no por clave (it["input_tokens"]).
6total_tokens = sum(
7    it.input_tokens + it.output_tokens
8    for it in response.usage.iterations
9)

Lo que reportas es una tabla honesta, no un eslogan. Tokens por turno del agente original frente al gestionado, y la latencia añadida por el sampling del resumen:

                      | original (sin gestión) | gestionado (con compaction)
----------------------+------------------------+----------------------------
tokens input / turno  |     crece sin tope     |   acotado por el umbral
sampling extra / turno|          0             |   1 (el resumen) cuando compacta
latencia / turno      |    sube con el historial|  +Δ del resumen en los turnos de compactación

Los valores concretos los rellenas con tu medición — esta tabla es la forma del reporte, no sus cifras. El mensaje que comunica: la gestión acota el coste por turno que el original dejaba crecer sin tope, a cambio de un sampling extra cuando compacta. Ese trade-off, cuantificado, es la dim 5.

5.7Hazlo tú: calibra el listón con un entregable comentado

Antes de autoevaluarte, calibra el listón con un entregable de ejemplo. Es de una variante de Magallanes, sólido en las dims 1–3 y flojo en la 5. Leerlo afina tu ojo para tu propio entregable.

El entregable de ejemplo

Dim 1 — Mapeo. El presupuesto de C0 mostró que el historial dominaba el crecimiento (cada leer() mete un documento entero). Síntoma: distraction. Palanca: compress. Orden: primero, por ser la más barata. ✓ justificado desde la evidencia de C0.

Dim 2 — Compaction con preservación. Nodo con prompt que preserva decisiones, estado, pendientes y doc_ids. Caso de control: a 50 documentos, la ingenua re-lee doc-014 y contradice la sección 2; la de preservación no. Traza adjunta. ✓ control que falla de verdad.

Dim 3 — Altitud. Prompt podado de 12 reglas-parche a 4 secciones de alta señal; dos contradicciones resueltas; validado con el harness. ✓

Dim 4 — Mejora medida. Curva after superpuesta al baseline: el codo se movió de ~15 a ~35 documentos. Más longitud a la misma calidad. ✓ baseline intacto, seed y encargo fijos.

Dim 5 — Coste. "La gestión mejora la estabilidad del agente." ✗

Tu tarea

Lee las cinco dimensiones y responde:

1. ¿Qué falla exactamente en la dim 5?
2. ¿Qué tendría que añadir el autor para superarla?

Elaborative interrogation — antes de responder, pregúntate: ¿por qué la dim 5 es la que un equipo de verdad va a mirar primero?

5.8El mastery gate: tu checkpoint C1

Sin pistas. Este es el entregable que valida C1 sobre tu Magallanes. Es el whole-task del nivel: recuperar el agente real, medido contra su baseline.

Lo que entregas

Sobre el Magallanes degradado de C0, produce:

• (a) Gestión de historial. Trimming (trim_messages) y un nodo de compaction con preservación explícita de decisiones, estado y problemas abiertos.
• (b) System prompt a la altitud correcta. Ni lógica frágil hardcodeada ni vaguedad; secciones organizadas; sin reglas muertas.
• (c) Re-ejecución del sweep de C0 con curva antes/después superpuesta al baseline. Mismo encargo, mismas longitudes, mismo seed.
• (d) Caso de control: demuestra, con una traza concreta, que la compaction ingenua rompe lo que la tuya preserva.
• (e) Presupuesto justificado + coste reportado: qué va upfront, cuándo se compacta, qué se preserva — y la factura en tokens y latencia frente al original.

Cómo se corrige — la rúbrica con feedback por dimensión

Autoevalúate dimensión a dimensión. Para cada una: nombra tu fortaleza concreta, tu brecha concreta, tu siguiente paso.

5.9Conecta

Acabas de cerrar el arco que abriste en N0. Recuerda el run muerto de el-mito-de-la-ventana-infinita: aquella curva de Magallanes desplomándose con la longitud.

Esa curva ya no es tu baseline. Es tu marca a batir — batida. La superpusiste, la desplazaste, le pusiste la factura al lado. La pregunta del sprint —¿pagó la inversión?— tiene ahora una respuesta que el equipo puede discutir con datos, no con impresiones.

Y aplicaste el principio que cierra el nivel: "do the simplest thing that works" (corpus B.3). Empezaste por compress sobre el historial, la palanca más barata, y mediste antes de escalar. No saltaste a multi-agente para un síntoma que un nodo de compaction resolvía.

Pero tu prompt de preservación deja una pregunta abierta. Carga a mano, en cada resumen, con decisiones, estado y pendientes. Esas tres cosas se re-destilan turno tras turno, pagando sampling cada vez. Y son justo lo que ningún resumen debería tener que cargar — porque no son conversación, son estado persistente.

¿Por qué vive el estado dentro del contexto, si se podría escribir fuera y leerlo cuando hace falta? Esa es la palanca write, la que aquí no tocaste. Te espera en memoria: persistir fuera del contexto lo que ningún resumen debería cargar.

5.10Reflexiona

Tómate un minuto. Escribir esto consolida más que releer.

• ¿Qué aprendiste? Resume en una frase por qué "mejoró" sin curva contra el baseline no es una afirmación admisible en C1.
• ¿Qué sigue sin estar claro? ¿Tienes claro qué distingue un caso de control que falla de verdad de uno trivial? Si no, vuelve a 5.5.
• ¿Qué harías distinto? La próxima vez que alguien diga "optimicé el agente", ¿qué dos cosas le pedirías antes de creerlo?

Esto requiere práctica. La disciplina de medir contra un baseline fijo, una variable a la vez, con la factura al lado, se interioriza cerrando experimentos — no leyendo sobre ellos. Acabas de cerrar el primero.