¿Qué es Auto Compact en Claude Code?

Claude Code es el asistente de programación agente de Anthropic que puede leer una base de código, editar archivos, ejecutar comandos e integrarse con herramientas en flujos de trabajo de terminal, IDE, aplicación de escritorio y navegador. Debido a que funciona dentro de una ventana de contexto compartida, las sesiones largas eventualmente se llenan con historial de chat, salida de archivos y tráfico de herramientas. Claude Code gestiona esto automáticamente compactando el historial de la conversación a medida que te acercas al límite, y las instrucciones tempranas pueden perderse si solo están presentes en el historial de chat.

Eso importa aún más en 2026 porque Anthropic sigue impulsando a Claude Code hacia trabajos más largos y autónomos. El 25 de marzo de 2026, Anthropic publicó “Claude Code auto mode: a safer way to skip permissions”, diciendo que los usuarios aprueban el 93% de las solicitudes de permiso y describiendo el modo automático como un punto medio basado en clasificadores entre la aprobación manual y el salto de permisos inseguro. El 5 de febrero de 2026, Anthropic también lanzó Claude Opus 4.6, destacando un código más sólido, mejor depuración y sesiones más largas con comportamiento agente. Esas actualizaciones no son lo mismo que la compactación automática, pero muestran claramente la dirección del producto: menos interrupciones, sesiones más largas y una continuidad más confiable.

CometAPI actualmente ofrece acceso a la Claude API a un precio más bajo que la API oficial, por ejemplo Claude Sonnet 4.6, Claude Opus 4.6, y el Claude 5.

Qué significa realmente Auto Compact en Claude Code

Auto Compact es un mecanismo integrado de optimización del contexto en Claude Code (la herramienta de CLI/escritorio de Anthropic) y en el ecosistema más amplio de la Claude API. Interviene automáticamente cuando tu conversación se acerca al techo de la ventana de contexto del modelo—normalmente alrededor de 200,000 tokens para modelos insignia como Claude Opus 4 o Sonnet 4. La documentación de hooks es explícita: PreCompact se dispara antes de una operación de compactación, y el matcher auto significa “compactación automática cuando la ventana de contexto está llena”. El hook correspondiente PostCompact se dispara después de que la compactación se complete y recibe el compact_summary generado.

Eso importa porque la compactación no es lo mismo que la “memoria”. La memoria automática es el propio sistema de toma de notas de Claude, mientras que la compactación es un mecanismo de gestión de sesión que comprime el estado de la conversación activa. La documentación de memoria es clara en que CLAUDE.md es persistente, la memoria automática la escribe Claude, y la compactación es el momento en que el historial de la conversación de la sesión se reduce para que el modelo pueda seguir trabajando.

En lugar de forzar un nuevo chat (y perder el historial) o dejar que el modelo “olvide” detalles críticos, Auto Compact:

1. Analiza todo el historial — identifica elementos clave que vale la pena conservar.
2. Genera un resumen conciso — de decisiones, arquitectura de código, errores solucionados, estados de archivos y próximos pasos.
3. Reemplaza mensajes antiguos — con este resumen (un “bloque de compactación” en términos de API).
4. Se reanuda sin interrupciones — con el contexto preservado.

Datos clave (2026):

• Umbral de disparo: Por defecto ~95% de capacidad (o ~25% restante). Algunos usuarios informan un buffer interno que reserva entre 20–45k tokens (~22.5% del contexto) para el propio proceso de compactación.
• Mejora de rendimiento: Desde Claude Code v2.0.64, la compactación es “instantánea” en lugar de tomar minutos.
• Ejemplo de ahorro de tokens (según benchmarks del Claude Agent SDK): Un flujo de 5 tickets bajó de 204k a 82k tokens de entrada (reducción del 58.6%) con dos eventos de compactación.

Auto Compact no es lo mismo que /clear (que borra todo) ni una simple truncación. Conserva de forma inteligente lo que importa—diffs de código recientes, decisiones arquitectónicas, convenciones de nomenclatura—mientras condensa bucles de depuración resueltos y desvíos exploratorios.

¿Por qué usar Auto Compact en Claude Code?

Las sesiones largas de programación son la norma. La implementación de una sola funcionalidad puede abarcar 50+ turnos: planificación, depuración, refactorización, pruebas. Sin compactación, el uso de tokens crece linealmente, la calidad de la respuesta se degrada y los costos se disparan.

Para los desarrolladores, la recompensa es menos fatiga de reinicios. En lugar de copiar manualmente un resumen a una nueva sesión, permites que Claude compacte la sesión y sigas adelante. Eso es especialmente útil en corrección de errores, refactorizaciones multiarchivo, cambios guiados por pruebas y flujos centrados en revisión donde la conversación puede volverse muy larga. Las sesiones de Claude Code comienzan con una ventana de contexto fresca, por lo que la compactación es uno de los mecanismos clave que hace viable el trabajo de larga duración.

Beneficios principales

• Longitud de sesión ilimitada: Continúa indefinidamente sin empezar de cero.
• Eficiencia de costo y rendimiento: Reduce drásticamente los tokens de entrada. Informes del mundo real muestran ahorros del 50–60% en flujos multip fase.
• Mejor enfoque y estabilidad: Evita el “sobrecargado de contexto” donde el modelo alucina u olvida restricciones anteriores.
• Preserva el conocimiento institucional: Las decisiones clave permanecen en contexto incluso después de cientos de mensajes.
• Perfecto para flujos agente: Crítico al usar herramientas, servidores MCP o configuraciones multiagente en Claude Code.

¿Cuándo deberías confiar en Auto Compact?

Usa Auto Compact cuando la tarea es naturalmente de larga duración: refactorizaciones multiarchivo, sesiones de depuración que saltan entre logs y código fuente, implementación de funcionalidades con verificación repetida o investigación que requiere muchas llamadas de herramientas. La documentación de Anthropic señala explícitamente sesiones largas donde la ventana de contexto se llena de conversación irrelevante, contenidos de archivos y comandos, y dice que la compactación automática preserva el código y las decisiones clave mientras libera espacio.

Es menos adecuado cuando la tarea es corta, aislada o requiere instrucciones precisas y retenidas de forma permanente. Esas instrucciones de las primeras etapas de la conversación pueden perderse tras la compactación, por lo que las reglas del proyecto deben estar en CLAUDE.md, no en un prompt desechable que podría ser comprimido más tarde.

Cuándo usarlo (o habilitarlo):

• Activado por defecto para la mayoría de usuarios — ideal para la programación diaria, refactorizaciones grandes o proyectos exploratorios.
• Tareas de larga duración — procesamiento de colas, pipelines de datos o bases de código multiarchivo.
• Entornos de equipo/empresa — donde la continuidad del contexto entre sesiones importa.
• Proyectos de alto riesgo — donde perder una sola decisión arquitectónica podría costar horas.

Cuándo considerar deshabilitarlo (vía /config):

• Quieres cada token de contexto para un control ultrapreciso.
• Prefieres la gestión totalmente manual (usuarios avanzados que guardan/restauran planes vía archivos).

Últimas noticias (2025–2026): En marzo de 2025, Anthropic mejoró la lógica de preservación de Auto Compact, haciendo los resúmenes más inteligentes al retener “información importante mientras se reduce el uso de tokens”. A finales de 2025, el disparo fue refinado (a veces antes, al 64–75% de uso, para evitar compactaciones fallidas). A inicios de 2026 hubo errores temporales en las interfaces web/escritorio (marcados como corregidos a mediados de enero pero con informes residuales), mientras que el CLI se mantuvo estable. La versión 2.0.64 (feb 2026) hizo la compactación instantánea, un gran avance para la experiencia del desarrollador.

Cómo usar Auto Compact en Claude Code: guía paso a paso

Claude Code está diseñado para que cada sesión comience con una ventana de contexto fresca. Eso es útil porque cada tarea nueva comienza limpia, y también facilita detectar cuándo una sesión se está volviendo ruidosa. Se recomienda usar /clear entre tareas no relacionadas para que el contexto obsoleto no siga consumiendo espacio.

Paso 1: Verifica el estado actual del contexto

Usa /context para visualizar la carga actual del contexto. La lista de comandos integrada de Claude Code dice que /context muestra una cuadrícula de colores y destaca la hinchazón de memoria, sugerencias de optimización y advertencias de capacidad. Eso lo convierte en la forma más rápida de saber si te estás acercando al punto donde es probable que se active la compactación automática.

En tu sesión de Claude Code, escribe:

/context

Esto muestra “Context left until auto-compact: XX%” — tu barra de progreso en tiempo real.

Paso 2: Configura la compactación automática (opcional)

Cuando la ventana de contexto se llena, Claude Code compacta automáticamente la conversación. La referencia de hooks etiqueta este evento como auto, y se dispara cuando la ventana de contexto está llena. En la práctica, no “activas” Auto Compact tanto como dejas que Claude Code lo haga cuando sea necesario.

/config

Navega a “Auto-compact enabled” y alterna verdadero/falso. El valor predeterminado es enabled. También puedes ajustar configuraciones relacionadas como el uso de servidores MCP para liberar tokens de forma proactiva.

Paso 3: Deja que Auto Compact se ejecute automáticamente

Cuando llegues a ~95%:

• Claude muestra “Compacting our conversation so we can keep chatting…” (o similar).
• Se ejecuta en segundo plano y se reanuda.
• Verás el nuevo resumen en la parte superior del contexto.

Consejo: No esperes al 0%. Compacta manualmente antes para obtener mejores resultados (ver buenas prácticas abajo).

Paso 4: Usa hooks si quieres automatizar lo que sucede alrededor de la compactación

Claude Code expone PreCompact y PostCompact. La referencia de hooks muestra que PreCompact puede detectar si la compactación es manual o automática, y que PostCompact recibe el compact_summary generado. Eso hace que los hooks sean muy adecuados para logging, trazas de auditoría, notas post-compactación o automatizaciones externas.

Un patrón simple de hook se ve así:

{  "hooks": {    "PostCompact": [      {        "matcher": "auto",        "hooks": [          {            "type": "command",            "command": "./scripts/save-compact-summary.sh"          }        ]      }    ]  }}

Y el script shell correspondiente puede leer el JSON de la entrada estándar, porque los command hooks de Claude Code reciben JSON de esa manera:

#!/usr/bin/env bashset -euo pipefailjq -r '.compact_summary // empty' \  | sed 's/^/[compact] /' \  >> .claude/compact-log.txt

La documentación confirma que los command hooks reciben JSON vía stdin, y que PostCompact incluye compact_summary, por lo que este patrón está alineado con el modelo de hooks actual.

Paso 5: Compactación manual con precisión (recomendado)

Usa /compact cuando quieras que el asistente comprima el hilo ahora mismo. Puedes incluir instrucciones que den forma al resumen que deseas preservar. La página de comandos integrados de Anthropic enumera /compact [instructions] como “Compact conversation with optional focus instructions,”

/compact keep the auth flow decisions, the current test plan, and the open TODOs

Ese patrón es útil justo antes de una transferencia, antes de un cambio de rama o antes de pedirle a Claude que comience una nueva fase de trabajo.

Ejemplos de uso real:

• After debugging: /compact keep the solution we found, remove debugging steps
• Project milestone: /compact focus on the new feature requirements

Compactación a nivel API (avanzado – Python SDK y Messages API)

Para agentes o scripts personalizados, usa las herramientas oficiales de compactación.

Ejemplo con Claude Agent Python SDK (automático para flujos que usan herramientas):

from anthropic import Anthropic

client = Anthropic()

runner = client.beta.messages.tool_runner(
    model="claude-opus-4-6",
    max_tokens=4096,
    tools=your_tools,
    messages=messages,
    compaction_control={
        "enabled": True,
        "context_token_threshold": 100000,  # or lower for aggressive compaction
        "model": "claude-haiku-4-5",        # cheaper summarizer
        "summary_prompt": """Create a focused summary preserving:
1. COMPLETED TASKS and key outcomes
2. CURRENT STATE and open items
3. NEXT STEPS
Wrap in <summary></summary> tags."""
    }
)

Detecta eventos de compactación:

if curr_msg_count < prev_msg_count:
    print(f"Compaction occurred! Messages reduced from {prev_msg_count} to {curr_msg_count}")
```<grok-card data-id="f4afb5" data-type="citation_card" data-plain-type="render_inline_citation" ></grok-card>

**Full Messages API (beta, 2026)** – requiere header:
```bash
curl https://api.anthropic.com/v1/messages \
  --header "anthropic-beta: compact-2026-01-12" \
  --data '{
    "model": "claude-opus-4-6",
    "messages": [...],
    "context_management": {
      "edits": [{
        "type": "compact_20260112",
        "trigger": {"type": "input_tokens", "value": 150000},
        "pause_after_compaction": true
      }]
    }
  }'

La API devuelve un bloque de compactación que debes pasar en futuras llamadas. Las instrucciones personalizadas y la pausa ofrecen control total sobre el presupuesto (p. ej., imponer un tope total de 3M tokens a través de sesiones).

Si estás usando la Claude API de CometAPI, cambia el header del mensaje a "https://api.cometapi.com/v1/messages\\".

Auto-Compact vs Compactación manual vs Clear: tabla comparativa

Mejores prácticas para Auto Compact en Claude Code (consejos de desarrolladores)

Compacta de forma proactiva

La tercera regla es usar la compactación como un reinicio, no como un parche. Si el hilo está lleno de vías muertas, pide a Claude que compacte con una instrucción clara sobre lo que importa: objetivo actual, enfoque elegido, pruebas fallidas y preguntas sin resolver. En la práctica, eso hace que el resumen sea mucho más útil que dejar que el sistema compacte a ciegas y esperar lo mejor.

Mantén cortas tus instrucciones duraderas.

Anthropic dice que los archivos de más de 200 líneas pueden reducir la adherencia, por lo que los bloques de políticas grandes suelen ser peores que reglas concisas y bien delimitadas. Usa .claude/rules/ para comportamientos específicos por tipo de archivo o ruta, y usa @path imports cuando necesites detalles de apoyo más amplios sin inflar el archivo de instrucciones principal.
Free tokens first — Deshabilita servidores MCP no utilizados con /mcp o @server-name disable antes de compactar.

Combínalo con CLAUDE.md

Trata CLAUDE.md como la fuente de verdad para todo lo que quieres que sobreviva a una sesión larga. CLAUDE.md se vuelve a leer después de /compact, lo que lo convierte en el lugar adecuado para comandos de build, convenciones de código y reglas persistentes que nunca quieres perder. La memoria automática también es útil, pero es un sistema diferente con un propósito distinto.

Otros consejos

Monitorea con /context — Mantén el uso por debajo del 70–80% cuando sea posible.

Para usuarios de API — Establece umbrales más bajos (p. ej., 50k–100k) y usa modelos de resumen más baratos como Haiku.

Deshabilita solo cuando sea necesario — La mayoría de desarrolladores ahora recomiendan mantener Auto-Compact activado tras las mejoras de 2025.

Prueba la compactación — Primero en sesiones no críticas para ver cómo se resume tu flujo específico.

Impacto real: Los desarrolladores reportan sesiones productivas 2–3x más largas y menos momentos de “Claude olvidó lo que estábamos haciendo”.

Problemas comunes y solución de problemas (edición 2026)

• Auto-compact no se activa: Revisa web/escritorio vs CLI; algunos errores de enero de 2026 fueron corregidos pero verifica la versión.
• Contexto perdido tras la compactación: Usa /compact manual con instrucciones explícitas la próxima vez.
• Bucles infinitos o 102% de uso: Raro; reinicia la sesión o usa /clear como último recurso.
• Compactación lenta: Problema previo a v2.0.64—actualiza Claude Code.
• Errores de bloque de compactación en la API: Siempre agrega el bloque completo de contenido de compactación en las llamadas posteriores.

Conclusión

La compactación automática es uno de los mecanismos ocultos más importantes en Claude Code porque mantiene utilizables las sesiones largas de programación sin obligarte a reiniciar cada vez que la ventana de contexto se llena. La regla práctica es simple: deja que la compactación automática maneje el desbordamiento, usa /compact cuando quieras control, guarda las directrices duraderas en CLAUDE.md, y usa /clear o /rewind cuando cambie la estructura de la sesión. Esa combinación te da el mejor equilibrio entre continuidad, control y velocidad en flujos de trabajo largos con Claude Code.

Auto Compact en Claude Code representa un salto en el desarrollo asistido por IA práctico. Al gestionar inteligentemente la ventana de contexto de 200k tokens, elimina el mayor punto de fricción en la programación de largo aliento: quedarse sin memoria. Con rendimiento instantáneo (2026), opciones ricas de configuración y potentes extensiones de API, ahora es una función madura y probada en batalla usada a diario por miles de desarrolladores.

Pasos de acción hoy:

1. Abre Claude Code y ejecuta /config — confirma que Auto-Compact está habilitado.
2. Prueba un /compact manual con instrucciones en tu proyecto actual.
3. Explora el Python SDK o la Messages API para agentes automatizados en CometAPI.