LoopX: Long-Horizon Agent Control Plane for Governed AI Workflows

Introduction

LoopX is an open, provider-neutral, and stateful control plane designed for long-horizon AI agents. It enables durable, governed work across various agent harnesses, including Codex App, Claude Code, and other custom setups. Instead of replacing existing agent runtimes, LoopX operates on top of them, providing essential capabilities for managing complex, long-running tasks.

It offers long-horizon state management, semantic decision-making, robust governance, recovery mechanisms, and seamless human-agent collaboration. LoopX ensures that objectives, gates, todos, evidence, quota, and handoffs remain stable and reviewable, making multi-day engineering, research, and operational workflows restartable and easier to manage across multiple turns, tools, and agents.

Installation

Getting started with LoopX is straightforward. Ensure you have Python 3.11+ installed and an active Python environment with console scripts on your PATH.

Install LoopX from PyPI:
```
python3 -m pip install --upgrade loopx
```
Install workflow skills:
```
loopx workflow-skills --install
```
Run a diagnostic check:
```
loopx doctor
```
This command verifies your setup.
Connect to your project:
Navigate to your project root and connect LoopX.
```
cd /path/to/your-project
loopx connect
```
If your project hasn't been initialized, use the guided path:
```
loopx start-goal --guided --project . --goal-text "Your long-running objective"
```
Remember to keep .loopx/, .codex/goals/, and .local/ ignored in your version control. For more detailed instructions, including pipx and native Windows installation, refer to the official documentation.

Examples

LoopX excels in managing real-world, long-running agent projects, providing clear evidence and traceability for complex workflows. Here are some notable examples:

Open-Source Issue Fix (200+ hours): This public contribution arc demonstrates PR delivery and the evolution of reusable fix knowledge. LoopX's creator uses this path as an OpenViking contributor, showcasing how the Issue-Fix capability maintains repository context, revision-stamped fix knowledge, and reviewer preferences across extended periods.
Auto ML Experiment (200+ hours): A redacted, owner-run showcase where LoopX managed a multi-day experiment arc. It kept hypotheses, matched evidence, invalid lineages, running replicates, and promotion/stop gates visible in a single graph, preserving decision lineage over hundreds of hours.
Auto Research (Reproducible KNN Demo): This built-in demo illustrates how proposer, executor, and evaluator/promoter agents iterate in parallel. LoopX ensures that todos, quota, evidence, and targeted wake activities remain visible, providing a clear view of the multi-agent workflow.

These examples highlight LoopX's ability to sustain and govern agent activities over extended durations, far beyond single-turn interactions.

Why Use LoopX

Traditional agent sessions often struggle with long-running work where objectives change, human decisions are needed, evidence becomes stale, or tasks are handed off between agents. LoopX addresses these challenges by providing a durable control plane that keeps the entire workflow manageable and transparent.

LoopX keeps the durable control state in one compact layer, offering five core promises:

What is the objective? It clearly tracks the active goal, explicit scope, and current authority, ensuring everyone understands the overarching aim.
What happens next? It provides ordered user and agent todos, managing ownership, claims, and leases for clear progression.
What needs human judgment? LoopX presents concrete user gates, replacing vague "waiting for owner" messages with actionable questions for human intervention.
What evidence changed? It maintains a compact run history, including validation, blockers, and accepted writeback, for full traceability and recovery.
May the loop continue? It governs continuation through quota, capabilities, safe fallbacks, scheduler hints, and explicit stop conditions, preventing uncontrolled execution.

LoopX is not another agent framework, but a lightweight state kernel that ensures long-running engineering, research, discovery, and operations loops can continue across runs, remaining reviewable, restartable, and auditable.