continuum-runtime

Read this in other languages: English, Русский.

Continuum 🔄

AI agents write code that works today and breaks tomorrow. Continuum fixes it forever.

Continuum is a deterministic runtime for AI-generated code. It captures what the AI decided to do, executes it in a sandbox, and proves the result is reproducible — or heals it when reality drifts.

Think of it as CI/CD for the AI era: not just "did the tests pass?" but "can we reproduce exactly what the AI built, and fix it when the world changes?"

npm install -g continuum-runtime

https://github.com/user-attachments/assets/fc314d49-c190-4bba-b9bc-025d9a0fd4c9

The Problem

Every day, millions of developers use AI to generate code. Every week, that code breaks:

• express patches from 4.21.2 to 4.21.3
• Node updates from 20.11 to 20.12
• A lockfile drifts
• The AI model changes behavior

The industry's answer: "Just run the AI again." That costs money, takes time, and produces different results.

Continuum's answer: Run once. Cache the plan. Replay forever. Heal when needed.

30-Second Demo

# 1. AI writes code (the only time you pay for LLM)
$ continuum run "Express API: GET /health, POST /echo, jest tests, pinned deps"
  ✓ Planned 6 steps via Claude
  ✓ Executed in sandbox
  ✓ Assertions: 3/3 passed
  → Run ID: abc-123

# 2. Same prompt, zero AI cost
$ continuum run "Express API: GET /health, POST /echo, jest tests, pinned deps"
  ✓ Plan cache hit — skipping LLM
  ✓ Executed in 12s
  → Run ID: def-456

# 3. Prove it's identical
$ continuum replay abc-123
  ✓ 6/6 artifact hashes match
  ✓ 3/3 assertions passed
  → REPLAY VERIFIED

# 4. A month later — dependencies drifted
$ continuum replay abc-123
  ✗ Drift detected: express 4.21.2 → 4.21.3
  ✗ Assertion failed: GET /health → 500

# 5. One command to fix everything
$ continuum replay abc-123 --heal
  ⚙ Level 1: Retrying flaky assertions... skipped
  ⚙ Level 2: npm ci (deterministic repair)... applied
  ⚙ Re-verifying... 3/3 assertions passed
  ✓ HEALED — generation 1 saved (zero LLM cost)

No AI was called during healing. The fix was mechanical. The LLM is only invoked as a last resort — when deterministic repairs fail.

How It Works

You: "build Express API with auth"
         │
         ▼
    ┌─────────┐     cache hit?     ┌──────────┐
    │ Planner │────── yes ────────▶│  Cached   │
    │ (LLM)   │                    │   Plan    │
    └────┬────┘                    └─────┬─────┘
         │ no                            │
         ▼                               ▼
    ┌─────────┐                    ┌───────────┐
    │ New Plan│───────────────────▶│  Execute  │
    │ (JSON)  │                    │ (sandbox) │
    └─────────┘                    └─────┬─────┘
                                         │
                                         ▼
                                  ┌──────────────┐
                                  │   Verify     │
                                  │ hash + assert│
                                  └──────┬───────┘
                                         │
                              ┌──────────┴──────────┐
                              │                     │
                         ✓ Verified            ✗ Drifted
                              │                     │
                         Save & done          Repair Cascade
                                                    │
                                          L1: Retry (flaky)
                                          L2: Deterministic fix
                                          L3: LLM repair (1 shot)
                                          L4: Manual (with diagnostics)

Every file gets a sha256 hash. Every command's exit code is recorded. The plan itself is hashed. Replay compares artifacts, not stdout — so npm warnings don't break your builds.

Verification: Two Independent Layers

	Hashes match	Hashes differ
Assertions pass	identical ✓	benign_drift — accept new reality
Assertions fail	regression — bug in plan	drifted — trigger Repair Cascade

Benign drift is the key insight: if package-lock.json changed but all tests still pass, that's not a failure — it's the world moving forward. Continuum accepts it and creates a new verified generation. No LLM needed.

The Repair Cascade

When assertions fail, Continuum doesn't immediately call an LLM. It tries the cheapest fix first:

Level	What	Cost	Example
1	Retry	$0	Flaky HTTP assertion → wait and retry
2	Deterministic fix	$0	Dep drift → npm ci from lockfile
3	LLM repair	~$0.03	Broken import → AI patches one file
4	Unrecoverable	$0	Major Node version → tells you exactly what to do

LLM is invoked in ~1 out of 10 failures. Everything else is mechanical.

CLI Reference

Command	What	LLM?
continuum run <prompt>	Plan + execute + verify	Yes (or cache)
continuum execute <plan.json>	Run any plan without LLM	No
continuum replay <run_id>	Re-execute + verify hashes	No
continuum replay <id> --heal	Detect drift + Repair Cascade	Rarely
continuum explain <run_id>	Human-readable step-by-step	No
continuum inspect <run_id>	Full run data (--json)	No
continuum diff <id1> <id2>	Compare artifact hashes	No
continuum history <plan_hash>	Show generation lineage	No
continuum list	List all runs	No
continuum freeze	Snapshot environment versions	No

8 out of 10 commands never touch an LLM. The runtime is the product, not the AI.

Plan = Executable Artifact

Plans are JSON. They can be written by AI, written by hand, or exported from any run:

# Export a plan from a previous run
continuum inspect abc-123 --json | jq '.plan' > my-api.plan.json

# Anyone can execute it — no API key needed
continuum execute my-api.plan.json

# Same result. Every time.

Plans track their lineage — every repair creates a new generation with full ancestry:

$ continuum history sha256:aaa
  gen 0: sha256:aaa (original, claude-sonnet, Jan 15)
    └─ gen 1: sha256:bbb (deterministic: npm-ci, Feb 25)
        └─ gen 2: sha256:ccc (llm-repair: 1 mutation, Mar 15)

When to Use Continuum

Scenario	Without Continuum	With Continuum
AI-generated project breaks after a month	Re-run AI ($), hope for the same result	replay --heal, fixed in seconds
Team member needs the same setup	"Ask the AI again"	continuum execute plan.json
CI for AI-produced code	Tests pass today, mystery tomorrow	Deterministic replay + assertions
Audit trail for AI decisions	Chat logs (useless)	Hashed plan + lineage chain
Reproducible experiments	"It worked on my machine"	Replay with environment fingerprint

Requirements

• Node.js ≥ 20
• Docker (for sandbox isolation)
• Anthropic API key (only for continuum run — everything else is local)

Philosophy (for the curious)

Why "runtime" and not "agent framework"?

Every AI tool today focuses on making agents smarter. Continuum focuses on making results stable.

The LLM is a compiler — invoked once to produce a plan, then never needed again. Execution is deterministic. Verification is cryptographic. Repair is mechanical first, intelligent last.

This is the missing layer between "AI wrote code" and "code is in production":

Git    → tracks what changed
Docker → tracks where it runs
CI/CD  → tracks when it runs
Continuum → tracks WHY it was built and PROVES it still works

Contributing

We're building developer infrastructure, not an AI product. PRs welcome.

git clone https://github.com/Asouei/continuum-runtime
cd continuum-runtime
npm install
npm test

🍜 Support the Developer

I built Continuum over a single weekend from a café in Vietnam — juggling two jobs, freelancing to stay afloat, and trying not to burn out. The reason was blunt: I was tired of AI-generated code “working” today and exploding tomorrow because the world drifted (deps, environment, CI, everything).

If Continuum saves you or your team hours of CI/CD debugging or real money on API tokens, consider buying me a bowl of Pho. It genuinely helps keep the project alive and moving.

🪙 USDT (TRC20): TXKc7fCQicpcNV2UrthWbAYNz46xs47rmx 🏦 Bybit UID: 122577535

License

MIT