loopx

LoopX

The open, provider-neutral, stateful control plane for long-horizon agents.

Runs on top of Codex, Claude Code, Cursor, and other agent harnesses. LoopX preserves objectives, gates, todos, evidence, quota, and handoffs across turns; the harness executes bounded work.

Public website · Blog · Docs · Developer Book · Try LoopX · See real loops · How it works · 简体中文

Open and provider-neutral, LoopX is a lightweight state kernel and local-first control plane for loop engineering. It runs on top of different agent harnesses rather than replacing them, providing the long-horizon state, semantic decisions about what happens next, governance, recovery, and human-agent collaboration that keep long-running work reviewable, restartable, and easier to hand off across turns, tools, and agents.

Loop engineering for long-horizon AI agents and peer agent teams.

Keep the loop moving. Keep the judgment human.

Learn LoopX

• Developer Book - the curated bilingual path from control-plane foundations to project onboarding and developer contributions. 中文版 · English
• Getting started - install, connect a project, and run your first governed loop. Guide
• Docs - the full reference and operations site. LoopX Docs

Meet the Personal Agent Workspace

Keep long-horizon goals in one local-first workspace. Goals, attention, conversations, tasks, files, schedules, and recovery stay durable across days, restarts, and harnesses. Reopen a project, inspect the previous turn’s state and evidence, and continue the next permitted action.

LoopX 1.0 brings these long-horizon control states into the Personal Workspace. It gives you one place to:

• see what needs you, what is running, what is being watched, and what is

scheduled or stopped;

• configure Goal capabilities, distinguish machine defaults from Goal overrides,

and preview changes before applying them;

• steer a live turn, queue a message, or use the async inbox from a connected

Lark conversation with explicit Goal/Agent/session routing;

• inspect deliverable files, periodic reports, and their supporting evidence;
• continue across Codex, Claude Code, direct-model, and other registered Agent

sessions without losing Goal state or evidence;

• review protected changes through typed preview, explicit confirmation, and

receipts while LoopX state—not the browser—remains authoritative.

For Manager group conversations, LoopX keeps message visibility separate from Turn authority; see the bilingual Lark Manager context and authority contract.

loopx dashboard

loopx dashboard is the supported browser/PWA launch path. You can also download native desktop previews from the 1.0 release; they reuse the same loopback services and Goal state. Apple Silicon macOS supports signed App updates that pair the shell with its bundled runtime, plus repair and recovery. Python 3.11+ is required; the App is ad-hoc signed, not notarized. Windows preview installers currently use manual updates and a separately installed CLI. Desktop installation, updates, and source development.

From a source checkout, run python -m demo.workspace serve to explore a community event, a home-energy comparison, and a neighborhood website release. Each has four work roles, 18 tasks, two decisions, and two watches. The screenshot above comes from this reproducible workspace. Scenarios and replay instructions.

· Read the workspace guide · Try the five-minute tour

Why LoopX

An agent can finish a task in one session. Long-running work is harder: objectives change, owner decisions appear, evidence goes stale, agents hand work to peers, and a scheduler can keep spending after no useful transition remains. Chat memory and a timer are not enough to govern that.

LoopX keeps the durable control state in one compact layer:

objective / issue / project
   │
   ▼
LoopX state: objective + gates + todos + scope + evidence + quota
   │
   ├─ human judgment needed? ── yes ─▶ ask a concrete question and wait
   │
   ├─ safe fallback available? ──────▶ run one bounded agent slice
   │
   ▼
Codex / Claude Code / Cursor / shell agent executes one turn
   │
   ▼
write evidence + handoff + next todo ─▶ quota decides the next tick

Agent runtimes execute the work. LoopX governs the state that lets engineering, research, discovery, and operations loops continue across runs. It is not another agent framework or a provider-specific orchestration runtime.

A useful mental model is an agent-native Kanban for long-running work. Cards carry identity, authority, evidence, and continuation. Moves are validated operators such as claim, gate, monitor, and writeback. The board is a projection; LoopX state remains the source of truth.

Registered agents are peers. Claims, leases, task boundaries, capabilities, and typed continuation decide who acts next; no durable leader identity is required.

LoopX is useful when you run:

• multi-day engineering, research, benchmark, or experiment objectives;
• issue and PR loops that must preserve scope, evidence, and review state;
• recurring heartbeat or monitor work;
• projects with owner, safety, publication, or private-data gates;
• peer-agent teams where ownership, leases, and handoff matter;
• creator, research, or operations workflows whose progress must remain

legible to a non-engineering operator.

LoopX is not an autonomous production controller. Dangerous permissions, publishing, production writes, and final ownership stay with the human.

Evidence

The public OpenViking contribution sequence and the redacted, owner-run Auto ML showcase each span 200+ hours of elapsed loop lifetime, preserving bounded turns, decisions, and evidence updates. This measures wall-clock project time, not continuous model execution or unattended production autonomy. Open each visual to inspect the public-safe task graph, evidence branches, and cross-turn decisions; each case states its source and reproducibility boundary.

Open-Source Issue Fix

200+ hour public contribution arc: PR delivery and reusable fix knowledge evolve together.

LoopX's creator uses this path as an OpenViking contributor. The represented public contribution sequence spans more than 200 elapsed hours from its first PR creation to the latest represented review or update. The Issue-Fix capability keeps rolling repository context, revision-stamped fix knowledge, and reviewer-facing preferences separate; linked PRs plus current checkout source and tests remain authoritative.

Auto ML Experiment

Redacted owner-run showcase: a 200+ hour experiment arc keeps hypotheses, matched evidence, invalid lineages, running replicates, and promote/stop gates visible in one graph.

The redacted public-safe graph preserves decision lineage across that 200+ hour elapsed window. It is an owner-run showcase, not a claim of continuous compute, independent reproduction, a production result, or company or employer endorsement. The redacted image is not sufficient to reproduce the underlying experiment independently.

Auto Research

Reproducible public KNN demo: proposer, executor, and evaluator/promoter agents iterate in parallel while todo, quota, evidence, and targeted wake remain visible.

This screenshot comes from LoopX's built-in exact-KNN demo. The public task, editable and protected files, deterministic CPU evaluator, and dev/held-out commands all live in this repository. Follow the or the demo command path to reproduce the workflow; it is a demo result, not a production research claim.

Used In Real Projects

• Independent user · `>13h` C++ accuracy run. The user reported that a

multi-stage task stayed aligned, triggered public research, adopted a public code-memory tool, and improved final precision. Read the evidence boundary.

• Independent user · `4d` unattended run. The user reported four days

without human intervention, useful ongoing work, and a periodic report surface. Read the redacted case.

• Independent user · `7` merged PRs. A LoopX-attributed Engine refactor is

visible in a public issue and seven merged PRs; attribution and the reported 1B+ token scale remain user reports. Inspect the case.

These are the three strongest current cases, not the full inventory. Browse the complete Showcase catalog for contributor cases, creator dogfooding, reproducible demos, and explicit evidence-strength labels.

Exploratory Benchmark Studies

• SWE-Marathon:

Five execution modes on 15 matched tasks compare self-verification, scores, and cost. More self-verification did not consistently yield higher scores.

• LHTB × LoopX:

Five execution mechanisms on 46 long-horizon terminal tasks compare durable state, bounded Todos, replanning, and fresh executor sessions.

• DeepSWE behavior analysis (Chinese):

Selected cases examine how domain hints relate to requirement retention and verification choices, offering mechanism hypotheses for further testing.

SWE-Marathon and LHTB have one effective trial per task and mode; DeepSWE uses selected cases and post-hoc analysis. None establishes a general performance gain.

More inspectable surfaces:

• the public homepage for the product

narrative, quick start, and long-running evidence;

• the complete Showcase catalog and its

bilingual hosted index;

• the cross-runtime implementation review demo;
• the public user manual.

Try LoopX

Requirements: Python 3.11+ and Node.js 22.18.0+; Node.js 24 LTS is recommended. Use an active Python environment whose console scripts are on PATH; macOS and Linux use a POSIX shell, while native Windows uses PowerShell 7. Node.js runs the managed, idle-exiting TypeScript Effect core; LoopX starts it automatically. Git is only needed for contributor clone/canary workflows.

Install from PyPI without cloning:

python3 -m pip install --upgrade loopx
loopx workflow-skills --install
loopx doctor

Existing installs can use loopx update plan and loopx update apply; LoopX keeps the detected pip, pipx, or archive owner instead of switching channels.

On native Windows PowerShell 7, use the same PyPI release without a POSIX compatibility layer:

py -3.11 -m pip install --upgrade loopx
loopx workflow-skills --install
loopx doctor

Restart your agent host after first install so it reloads the workflow skills. See Installing LoopX for pipx, host command surfaces, native Windows checkout installation, upgrade, rollback, uninstall, and the archive fallback.

Then connect from your project root: