Cómo hacer que Codex trabaje 4 horas seguidas de forma autónoma

La mayoría de los desarrolladores usan los asistentes de IA turno a turno: le piden un cambio, esperan 30 segundos, revisan el código a mano y vuelven a escribir otro prompt.

Eso no es programar con agentes: es usar autocompletado con esteroides.

Para que un agente como Codex o Claude Code trabaje horas seguidas de forma autónoma y entregue un proyecto terminado sin romper nada, necesitas tres pilares técnicos: especificaciones ejecutables (TDD), bucles de retroalimentación cerrada y memoria de sesión compacta.

1. El pilar indispensable: TDD y Tests como árbitro

Un agente autónomo nunca debe fiarse de su propia intuición para saber si terminó. El criterio de parada debe ser un comando ejecutable en tu terminal.

El flujo del bucle autónomo:

# 1. El planificador redacta el archivo de especificaciones y tests que fallan (RED)
# 2. El worker modifica el código de la aplicación
# 3. El sistema ejecuta la suite de tests automáticamente
npm test -- --runInBand
# 4. Si el código de salida es != 0, el output del error se inyecta directamente al agente
# 5. El agente repite el ciclo hasta que el comando devuelve EXIT 0 (GREEN)

2. Implementar el script de orquestación (Orchestration Loop)

Este script en Python lanza el agente en un bucle cerrado con límite de iteraciones y rollback automático si se atasca:

import subprocess
import time

MAX_ITERATIONS = 20
COMMAND_TEST = ["npm", "test"]

def run_test_suite():
    result = subprocess.run(COMMAND_TEST, capture_output=True, text=True)
    return result.returncode == 0, result.stdout + result.stderr

def run_autonomous_loop():
    print("Iniciando bucle de desarrollo autónomo...")
    
    for i in range(1, MAX_ITERATIONS + 1):
        print(f"\n--- Iteración {i}/{MAX_ITERATIONS} ---")
        passed, test_output = run_test_suite()
        
        if passed:
            print(" Todos los tests pasan con éxito. Tarea completada.")
            break
            
        print("Tests fallando. Pasando feedback de error al agente...")
        # Aquí se invoca el turno del agente pasándole únicamente el fragmento de error
        prompt = f"La suite de tests ha fallado con el siguiente error. Corrige el código:\n{test_output[-1500:]}"
        subprocess.run(["codex", "exec", prompt])
        time.sleep(2)

if __name__ == "__main__":
    run_autonomous_loop()

3. Evitar la degradación de contexto

El mayor enemigo de una sesión de 4 horas es el crecimiento descontrolado del contexto. Cuando el prompt supera los 100k tokens, la precisión del modelo cae en picado (context drift).

Reglas de higiene de contexto para sesiones largas:

• Subagentes de corta duración: Destruye el subagente tras completar cada módulo y pasa solo un resumen JSON al siguiente turno.
• Archivos .agentignore: Excluye node_modules, builds, logs y archivos binarios pesados.
• Checkpoints en Git: Haz commits automáticos cada vez que una batería de tests pase (git commit -m "chore(agent): passing tests iteration X"). Si una iteración empeora el resultado, haz git checkout y vuelve a planificar.

Conclusión

El trabajo autónomo no es magia ni suerte: es ingeniería de software tradicional (tests automatizados + feedback loops) combinada con modelos de lenguaje. Si los tests son sólidos, puedes dejar al agente trabajando e irte a tomar un café.