CONTINUUM

Recuperación semántica universal y verificable para agentes de IA de larga duración con puntos de control semánticos, libro de acciones idempotente y registro encadenado por hash como servidor MCP de denegación por defecto

GitHub

Prueba este MCPPatrocinado

Documentación

CONTINUUM Banner

CONTINUUM: Recuperación semántica verificable para agentes de IA de larga duración. Puntos de control semánticos (no volcados de conversación), un libro de acciones idempotente que rechaza efectos secundarios duplicados, y un registro de eventos encadenado por hash y a prueba de manipulación, todo expuesto como un servidor MCP con denegación por defecto. Independiente del framework, Python 3.11+.

Visita el sitio web de CONTINUUM

_{Si CONTINUUM ayuda a tus agentes a recuperarse, por favor dale una estrella al repositorio. Ayuda a que otros lo descubran y mantiene buenos primeros issues en camino.}

Contenido

Por qué · Inicio rápido · Cómo funciona · Dónde encaja CONTINUUM · Características · Extensión de seguridad · Verificación empírica · Integración MCP · Integración con frameworks · Conceptos clave · Arquitectura · API y CLI · Hoja de ruta · Lo que CONTINUUM no es · Trabajo relacionado · Estado y limitaciones · Contribuciones · Licencia

Por qué

Los agentes de IA modernos ejecutan tareas largas (cientos de llamadas LLM, invocaciones de herramientas, escrituras de archivos y bases de datos). Cuando fallan, la respuesta habitual es reproducir todo desde cero, lo que duplica trabajo, duplica efectos secundarios, desperdicia tokens y pierde decisiones.

CONTINUUM plantea una pregunta más acotada y difícil: ¿puede un agente reanudarse desde una representación semántica compacta de su estado de tarea mientras verifica de forma independiente que ese estado sigue siendo válido en el entorno actual? Su diferenciador tiene tres partes:

Puntos de control semánticos: una representación compacta y versionada de lo que el agente necesita para continuar, no un volcado de conversación.
Revalidación independiente del entorno: cada componente del punto de control se verifica contra el entorno actual antes de reanudar, con la obsolescencia propagándose a través del grafo de dependencias.
Estado con trazabilidad de origen: cada hecho se remonta a su origen, por lo que el progreso reportado por el agente nunca es autocertificado.

Inicio rápido

Publicado en PyPI como continuum-agent 0.1.0 — pip install continuum-agent (pip install continuum-agent==0.1.0 para fijar). Las etiquetas de lanzamiento además incluyen ruedas compiladas adjuntas a GitHub Releases.

Rutas sin configuración (sin clonar, sin instalar, nada publicado en ningún lugar):

Ruta	Cómo
Instalar desde PyPI	`pip install continuum-agent==0.1.0` — luego `continuum --help`
Ver la recuperación ante fallos de principio a fin	`docker run --rm ghcr.io/cyrax321/continuum`
Usar la CLI a través de Docker	`docker run --rm ghcr.io/cyrax321/continuum continuum --help`
Ejecutar la CLI sin clonar	`uvx --from git+https://github.com/Cyrax321/CONTINUUM.git continuum --help`
Entorno de desarrollo completo en el navegador

La imagen de Docker se publica en GHCR por CI en cada push a main y en cada etiqueta de lanzamiento (.github/workflows/docker-publish.yml). El Codespace está definido en .devcontainer/.

git clone https://github.com/Cyrax321/CONTINUUM.git
cd CONTINUUM

uv venv && source .venv/bin/activate     # macOS / Linux; Windows: .venv\Scripts\activate

# Contributors (recommended): library + CLI + all test tooling + every adapter
uv pip install -e ".[dev]"

# Or pick only what you need: . (minimal), [mcp], [otel], [langgraph],
# [openai], [langchain], [attest], [postgres]

# Or skip the clone entirely:
uv pip install git+https://github.com/Cyrax321/CONTINUUM.git
uv pip install "continuum-agent[mcp] @ git+https://github.com/Cyrax321/CONTINUUM.git"

Alternativa para pip: reemplaza uv pip install con pip install en cada comando anterior.

Verifica:

continuum --help                 # CLI entrypoint
continuum-mcp --help             # MCP server entrypoint (needs [mcp] or [dev])
pytest -q                        # ~1,380 collected (exact count and skips vary by environment)
ruff check src/ tests/ examples/ && ruff format --check src/ tests/ examples/
mypy src/continuum               # the three gates CI enforces

La biblioteca principal tiene una dependencia de tiempo de ejecución (pydantic>=2.7); todo lo demás es opcional. El mapa completo de paquetes, la matriz de extras, la configuración de pruebas de Postgres y la verificación por comando están en references/install.md.

Conecta un agente de codificación en dos minutos

Para Claude Code, Gemini CLI o Codex, no escribes Python y no necesitas un archivo de prompt:

continuum start my-task --goal "What the agent should do"
continuum hooks install claude-code --with-gate   # also: gemini, codex

A partir de entonces, cada archivo que el agente escribe se captura como evidencia encadenada por hash, su sesión comienza con un informe de estado automático, los efectos secundarios no reclamados registrados en .continuum/gate.json se rechazan antes de que se disparen, y una sesión nueva después de cualquier fallo se reanuda con pasos ejecutables siguientes. No se requiere CLAUDE.md.

Ejemplo mínimo de biblioteca, registrar y recuperar:

from continuum import EventType, Run, SQLiteStorage, project

store = SQLiteStorage("agent.db")
store.create_run(Run(run_id="run_4821", goal="Analyze 10,000 documents"))
store.append_event("run_4821", EventType.RUN_STARTED, {"goal": "Analyze 10,000 documents", "total": 10_000})

for i, doc in enumerate(documents):
    analyze(doc)
    store.append_event("run_4821", EventType.WORK_COMPLETED, {"doc": i})

# After a crash, a new process picks up exactly where it stopped:
state = project("run_4821", store.read_events("run_4821"))
print(state.progress.completed)            # already done, not repeated
print(store.verify_events("run_4821").ok)  # True, chain intact after the crash

Ejecuta la prueba tú mismo:

python examples/crash_recovery_agent.py   # real process kill, real side effect
python examples/context_compaction.py     # transcript lost, checkpoint survives
python examples/model_switch.py           # Model A dies, Model B resumes safely
python scripts/mcp_smoke.py               # real subprocess, real JSON-RPC traffic

El kit e2e-autonomy-test/ automatiza una tarea real de lote de facturas, una interrupción forzada a mitad de ejecución y una sesión de reanudación nueva, luego puntúa el outbox, el libro y la cadena de eventos fuera de banda. La ejecución 1 obtuvo 7/7 mecánicas contra una sesión real de Claude Code. Guía completa en references/e2e.md.

Cómo funciona

CONTINUUM separa el contexto LLM (temporal) del estado de tarea duradero (permanente). En lugar de guardar el historial de conversación, construye un punto de control semántico: la información mínima verificada necesaria para continuar.

CONTINUUM how it works

La explicación detallada, el modelo de proyección y el contexto de recuperación están en references/architecture.md.

Dónde encaja CONTINUUM

Cuatro preocupaciones se superponen en cada agente de larga duración. CONTINUUM solo posee la última y toca las otras tres a través de costuras explícitas. No se nombra a ningún competidor y no se hace ninguna afirmación sin un módulo publicado o una suite publicada que ya la imprima.

Capa	Responde	Cómo se conecta (módulos publicados o salida publicada)
Arnes	¿Cómo llama el agente a las herramientas y avanza hacia un objetivo?	Fuera de CONTINUUM. Los puntos de conexión se publican en `src/continuum/adapters/generic.py` (`GenericAgentAdapter`), `src/continuum/adapters/thin.py` (hooks de CrewAI, AutoGen, Pydantic AI), `src/continuum/mcp/server.py` (MCP stdio), `src/continuum/hooks.py` y `src/continuum/clienthooks.py` (hooks de ciclo de vida de CLI de codificación), `src/continuum/gateway.py` (aplicación de proxy HTTP para cualquier lenguaje) y `src/continuum/otel.py` (puente OpenTelemetry). Las recetas están en `docs/recipes/` y `references/adapters.md`.
Ejecución duradera	¿Qué sucedió antes de un fallo y qué se puede reproducir sin perder trabajo?	Registro de eventos encadenado por hash `src/continuum/events.py` con `verify()` y `trusted_through`, almacenamiento duradero `src/continuum/storage/sqlite.py` (WAL, `synchronous=FULL`, esquema v6) y `src/continuum/storage/postgres.py` más `src/continuum/storage/migrations.py`, puntos de control basados en políticas `src/continuum/checkpoint/manager.py` y `src/continuum/checkpoint/policy.py` que reproducen la brecha en `restore()`. Guía en `docs/recovery_walkthrough.md` (salida de `examples/recovery_walkthrough.py`).
Plano de control	¿Qué ejecución está activa, quién puede actuar sobre ella y a dónde va la salida?	Registro de ejecuciones y jerarquía padre/hijo `src/continuum/storage/` y `src/continuum/recovery/family.py` (`continuum tree`), autorización por lista blanca `src/continuum/mcp/authz.py` (`CONTINUUM_MCP_MUTATING_CLIENTS` / `CONTINUUM_MCP_TOKEN`), superficies de presentación `src/continuum/dashboard/app.py` y `src/continuum/serve/server.py`, CLI `src/continuum/cli/main.py` (`continuum runs`, `continuum tree`, `continuum health`).
Sustrato de verificación	Dado el punto de control en el tiempo T y el mundo tal como es ahora, ¿sigue siendo seguro y correcto continuar?	`src/continuum/state/validator.py` (obsolescencia `dependency -> evidence -> finding -> decision` más `PlanStep.depends_on`), `src/continuum/provenance_map.py` (`Origin` a `REQUIRES_REVIEW` hasta `REVIEW_CONFIRMED`), `src/continuum/actions/ledger.py` con `src/continuum/actions/idempotency.py` y `src/continuum/gate.py` / `src/continuum/gateway.py` (reclamar antes de disparar, rechaza duplicados, lanza `UnknownSideEffect` para reconciliación), `src/continuum/replayguard.py` (guardia portátil), `src/continuum/pinning.py` y `src/continuum/replay_similarity.py` (corrección de reproducción), `src/continuum/budgets.py` (límites de reintento), `src/continuum/recovery/engine.py` + `src/continuum/recovery/contract.py` + `src/continuum/recovery/planner.py` + `src/continuum/recovery/observations.py` (severidad máxima `RESUME < ... < ABORT`, contrato sellado con `evidence` / `reason` / `next_allowed_action` / `human_steps`), `src/continuum/checkpoint/rewind.py` (rebobinado atómico de doble estado), `src/continuum/analysis/prefix_trust.py` (confianza consultiva). Comprobaciones publicadas: `docs/recovery_walkthrough.md`, `benchmarks/fault_injection/` (suite que imprime `detection_rate` / `unsafe_resume_rate`), `src/continuum/benchmark/phase6/` (suite de corrección de recuperación), `docs/RESULTS.md` y la imagen regenerable a continuación.

Cada fila anterior es rastreable a una ruta que existe en main en el commit etiquetado. Nada en esta tabla reformula un número de referencia; los puntos de referencia viven solo en la salida de la suite que ya imprimen. Consulta docs/research.md para la lista completa de suites publicadas y documentos de diseño.

Recuperación ante fallos, de verdad

La imagen a continuación no es un simulacro. Es la salida de python demo-run/generate_crash_visual.py, que ejecuta demo-run/worker.py hasta os._exit(9) en el documento 399, llama a continuum resume --env dataset=v4 y muestra la ruta de rechazo (REQUEST_HUMAN, safe:false, salida 20), reconcilia el efecto secundario incierto con una sonda, luego se reanuda desde la misma base de datos y termina sin trabajo duplicado. La transcripción también se guarda como docs/assets/crash-recovery.txt para auditoría.

Regenérala:

python demo-run/generate_crash_visual.py
# or: python scripts/generate_crash_visual.py

Crash recovery: hard kill mid-batch, refusal, reconcile, resume

Guía completa con código en docs/recovery_walkthrough.md (examples/recovery_walkthrough.py). El arnés de referencia mínimo está en references/bench.md (continuum benchmark).

Características

Capacidad	Qué te proporciona
Puntos de control semánticos	Estado compacto, versionado e inspeccionable, no un volcado de transcripción
Libro mayor de acciones idempotentes	Rechaza efectos secundarios externos duplicados; expone los inciertos para reconciliación
Revalidación del entorno	Cada componente del punto de control se verifica contra el mundo actual antes de reanudar
Estado consciente de la procedencia	El progreso reportado por el agente se marca `REQUIRES_REVIEW`, nunca autocertificado
Motor de recuperación	Siete modos de recuperación con un contrato de próxima acción determinista y sellado
Servidor MCP con denegación por defecto	Once herramientas, división de solo lectura/mutación, lista de permitidos del llamador
Adaptadores de framework	Integraciones genéricas de Python, OpenAI Agents SDK, LangGraph y LangChain
Bucle de planificación seguro	La verificación de observación de dos señales eleva las ramas de alto riesgo a REQUIRES_REVIEW
Revalidación periódica	El entorno se vuelve a comprobar según un cronograma, detectando desviaciones a mitad de ejecución dentro de un ciclo
Registro a prueba de manipulaciones	Registro de eventos encadenado por hash (36 tipos de eventos) con verificación de integridad
Puerta de aplicación	Las llamadas de efectos secundarios no reclamadas se rechazan antes de ejecutarse; los mensajes de denegación enseñan el protocolo de reclamación
Ganchos de observación	Cada archivo que un CLI de codificación escribe se convierte en evidencia verificada por digest, fuera del control del modelo
Resumen de sesión	Las sesiones nuevas aprenden el estado de ejecución de manera determinista al inicio, incluido el resumen de razonamiento de la última sesión
Sondas de reconciliador	Los comandos registrados resuelven efectos secundarios inciertos automáticamente; los humanos solo ven el resto
Guía ejecutable	Reanudar/validar renderiza los siguientes pasos como comandos ejecutables, no como estados
Puerta de enlace HTTP de aplicación	Las llamadas salientes en cualquier idioma requieren reclamaciones; las respuestas las resuelven desde la realidad
Puente OpenTelemetry	Los tramos de llamadas a herramientas del rastreo de producción se convierten en evidencia con cero cambios de código
Índice de acciones	Las búsquedas de idempotencia entre ejecuciones son lecturas indexadas, no escaneos completos del registro
Fijación de versiones	Los hashes de prompt/herramienta/modelo afirmados por el llamador se almacenan por reclamación; la desviación se muestra al reanudar
Presupuestos de reintentos	Los límites de intentos por tipo de acción se aplican en el momento de la reclamación; los agentes ven los intentos restantes
Multiagente padre/hijo	La reanudación del padre compone el peor estado familiar; el hijo incierto bloquea al padre
Reintento informado	Los resúmenes de fallos redactados por el motor se inyectan en las reanudaciones posteriores a la recuperación
Semántica de bifurcación	Las continuaciones divergentes se ramifican en ejecuciones hijas con autoridad nueva
Compactación de registros	El prefijo anterior al ancla se archiva textualmente; el registro en vivo se limita para ejecuciones de un mes
Seguimiento de subvenciones consumidas	Las referencias de autoridad de un solo uso se marcan como gastadas en estado terminal; la reutilización después de la restauración se rechaza (`GRANT_DENIED`), defendiendo la ruta de restauración de puntos de control contra la Resurrección de Autoridad
Atestación de cadena	`continuum attest` firma el encabezado de la cadena de una ejecución con Ed25519 para que un verificador externo pueda probar que la historia no fue alterada a partir de una clave conocida
Superficie de panel HITL	Botones de confirmar/reconciliar/completar con paridad de auditoría con el CLI

Extensión de seguridad

Dos extensiones de seguridad aditivas se sitúan sobre el sustrato de recuperación y puntos de control. No cambian la reanudación, la reproducción ni la ruta de revalidación en tiempo de fallo existente.

Bucle de planificación seguro: las observaciones llevan procedencia y se verifican mediante dos señales independientes (verified / unverified / contested). Una rama de planificación condicionada a una observación no verificada o impugnada se eleva a REQUIRES_REVIEW. Las decisiones se añaden al libro mayor como eventos PERCEPTION_OBSERVED y BRANCH_RESOLVED.
Revalidación periódica: reutiliza el motor de recuperación en un intervalo de pasos (predeterminado 25) y al cambiar de aplicación, de modo que la desviación del entorno a mitad de ejecución se detecte dentro de un ciclo en lugar de solo en el próximo fallo.

Consulta docs/PROBLEM.md, docs/RESULTS.md y STATUS.md.

Verificación empírica

CONTINUUM se verifica contra agentes LLM reales, límites de protocolo en vivo y fallos duros de procesos, no solo pruebas unitarias simuladas.

Agentes reales: lotes de facturas de Claude Code de múltiples sesiones con SIGKILL a mitad de ejecución, puntuados 7/7 en mecánica; las sesiones reanudadas consultaron continuum_resume, enrutaron efectos secundarios a través del libro mayor de dos fases, se negaron a duplicar escrituras verificadas y respetaron request_human. Las pruebas en vivo revelaron brechas de deduplicación por desviación de prompt, cerradas mediante normalización de rutas canónicas y respaldo basado en tokens en ActionLedger.claim().
Clientes de terceros: Gemini CLI y Kilo Code se conectaron a través de stdio JSON-RPC contra el almacén SQLite en vivo, validando la coexistencia multiagente y el aislamiento de autorización.
Cumplimiento de protocolo: impulsado de extremo a extremo con @modelcontextprotocol/inspector --cli a través de muertes de procesos; las herramientas mutantes deniegan por defecto detrás de CONTINUUM_MCP_MUTATING_CLIENTS; las reclamaciones externas degradan a REQUIRES_REVIEW (safe: false).
Autocuración: los servidores eliminados por fuerza se recuperan de sidecars SQLite huérfanos -wal/-shm mediante una limpieza de reintento único al inicio.
Escala: aproximadamente 1,380 pruebas recopiladas (~1,360 aprobadas; el resto se omiten sin servicios opcionales) en Python 3.11, 3.12 y 3.13 (unitarias, hypothesis basadas en propiedades, concurrencia, adversariales). CONTINUUM-Bench ejecuta cinco escenarios de fallo más un escenario dedicado de desviación de argumentos, midiendo 0 trabajo duplicado y 0 efectos secundarios duplicados para CONTINUUM frente a duplicación completa para reproducción ingenua; una suite separada de corrección de recuperación de 12 escenarios (continuum.benchmark.phase6) codifica los puntos de fallo de la encuesta de ejecución duradera como aserciones ejecutables.
Auditoría adversarial: toda la superficie MCP se auditó sobre el protocolo en vivo; se encontraron y corrigieron tres defectos. Método y pasos de reproducción en test.md.

Integración MCP

CONTINUUM incluye un servidor MCP para que un agente pueda registrar progreso, crear puntos de control y enrutar efectos secundarios externos a través del libro mayor sin incrustar la biblioteca:

uv pip install -e ".[mcp]"
CONTINUUM_MCP_MUTATING_CLIENTS=your-client-name continuum-mcp

Once herramientas a través de stdio. Tres son de solo lectura (continuum_validate, continuum_resume, continuum_list_actions); ocho mutan. Los efectos secundarios son de dos fases (reclamar, ejecutar, completar), y las herramientas mutantes deniegan por defecto detrás de una lista de permitidos. El estado reportado por el agente se registra con procedencia Origin.EXTERNAL_AGENT y se marca REQUIRES_REVIEW.

Los detalles de verificación, incluida la recuperación de fallos al inicio y la prueba de extremo a extremo de Claude Code, están en references/mcp.md. Si un servidor registrado reporta CONNECTION_CLOSED, la causa casi siempre es la resolución de PATH en lugar del servidor en sí: docs/api/mcp.md tiene el diagnóstico y dos remedios.

Integración de framework

Nueve adaptadores se incluyen en src/continuum/adapters/ (una fachada en proceso más ocho integraciones), todas instalaciones opcionales para que el núcleo siga siendo solo de biblioteca estándar:

Adaptador	Clase	Notas
Agente Python genérico	`GenericAgentAdapter`	Fachada en proceso; escribe estado confiable (`Origin.DETERMINISTIC`).
Sandbox de sistema de archivos	`FilesystemSandboxAdapter`	Sandbox de directorio local, sin servicio externo, predeterminado para docs y CI.
Python en proceso	`PythonInProcAdapter`	Ejecuta Python en un directorio de trabajo temporal, registra a través del libro mayor.
Contenedor	`ContainerAdapter`	Respaldado por Docker, omisión protegida cuando `docker` está ausente.
Navegador	`BrowserAdapter`	Respaldado por Playwright, omisión protegida cuando no está instalado.
Kubernetes	`KubernetesAdapter`	Respaldado por `kubectl`, omisión protegida cuando no está configurado.
OpenAI Agents SDK	`OpenAIAgentAdapter`	Experimental. Engancha `ToolContext` / `RunHooks`; `openai-agents` opcional.
LangGraph	`LangGraphAgentAdapter`	Experimental. Envuelve un `StateGraph`; `langgraph` opcional.
LangChain	`LangChainAgentAdapter`	Experimental. Inserta `checkpoint_node` en un pipeline LCEL `Runnable` y el bucle de llamadas a herramientas `create_agent`; `langchain` opcional.

Cada adaptador registra el progreso a través del libro mayor y enruta los efectos externos a través del protocolo de intercepción/completado de dos fases. Los tres adaptadores de framework tienen pruebas de integración de extremo a extremo y se han impulsado contra un modelo OpenRouter en vivo, donde las ejecuciones revelaron y luego cerraron una brecha de deduplicación por desviación de argumentos de LLM y dos errores del adaptador de OpenAI, incluida una prueba de fallo duro en vivo (os._exit(137) a mitad de efecto secundario) por adaptador. El uso completo, los resultados de modelos en vivo y los ejemplos ejecutables para cada adaptador están en references/adapters.md.

Las aplicaciones de producción de LangGraph también pueden mantener su API de persistencia nativa: make_continuum_checkpointer(storage) implementa el BaseCheckpointSaver de LangGraph sobre el almacenamiento de CONTINUUM, de modo que cada put aterriza en el mismo registro de eventos encadenado por hash y etiquetado con procedencia (consulta references/adapters.md).

Tres frameworks de producción adicionales están cubiertos por superficies de enganche delgadas y sin SDK en adapters/thin.py:

Framework	Superficie de intercepción	Punto de entrada
CrewAI	enganches globales antes/después de llamadas a herramientas	`install_crewai_hooks(storage, run_id)`
AutoGen core	`FunctionTool.run_json` envuelto en su lugar	`wrap_autogen_tool(tool, storage, run_id)`
Pydantic AI	capacidad de Hooks asíncronos	`Agent(capabilities=[wrap_pydantic_ai_hooks(storage, run_id)])`

Para pilas que ninguno de estos alcanza: continuum gateway aplica reclamaciones en HTTP saliente desde cualquier idioma, continuum.otel.make_span_processor(storage) convierte los tramos de herramientas OpenTelemetry existentes en evidencia, y continuum serve expone las mismas operaciones que las herramientas MCP sobre un protocolo de cable JSON independiente del idioma (stdio, o HTTP a través de --transport http con autenticación CONTINUUM_SERVE_TOKEN).

Reanudación de ejecuciones reportadas por agente o MCP

El estado reportado a través de MCP, o mediante el adaptador de OpenAI, lleva procedencia Origin.EXTERNAL_AGENT y se resuelve a request_human hasta que se confirme. Las ejecuciones de LangGraph y LangChain usan Origin.DETERMINISTIC y se reanudan directamente. Para despejar la revisión y reanudar:

continuum confirm <run_id>   # records REVIEW_CONFIRMED, then re-assesses
continuum resume <run_id>    # now reports RESUME

A través de MCP, el equivalente es la herramienta continuum_confirm seguida de continuum_resume. La confirmación es un evento único atestiguado por humanos: la vía de escape para la seguridad de autocertificación, de modo que una ejecución impulsada externamente nunca quede permanentemente atascada.

Conceptos centrales

La referencia profunda para cada concepto vive en references/concepts.md.

Puntos de control semánticos: una representación compacta y versionada de lo que el agente necesita para continuar.
Validación de estado: cada componente se verifica de forma independiente; el desfase se propaga a través del grafo de dependencias.
Libro mayor de acciones idempotentes: los efectos secundarios externos se rastrean y deduplican; los resultados inciertos se elevan en lugar de reintentar silenciosamente.
Modos de recuperación: RESUME, REPAIR_AND_RESUME, ROLLBACK, WAIT, REQUEST_HUMAN, ABORT (más REPLAN).
Contrato de recuperación: una próxima acción determinista, sellada por integridad y condicionada.

Arquitectura

CONTINUUM está organizado en torno a un invariante: cada hecho lleva su origen, y la confianza se gana, nunca se asume. El sistema tiene cinco capas, cinco costuras de integración y tres garantías.

Las tres garantías

Sin autocertificación. El estado reportado por el agente se marca EXTERNAL_AGENT y degrada a revisión humana al reanudar. Solo los escritores confiables (adaptadores en proceso, operadores de CLI) producen estado DETERMINISTIC.
Los efectos secundarios requieren reclamaciones. Los efectos externos se reclaman en un libro mayor idempotente antes de ejecutarse; los efectos no reclamados se bloquean en el límite del arnés.
Las decisiones de recuperación verifican contra la realidad. Los contratos de reanudación verifican el estado del punto de control contra el entorno actual (versiones de dependencias, digests de archivos, identidad del modelo) antes de declarar seguridad.

Cinco costuras de integración

Cualquier arnés de agente se conecta a través de exactamente una de estas; no se requiere cooperación del framework.

Seam 1: In-process adapters     GenericAgentAdapter.intercept_action(...);
         Python frameworks       wrap_tool(key_fn=...) on LangChain/LangGraph,
                                 OpenAI Agents SDK hooks
Seam 2: MCP server              continuum-mcp (11 tools over stdio)
         MCP-capable clients
Seam 3: CLI lifecycle hooks     continuum hooks install <client> [--with-gate]
         Coding CLIs             claude-code, gemini, codex
Seam 4: Enforcing HTTP gateway  continuum gateway --port N
         Any language            routes: .continuum/gateway.json
Seam 5: OpenTelemetry bridge    make_span_processor(storage)
         Traced applications     spans -> TOOL_COMPLETED evidence

Pipeline de aplicación

El pipeline de puerta a observación cierra la brecha de durabilidad en el límite del arnés:

PreToolUse hook                    PostToolUse hook
    |                                    |
    v                                    v
continuum gate                    continuum observe
    |                                    |
    |-- no claim? DENY (exit 2)          |-- TOOL_COMPLETED event:
    |   + instructions to claim          |     path, bytes, sha256
    |                                    |
    |-- live claim? ALLOW                |-- disk-checked status:
    |                                    |     verified / changed / missing
    v
agent performs effect
    |
    v
continuum_complete_action
    |
    v
claim settled from reality

Árbol de decisión de recuperación

El motor de recuperación evalúa las señales en orden de severidad y devuelve el máximo:

RESUME < REPAIR_AND_RESUME < REPLAN < WAIT < REQUEST_HUMAN < ROLLBACK < ABORT

Cada reanudación produce un contrato sellado con: estado de recuperación, componentes verificados/invalidados, próximos pasos ejecutables (human_steps), observaciones posteriores al punto de control (verificadas en disco), deriva de fijación y agregación familiar (multiagente).

Arquitectura de almacenamiento

Esquema v6. SQLite es el principal; Postgres está verificado por CI.

Tabla	Propósito
`events`	Registro de solo anexión encadenado por hash (36 tipos de eventos)
`runs`	Metadatos de ejecución con parent_run_id para multiagente
`versions`	Instantáneas de SemanticState por punto de control
`checkpoints`	Registros de puntos de control sellados
`action_index`	Proyección de idempotencia entre ejecuciones (esquema v3+)
`events_archive`	Almacenamiento de prefijo compactado (esquema v5+)
`lg_checkpoints` / `lg_writes`	Persistencia nativa de LangGraph (esquema v4+)

Mapa de módulos

CONTINUUM es una biblioteca (src/continuum, 104 módulos) más una gran suite de pruebas (98 archivos de prueba, ~1,380 pruebas). Todos los módulos anexan y reproducen un único registro de eventos encadenado por hash:

Módulo	Rol
`events.py`	Registro de eventos de solo anexión encadenado por hash y `verify()`
`state/`	Proyección, validación, extracción
`storage/`	SQLiteStorage (esquema v6), postgres.py, migrations.py, actionindex.py
`actions/`	Libro mayor de acciones idempotente, reconciliación, reclamación/completado, seguimiento de concesiones consumidas
`checkpoint/`	Puntos de control basados en políticas con anclaje forzado
`recovery/`	Motor, planificador, contrato sellado, guía, observaciones, resumen familiar, semántica de bifurcación, resúmenes de reintento informados
`gate.py`	Aplicación previa al uso de herramientas: permitir/denegar contra reclamaciones del libro mayor
`gateway.py`	Proxy HTTP de aplicación: reclamar antes de disparar para solicitudes salientes
`replayguard.py`	Guardia portátil de seguridad de reproducción: evaluate/protected_call/langgraph_protected_node
`hooks.py`	Ganchos de punto de control compartidos (punto de control automático, progreso derivado de archivos)
`clienthooks.py`	Perfiles de instalador de cliente y gestión de comandos de gancho
`budgets.py`	Registro y evaluación de presupuesto de reintentos
`pinning.py`	Normalización de fijación de versiones y detección de deriva
`replay_similarity.py`	Backends de similitud semántica (exacto/difuso/incrustación)
`reconcilers.py`	Registro de sondas para liquidación automática
`adapters/`	9 adaptadores basados en clases + ganchos delgados (CrewAI/AutoGen/Pydantic AI) + almacén de LangGraph
`mcp/`	11 herramientas stdio más autorización (autenticación de token, lista de permitidos, token de confirmación)
`serve/`	Sidecar (cable JSON stdio + transporte HTTP)
`dashboard/`	Panel web con botones HITL (confirmar/reconciliar/completar)
`cli/`	33 comandos argparse, códigos de salida como veredicto
`otel.py`	Puente de procesador de tramos de OpenTelemetry

Limitaciones honestas

La puerta no ve dentro de los comandos de shell (Bash/curl evaden las reclamaciones de herramientas estructuradas)
El backend de Postgres está probado por CI pero no probado en batalla en producción
Sin webhook de salida para notificaciones de request_human todavía
Un nivel de jerarquía multiagente v1
Descarga de carga útil (#254) aún no implementada

Referencia completa en references/architecture.md.

API y CLI

La superficie de Python (EventType, Run, SQLiteStorage, diff_states, project) y la API de adaptadores están documentadas con ejemplos ejecutables en references/api.md. La CLI es la misma superficie en forma de shell:

continuum runs                                   # list runs
continuum inspect <run_id>                       # semantic state
continuum validate <run_id> --env dataset=v4     # validate, read-only
continuum resume <run_id> --env dataset=v4       # recovery decision + contract + next steps
continuum checkpoint <run_id>                    # force a checkpoint, mutates
continuum actions <run_id>                       # external side effects
continuum reconcile <run_id>                     # settle uncertain effects with probes
continuum complete <run_id>                      # close a run as done, from the keyboard
continuum verify <run_id>                        # re-audit the event hash chain
continuum budget <run_id>                        # retry-budget usage per action type
continuum compact <run_id>                       # archive pre-anchor log prefix
continuum tree <parent_run_id>                   # show parent + children with recovery states
continuum attest <run_id> --key signer.pem       # sign the chain head for an external verifier

Todo el cableado es del lado del host; la cooperación del modelo es opcional:

continuum hooks install claude-code --with-gate   # coding CLIs: evidence, briefing, gate
continuum gateway --port 8765                     # enforcing HTTP proxy for everything else
provider.add_span_processor(continuum.otel.make_span_processor(storage))  # OTel to evidence
continuum-mcp                                     # anything MCP-capable: the eleven-tool server
continuum briefing                                # session-start context injection
continuum budget <run_id>                         # retry-budget usage report
continuum tree <parent_run_id>                    # multi-agent hierarchy view

Los registros opcionales viven junto a tu código y son datos, no código: .continuum/gate.json (herramientas de efectos secundarios + plantillas de clave estable), .continuum/reconcilers.json (sondas que verifican sistemas externos), .continuum/gateway.json (rutas ascendentes).

Cada comando acepta --json, y los comandos de solo lectura nunca escriben, por lo que son seguros contra una base de datos en vivo mientras un agente está en medio de una ejecución. Los códigos de salida son un contrato de seguridad (solo una ejecución verificada como segura sale con 0). Lista completa de comandos, tabla de códigos de salida y salida de diff de estado en references/cli.md.

Hoja de ruta

Fase	Componente	Estado
1-11	Modelos de datos, estado semántico, persistencia, puntos de control, validación, libro mayor de acciones, motor de recuperación, CLI, ejemplos de recuperación ante fallos, instantáneas/diffs de entorno, adaptadores de marco	Completo
12	Suite de referencia (CONTINUUM-Bench)	Completo (armazón mínimo)
13	API en la nube (FastAPI + PostgreSQL)	Parcial: el backend de almacenamiento PostgreSQL y el transporte sidecar HTTP (`continuum serve --transport http`) están publicados y probados por CI; el servicio multiinquilino alojado no ha comenzado
14	Panel	Completo (`continuum dashboard`)
15+	Plano de durabilidad aplicado: ganchos de observación, puerta, sesión informativa, sondas de reconciliador, puerta de aplicación, puente OTel, índice de acciones, guía ejecutable, instaladores multicliente, detección de reproducción semántica, fijación de versiones, presupuestos de reintentos, compactación de registros, superficie HITL, semántica de bifurcación, reintento informado, agregación multiagente	Completo (ver problema #213)
Siguiente	Plano de durabilidad a escala de meses: planes anclados a hitos (#312), memoria de intentos estructurada (#313), rebobinado atómico de doble estado (#292), referencia pública de corrección de recuperación (#293), notificaciones webhook-out (#305)	Planificado (borrador de especificación en docs/UPGRADE_SPEC.md)

Más allá del plan original: el servidor MCP, las capas de autorización MCP y autenticación de llamantes, procedencia y anti-autocertificación, archivos comunitarios, versionado de esquemas con migraciones hacia adelante, un contexto de recuperación acotado, seguimiento de concesiones consumidas, atestación de cadena de eventos Ed25519, el verificador de puntos de control nativo de LangGraph y artefactos wheel en cada push a main están publicados. Ver STATUS.md para el desglose verificado-vs-creído y errores de corrección abiertos.

Lo que CONTINUUM no es

No es esto	Es esto en su lugar
Un LLM	Una capa de confiabilidad para agentes que usan LLMs
Un marco de agentes	Una capa de recuperación que se conecta a cualquier marco
Una base de datos vectorial	Estado semántico estructurado, no incrustaciones
Un sistema RAG	Puntos de control verificados, no memoria aumentada por recuperación
Un motor de flujo de trabajo	Una capa de recuperación, no un orquestador

La abstracción central: semantic state + environment validation + action reconciliation = safe recovery.

Trabajo relacionado

CONTINUUM se encuentra en la intersección de ejecución duradera, seguimiento de efectos secundarios idempotente y recuperación ante fallos para agentes LLM. Los vecinos más cercanos son contratos de reanudación verificados por máquina (Khan 2026), procesamiento de transacciones agéntico con admisión restringida por restricciones (Mnemosyne 2026), análisis de ataques de reversión de puntos de control (ACRFence 2026) y defensa contra inyección de prompts a nivel de diseño (CaMeL 2025). La lista anotada completa, fundamentos y auditoría de citas están en references/related-work.md.

Estado y limitaciones

Probado: 1,360 aprobadas + 23 omitidas en una ejecución completa en la auditoría del 2026-08-24 de este árbol; CI aplica la suite en Python 3.11, 3.12 y 3.13, y los recuentos varían según la plataforma y servicios opcionales como Postgres (ver STATUS.md). La superficie MCP también ha sido auditada de manera adversaria sobre el protocolo en vivo; ver test.md.
En PyPI como continuum-agent 0.1.0 (pip install continuum-agent; el clon todavía funciona vía pip install . ver Inicio rápido).
La autenticación de llamantes MCP es opcional por implementación. Cuando CONTINUUM_MCP_TOKEN está configurado, el servidor rechaza cada herramienta mutadora a menos que el llamante presente ese secreto compartido en el initialize del apretón de manos _meta.authToken; los secretos por llamante están disponibles vía CONTINUUM_MCP_CLIENT_TOKENS (pares name:secret). Sin ningún token configurado, la autorización es solo por identidad declarada (el valor predeterminado histórico, preservado para uso local de un solo usuario).
Confirmar el estado autoinformado a través de MCP requiere un secreto separado. continuum_confirm rechaza a cada llamante hasta que el operador configure CONTINUUM_MCP_CONFIRM_TOKEN, porque un agente autorizado para registrar progreso no debe también poder confirmarlo. La ruta predeterminada sigue siendo impulsada por humanos: ejecuta continuum confirm <run_id> en el host.
Componentes no construidos: API en la nube (Fase 13).
Brecha de aplicación de comandos de shell: la puerta aplica reclamaciones para llamadas de herramientas estructuradas pero no puede ver dentro de comandos Bash/curl. Documentado como rechazo de alcance v1.
Los adaptadores de marco siguen siendo experimentales. Los tres adaptadores de marco ahora llevan pruebas de reanudación suave y fallo duro con modelos en vivo (OpenRouter, gpt-4o-mini), incluido el contrato de fallo que bloquea la reanudación ante un efecto secundario incierto, y ahora tienen pruebas de verificación de fallo y reanudación que logran paridad con la fachada genérica (Refs #285). Prefiere GenericAgentAdapter para recuperación en producción.
Las ejecuciones de agente/MCP necesitan una confirmación explícita antes de la reanudación automática. El estado reportado externamente es REQUIRES_REVIEW, por lo que continuum resume devuelve request_human hasta que un humano confirme. Por diseño, no es un error; ver Integración de marcos.
Serie de pruebas de autonomía e2e (problema #6): tres ejecuciones completas de Claude Code puntuaron 7/7 en mecánica con comportamiento de recuperación no solicitado observado. Iteraciones adicionales en diversos estilos de prompts siguen abiertas.

Contribuciones

Las contribuciones son bienvenidas. Este proyecto es de código abierto bajo Apache 2.0 y está deliberadamente construido para ser extendido: por investigadores que validan la semántica de recuperación, por ingenieros que portan el libro mayor o el servidor MCP a otros marcos o lenguajes, y por cualquiera que convierta la hoja de ruta planificada en realidad. Un buen lugar para comenzar es la etiqueta good first issue en el rastreador de problemas, o los errores de corrección abiertos listados en STATUS.md.

Abre un problema antes de enviar PRs grandes. Ver CONTRIBUTING.md para la guía de contribución completa, incluido el Código de conducta.

Contribuyentes

También con contribuciones fusionadas: Adhi1-2, yuki-fuyutsuki y okestroHjJeong.

Patrocinador

Si CONTINUUM ayuda a tus agentes a recuperarse de manera confiable, considera patrocinar para apoyar el mantenimiento a largo plazo.

Conviértete en patrocinador — GitHub Sponsors, o agrega un enlace personalizado FUNDING.yml si prefieres otra plataforma.

Licencia

Apache 2.0 - ver LICENSE.

Material de referencia profunda:

references/install.md - requisitos previos, niveles de instalación, mapa de paquetes, verificación
references/concepts.md - puntos de control semánticos, validación, libro mayor, modos de recuperación, contrato
references/architecture.md - modelo de datos, registro de eventos, proyección, almacenamiento, puntos de control, motor de recuperación, seguridad
references/adapters.md - uso de adaptadores de marco y resultados de validación con modelos en vivo
references/api.md - API de Python y adaptadores
references/cli.md - lista completa de comandos CLI, códigos de salida, diff de estado
references/mcp.md - estado del servidor MCP, verificación, preguntas abiertas
references/bench.md - diseño de CONTINUUM-Bench
references/quickstart.md - instalación, ejemplos, los scripts de prueba
references/e2e.md - recorrido de la prueba de autonomía de extremo a extremo
references/testing.md - diseño y convenciones de la suite de pruebas
references/related-work.md - trabajo relacionado anotado y auditoría de citas