LoopX: Open-Source Control Plane Runs AI Agents 200+ Hours Without Context Loss

Current AI coding agents excel at short tasks but fail on cross-session, multi-day work: they forget goals, lose context, burn tokens on idle loops, execute high-risk actions unchecked, and break when switching between tools like Claude Code, Codex, or Cursor.

What LoopX Is

LoopX is not a new AI runtime; it is a lightweight, local-first, vendor-neutral long-horizon agent control plane (state kernel) . AI tools handle bounded single-turn execution; LoopX owns cross-turn, cross-session, cross-day, cross-tool goal persistence, progress tracking, evidence retention, budget control, human handoff, and failure recovery . Its positioning: "turn capable agents into manageable, auditable, continuously improvable digital employees."

Core State Model (Eliminates State Drift)

LoopX moves long-task state out of chat context into structured, local, durable storage independent of model sessions:

Long-term Goal + Execution Gate + Todo List + Scope + Evidence Log + Quota Budget

Execution loop:

LoopX materializes global task state and issues a single-turn executable instruction.

AI tool completes the bounded execution.

Results, verification evidence, and change records are written back to LoopX.

LoopX evaluates budget, gates, and progress to decide: continue, wait for human, pause, stop, or hand off to another agent.

Unlike a naive while true loop that only repeats, LoopX ensures ordered, controllable, traceable, non-wasteful long-term execution.

Key Features (v0.5.4)

1. Local Persistent State Kernel

All task state, progress, evidence, and change history stored purely locally — no cloud, no session binding, no chat-log dependency. Survives terminal close, reboot, or week-long gaps. Enables seamless multi-agent relay : Claude writes code, Codex reviews, DeepSeek runs checks; tool switches without state loss or handoff gaps.

2. Smart Quota Mechanism (Stops Token Burn)

Before every auto run, loopx quota should-run validates: valid work exists, budget remains, execution has value. If no progress or state change, the round is skipped — no model call, no token spent . Pre-check failures and dry runs don't consume quota. Only verified successful executions spend a slot via loopx quota spend-slot. Solves the classic "cron job runs all night, wakes up to empty quota and zero output" problem.

3. Human Gates for High-Risk Ops

LoopX enforces machine executes, human decides . Explicit gates on production writes, code merges, public releases, sensitive data ops, and route changes. Task pauses at gate with a concrete confirmation question; proceeds only after human approval. LoopX is not a production automation controller; final authority stays with the user.

4. Visual Local Dashboard

loopx dashboard

launches a browser PWA console with auto-upgrade and self-healing. Single view of running, human-pending, scheduled, and stopped goals; per-round evidence, changes, todos, blockers; multi-agent session status, ownership, and handoff logs. No log digging or chat scrolling needed.

5. Full Ecosystem Compatibility

Zero vendor lock-in. Native support for Codex App/CLI, Claude Code, Cursor, DeepSeek Harness, KunlunCode, OpenCode, Pi, ZCode. Custom Runner interface allows in-house agents and multi-agent team workflows to plug in directly.

6. Verified 200+ Hour Real-World Traces

Unlike minute-long demos, LoopX publishes multiple 200+ hour production trajectories , fully auditable:

Open-source issue fixing: OpenViking contributor completed 200+ hour PR iteration, capturing reusable fix knowledge and repo context.

Auto ML experiments: 200+ hour run preserving hypotheses, verification evidence, discarded paths, promotion decisions.

Auto Research: Reproducible KNN multi-agent demo with proposal, execution, evaluation, promotion visualized end-to-end.

User cases: 13+ hour C++ precision tuning, 4-day unattended stable run, 7 merged PRs in engineering refactor — all public.

Official note: 200+ hours is wall-clock project duration, not continuous model inference; no exaggeration of autonomy.

Installation & Quick Start (v0.5.4, macOS/Linux/Windows PowerShell 7)

Prerequisites

Python 3.11+ (zero third-party deps), Windows requires PowerShell 7, macOS/Linux need POSIX terminal.

1. One-Click Install (PyPI)

# macOS / Linux terminal
python3 -m pip install --upgrade loopx
loopx workflow-skills --install
loopx doctor

# Windows PowerShell 7
py -3.11 -m pip install --upgrade loopx
loopx workflow-skills --install
loopx doctor

Restart AI tool clients after install to load new workflow skills.

2. Project Onboarding

cd /path/to/your-project
loopx connect
loopx status

If first run (state missing), guided init creates a long-horizon goal:

loopx start-goal --guided --project . --goal-text "Your long-term task goal"

3. Open Dashboard

loopx dashboard

Browser opens local console; multi-project management, live status refresh, background service survives window close.

4. Daily High-Frequency Commands

# Current task status, gates, todos
loopx status
# Historical execution trace & evidence
loopx history --goal-id GOAL_ID
# Pre-flight check to avoid empty burns
loopx quota should-run
# Generate retrospective report
loopx review-packet

5. Safe Upgrades

LoopX preserves original install channel (pip/pipx/source), never silently switches versions:

loopx update plan
loopx update apply

Best-Fit Scenarios (Long-Horizon, High-Control, Iterative)

Cross-day engineering: Large refactors, batch issue fixes, version upgrades — context and evidence stay intact.

Scheduled automation: PR monitoring, daily report generation, heartbeat checks — quota gate kills idle token burn.

AI research experiments: ML model iteration, algorithm search, controlled variable trials — full hypothesis/verification/discard trail kept for replay.

Approval-gated production tasks: Code deploy, data mutation, public content — human gate blocks autonomous risk.

Multi-agent collaboration: Division of labor, cross-review, task relay — clear ownership, lease permissions, handoff logs.

Not for: One-off scripts, simple Q&A, single-shot generation — deployment ROI too low.

Strengths & Limitations

✅ Core Strengths

Precise architecture: Ignores model arms race, focuses on long-task state governance — fills the core gap in AI tooling.

Lightweight, zero-dep: Pure Python, no external dependencies, local-first, no cloud upload, privacy-safe.

Extreme cost savings: Quota gate eliminates wasteful token spend at the source.

Safe by design: All high-risk ops require human sign-off; fits production environments.

Mature ecosystem: Mainstream tool adapters, visual panel, full docs, active iteration.

⚠️ Current Gaps

Learning curve: Large feature surface, many config dimensions; light AI users struggle to ramp quickly.

Advanced features experimental: Exploration, context learning, IM integration default off, still iterating.

Not fully autonomous: Cannot run zero-human production ops; requires human-AI collaboration; unsuitable for "set-and-forget" seekers.

Selection Guidance

Adopt if you:

Heavily use AI coding tools on multi-day, multi-turn complex tasks.

Suffer from context loss, state drift, token waste, unauditable runs.

Need replayable, traceable, controllable tasks for team collaboration and production.

Run multi-agent division of labor, research experiments, or automated patrols.

Avoid if you:

Only do simple writing, short coding, one-off tasks.

Want fully unattended autonomous production deployment.

Have zero baseline and won't learn basic CLI and task-governance concepts.

Why Long-Horizon Governance Now Matters

Model single-turn intelligence is commoditized. The real differentiator is sustainable, controllable, auditable, iterative long-horizon task execution . LoopX's value isn't making AI smarter — it's letting smart AI work continuously, stably, safely, and cheaply over the long haul . It turns chaotic chat context into structured, auditable, recoverable engineering state, converting fragmented AI executions into standardized digital-employee workflows. If you run complex long tasks with AI and hit disconnects, amnesia, token fires, or unauditable runs, LoopX is today's best answer.

https://github.com/huangruiteng/loopx