loopx-project/loopxPublic

The control plane for 24/7 always-on agents. Turn long-horizon goals into verifiable results across Codex, Claude Code, and custom runtimes—from local SQLite to team scale.

AI summary: An open, stateful control plane that manages long-horizon execution and governance for AI agent harnesses.

Stars
6.7K
+109 today
Forks
637
Watchers
28
Open issues
139
Open PRs
93
Contributors
~139
Commits
16.6K
Branches
410

PythonApache-2.0Created May 31, 2026Last push 1d agoLatest release v2.3.0+151 stars this week+352 this month

Quick answers

What is loopx?
An open, stateful control plane that manages long-horizon execution and governance for AI agent harnesses.
What does loopx do?
LoopX acts as a lightweight, provider-neutral orchestration layer designed to manage the execution loops of long-running AI agents. Instead of replacing existing tools like Cursor or Claude Code, it wraps around them to provide a stable, long-horizon state kernel. It handles complex semantic decisions, enforces execution quotas, manages task gating, and facilitates safe human-agent collaboration. By maintaining persistent state objectives and evidence tracking while the underlying harness executes bounded turns, it turns single-prompt coding assistants into manageable, auditable digital employees capable of sustained autonomous work.
Who is loopx for?
AI engineers, engineering managers, and power users who want to orchestrate and safely manage long-running autonomous tasks using existing coding assistants. Familiarity with Python is recommended.
How do I get started with loopx?
git clone https://github.com/huangruiteng/loopx.git
How popular is loopx on GitHub?
loopx-project/loopx has 6,725 stars and 637 forks on GitHub, and gained 151 stars in the last 7 days.
What license does loopx use?
loopx-project/loopx is released under the Apache-2.0 license.

Star history

since Aug 6, 2026
02K4K6KAug 2026Sep 2026Oct 2026Nov 2026
6.7K stars as of Nov 19, 2026. Measured daily since Aug 6, 2026; GitHub no longer exposes earlier star timestamps.

Update history

8 recorded
  • Nov 15, 2026New release v2.3.0 (previously v2.2.0).
  • Nov 15, 2026Description changed from "Turn long-horizon goals into verifiable results. A local-first semantic control plane and research workbench for long-ru" to "The control plane for 24/7 always-on agents. Turn long-horizon goals into verifiable results across Codex, Claude Code, ".
  • Nov 4, 2026New release v2.2.0 (previously v2.1.1).
  • Oct 25, 2026Description changed from "Turn long-horizon goals into verifiable results. A local-first control plane and research workbench for agents and teams" to "Turn long-horizon goals into verifiable results. A local-first semantic control plane and research workbench for long-ru".
  • Oct 23, 2026New release v2.1.1 (previously v1.4.0).
  • Oct 23, 2026Description changed from "Local-first control plane and research workbench for long-horizon agents and teams. Durable goals, governed collaboratio" to "Turn long-horizon goals into verifiable results. A local-first control plane and research workbench for agents and teams".
  • Oct 20, 2026Description changed from "A control plane with a durable state kernel for long-horizon agents and teams. Keep work moving and improving across ses" to "Local-first control plane and research workbench for long-horizon agents and teams. Durable goals, governed collaboratio".
  • Oct 12, 2026New release v1.4.0 (previously v1.2.3).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 0 commits2026-04-07: 0 commits2026-04-08: 0 commits2026-04-09: 0 commits2026-04-10: 0 commits2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 0 commits2026-04-14: 0 commits2026-04-15: 0 commits2026-04-16: 0 commits2026-04-17: 0 commits2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 0 commits2026-04-21: 0 commits2026-04-22: 0 commits2026-04-23: 0 commits2026-04-24: 0 commits2026-04-25: 0 commits2026-04-26: 0 commits2026-04-27: 0 commits2026-04-28: 0 commits2026-04-29: 0 commits2026-04-30: 0 commits2026-05-01: 0 commits2026-05-02: 0 commits2026-05-03: 0 commits2026-05-04: 0 commits2026-05-05: 0 commits2026-05-06: 0 commits2026-05-07: 0 commits2026-05-08: 0 commits2026-05-09: 0 commits2026-05-10: 0 commits2026-05-11: 0 commits2026-05-12: 0 commits2026-05-13: 0 commits2026-05-14: 0 commits2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 0 commits2026-05-18: 0 commits2026-05-19: 0 commits2026-05-20: 0 commits2026-05-21: 0 commits2026-05-22: 0 commits2026-05-23: 0 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 0 commits2026-05-27: 0 commits2026-05-28: 0 commits2026-05-29: 0 commits2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 33 commits2026-06-02: 106 commits2026-06-03: 44 commits2026-06-04: 47 commits2026-06-05: 0 commits2026-06-06: 54 commits2026-06-07: 55 commits2026-06-08: 48 commits2026-06-09: 0 commits2026-06-10: 32 commits2026-06-11: 43 commits2026-06-12: 0 commits2026-06-13: 9 commits2026-06-14: 23 commits2026-06-15: 0 commits2026-06-16: 0 commits2026-06-17: 25 commits2026-06-18: 108 commits2026-06-19: 74 commits2026-06-20: 117 commits2026-06-21: 183 commits2026-06-22: 82 commits2026-06-23: 144 commits2026-06-24: 98 commits2026-06-25: 36 commits2026-06-26: 19 commits2026-06-27: 88 commits2026-06-28: 88 commits2026-06-29: 39 commits2026-06-30: 84 commits2026-07-01: 82 commits2026-07-02: 89 commits2026-07-03: 126 commits2026-07-04: 208 commits2026-07-05: 136 commits2026-07-06: 126 commits2026-07-07: 37 commits2026-07-08: 95 commits2026-07-09: 63 commits2026-07-10: 76 commits2026-07-11: 114 commits2026-07-12: 102 commits2026-07-13: 60 commits2026-07-14: 65 commits2026-07-15: 89 commits2026-07-16: 87 commits2026-07-17: 53 commits2026-07-18: 58 commits2026-07-19: 90 commits2026-07-20: 48 commits2026-07-21: 45 commits2026-07-22: 29 commits2026-07-23: 26 commits2026-07-24: 55 commits2026-07-25: 14 commits2026-07-26: 36 commits2026-07-27: 13 commits2026-07-28: 25 commits2026-07-29: 48 commits2026-07-30: 34 commits2026-07-31: 30 commits2026-08-01: 24 commits2026-08-02: 39 commits2026-08-03: 26 commits2026-08-04: 30 commits2026-08-05: 25 commits2026-08-06: 33 commits2026-08-07: 27 commits2026-08-08: 61 commits2026-08-09: 131 commits2026-08-10: 27 commits2026-08-11: 43 commits2026-08-12: 34 commits2026-08-13: 24 commits2026-08-14: 39 commits2026-08-15: 40 commits2026-08-16: 39 commits2026-08-17: 19 commits2026-08-18: 12 commits2026-08-19: 56 commits2026-08-20: 67 commits2026-08-21: 35 commits2026-08-22: 48 commits2026-08-23: 63 commits2026-08-24: 34 commits2026-08-25: 82 commits2026-08-26: 82 commits2026-08-27: 38 commits2026-08-28: 15 commits2026-08-29: 32 commits2026-08-30: 42 commits2026-08-31: 21 commits2026-09-01: 35 commits2026-09-02: 46 commits2026-09-03: 59 commits2026-09-04: 48 commits2026-09-05: 97 commits2026-09-06: 131 commits2026-09-07: 126 commits2026-09-08: 85 commits2026-09-09: 61 commits2026-09-10: 54 commits2026-09-11: 65 commits2026-09-12: 53 commits2026-09-13: 47 commits2026-09-14: 88 commits2026-09-15: 157 commits2026-09-16: 122 commits2026-09-17: 267 commits2026-09-18: 178 commits2026-09-19: 67 commits2026-09-20: 182 commits2026-09-21: 225 commits2026-09-22: 75 commits2026-09-23: 171 commits2026-09-24: 205 commits2026-09-25: 148 commits2026-09-26: 102 commits2026-09-27: 155 commits2026-09-28: 71 commits2026-09-29: 85 commits2026-09-30: 97 commits2026-10-01: 136 commits2026-10-02: 181 commits2026-10-03: 153 commits2026-10-04: 171 commits2026-10-05: 227 commits2026-10-06: 270 commits2026-10-07: 213 commits2026-10-08: 171 commits2026-10-09: 152 commits2026-10-10: 198 commits2026-10-11: 241 commits2026-10-12: 212 commits2026-10-13: 232 commits2026-10-14: 125 commits2026-10-15: 176 commits2026-10-16: 210 commits2026-10-17: 235 commits2026-10-18: 128 commits2026-10-19: 132 commits2026-10-20: 130 commits2026-10-21: 103 commits2026-10-22: 210 commits2026-10-23: 160 commits2026-10-24: 171 commits2026-10-25: 141 commits2026-10-26: 129 commits2026-10-27: 212 commits2026-10-28: 155 commits2026-10-29: 177 commits2026-10-30: 94 commits2026-10-31: 21 commits2026-11-01: 235 commits2026-11-02: 135 commits2026-11-03: 206 commits2026-11-04: 73 commits2026-11-05: 136 commits2026-11-06: 125 commits2026-11-07: 241 commits2026-11-08: 255 commits2026-11-09: 167 commits2026-11-10: 173 commits2026-11-11: 130 commits2026-11-12: 38 commits2026-11-13: 78 commits2026-11-14: 189 commits2026-11-15: 48 commits2026-11-16: 0 commits2026-11-17: 0 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
15,923 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Very active

    15,923 commits in 52 weeks

  • Community-driven

    ~139 contributors

  • Well documented

    High community health score

  • Permissive license

    Apache-2.0

  • Continuous integration

    Automated checks passing

  • Repeat trending

    13 trending appearances

What loopx does

LoopX acts as a lightweight, provider-neutral orchestration layer designed to manage the execution loops of long-running AI agents. Instead of replacing existing tools like Cursor or Claude Code, it wraps around them to provide a stable, long-horizon state kernel. It handles complex semantic decisions, enforces execution quotas, manages task gating, and facilitates safe human-agent collaboration. By maintaining persistent state objectives and evidence tracking while the underlying harness executes bounded turns, it turns single-prompt coding assistants into manageable, auditable digital employees capable of sustained autonomous work.

AI engineers, engineering managers, and power users who want to orchestrate and safely manage long-running autonomous tasks using existing coding assistants. Familiarity with Python is recommended.

  • Provider-neutral orchestration: Runs seamlessly on top of various agent harnesses without locking the user into a specific ecosystem.
  • Persistent state management: Maintains long-term objectives, sub-tasks, and execution context across multiple bounded agent turns.
  • Execution governance: Enforces strict quotas, semantic gates, and manual approval pauses to prevent runaway agent behavior.
  • Resilient error recovery: Automatically handles failures and enables the agent to pause, reflect, and recover without losing the overarching context.
  • Local-first architecture: Processes state and orchestration logic locally to ensure sensitive workflow data remains secure.

Where teams use it

Long-horizon codebase refactoring

Developers can assign a massive refactoring task to an agent, and LoopX will manage the multi-step execution, pausing for human review at critical gates.

Auditable autonomous agents

Engineering teams can deploy autonomous workers knowing that every decision, tool call, and failure is logged in a stable, persistent state.

Managing fragile agent harnesses

Users can wrap a basic terminal agent in LoopX to give it the ability to recover from context window exhaustion and network failures.

Human-in-the-loop collaboration

Project managers can define complex workflows where an agent drafts code, stops for approval, and then proceeds to deployment based on human input.

Getting started: git clone https://github.com/huangruiteng/loopx.git

README

main branch

LoopX 2.0

LoopX — #1 on GitHub Trending, tracked by Trendshift

Start with one goal. Keep long-running agent work verifiable.

Tell the Agent you already use what you want done. LoopX preserves goals, progress, decisions and verifiable results so work can continue across sessions.
An open, harness-neutral control plane for 24/7 always-on agents across Codex, Claude Code, DeepSeek Harness and other runtimes—scaling from local SQLite workflows to multi-agent teams.

Release License TypeScript core Python

Local-first state Loop Agents GitHub contributors Discord Listed on dsh-plugin.org

Get started · Why LoopX · 24/7 Always-On · See it in action · Evidence · Contribute · Docs · 简体中文


Start with one goal

1. Install LoopX once. Requires Python 3.11+ and Node.js 22.22.3+ (24 LTS recommended).

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

Install options and upgrades

2. Tell your Agent the outcome. Restart your Agent host, open your project, then send one natural-language goal:

$loopx speed up this project's slowest workflow; compare approaches and verify the gains

LoopX turns that into a visible plan, decisions that need you, and verification as needed. Claude Code uses /loopx <complex task>; see host setup for other runtimes. Prefer a guided first run? Choose a task below.

📰 News

  • 2026-11-01 · 📘 Progressive context delivery for 24/7 agents — Compaction-cycle structured deltas and progressive views cut control-plane bytes across 213 model-facing wakes (32.5% single-layer progressive view; 3.0% body / 5.0% CLI stacked first-read entry across 112 in-cycle continuations) while preserving lossless baseline recovery (47-day freshness postmortem).
  • 2026-10-25 · 🤝 Long-horizon agent research: collaborators welcome — Exploring breakthroughs in long-horizon outcomes under equal budgets, through feedback, replanning and reproducible evaluation on EdgeBench and real-world tasks. Academic labs and industry teams are welcome to collaborate, comparing outcomes and total cost. Discuss collaboration.
  • 2026-10-20 · 🚀 LoopX 2.0 — A shared TypeScript state layer and long-horizon research workbench. Migration guide · Engineering story.
  • 2026-10-14 · 🤖 Agentic software — Connecting goals, evidence and human feedback to engineering delivery.
  • 2026-10-02 · 🧠 Long-horizon bootstrapping & RSI — Four months of developing LoopX with LoopX: public project history and a design perspective on system-level self-improvement.
  • 2026-09-18 · 🧪 LoopX × LHTB — A 46-task, same-model study provides empirical support for trading more compute for better outcomes: LoopX 1.0.3 Heartbeat continued runs reach mean reward 17.3% above Plain Codex and 10.6% above native Goal.
  • 2026-09-06 · 🎉 LoopX 1.0 — A Personal Agent Workspace to follow agent work, act on decisions, and inspect delivered results across sessions. Workspace guide.
  • 2026-08-02 · ⏱️ 200+ hour trajectories shared on X — Early owner-run examples spanning 200+ elapsed hours drew broad attention on X, showing work across execution, waits, human decisions and recovery. Trajectories and limits.

All releases

Why LoopX

You should not have to learn LoopX internals before the first useful action. The default path is goal-first: describe the outcome, let the Agent prepare the plan, and inspect the machinery only when a decision or debugging need calls for it.

An agent can finish a task in one session. Long-running work is harder: objectives change, owner decisions appear, evidence goes stale, and agents hand work to peers. A timer can keep a loop running without making it useful.

  • Continue without starting over. Keep the Goal, accepted requirements, decisions and evidence across sessions and restarts.
  • Coordinate without dropping context. Connect delegated work, dependent artifacts, review and returned results while keeping responsibility explicit.
  • Judge progress by what changed. Inspect deliverables, supporting and refuting evidence, costs and the next decision—not just activity.

Your Agent runtime supplies the model and tools. LoopX’s durable state layer preserves goals, acceptance, decisions, ownership and evidence across sessions and runtimes for engineering, research and operations. Agents and people use those facts to reassess what to do next. Human authorization still governs protected actions.

What you want to do Start here
Keep a coding or research agent working across sessions Install and start
Manage personal projects, schedules and decisions in one place Personal Agent Workspace
Wire up a 24/7 always-on agent without hand-rolling infra 24/7 Always-On Agent Control Plane
Let agents collaborate and deliver verifiable results Agent collaboration guide

LoopX keeps the durable work state in one compact layer:

Your harness runs the turn. LoopX carries the work.

Agent runtimes execute the work. LoopX keeps 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.

Advanced: how the control layer works and where it fits Advanced view of a governed state transition, not just a timer.

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.

Building 24/7 Always-On Agents Without Hand-Rolling the 5 Subsystems

Anthropic's Building always-on agents notes that effective persistent agents spend most of their wall-clock life asleep at zero tokens and wake for bounded runs across five surrounding subsystems: Event Inbox, Timers, Memory, Permissions, and an Outbox. In practice, teams often re-build fragile glue—cron scripts, JSON queues, prompt compaction, and ad-hoc approval checks—for every agent host, only to hit silent staleness, duplicate writes, or noisy status spam by week two.

LoopX packages that open, harness-neutral control layer so the runtimes you already use (Codex CLI, Claude Code, DeepSeek Harness, or custom runners) can operate 24/7 with explicit durability and human gates:

Always-on primitive LoopX control-plane subsystem What it prevents in multi-week runs
Event Inbox Single-flight Goal / Todo / Hard Lease queue, async app inbox, and connected Lark / GitHub listeners Duplicate workers mutating the same repo state; dropped human inputs mid-run
Timers & Wakeups Guarded Heartbeat and safe recurring presets (daily-triage, changelog-draft, pr-watch; inspect via loopx preset list) Blind cron loops burning tokens when nothing changed or a gate is still waiting on a human
Memory & Compaction Decision Context source tracking, compaction-cycle Progressive + Delta context_delivery (32.5% view across 213 wakes; 3.0% / 5.0% first-read entry across 112 in-cycle wakes), and optional Reward Memory Silent source staleness (5 incidents across 253 turns / 47 days); compounding prompt replay or broken deltas across compaction
Permissions & Deferred Calls Explicit owner, safety, publication, and private-data gates, isolated worktrees, and review-ready handoffs Autonomous cron runs publishing externally, forcing merges, or leaking private context
Outbox Shared Workspace & Lark Goal/Decision/Evidence views surfacing genuine completions, blockers, and open gates Fragmented terminal logs and high-noise pings that force humans to babysit runs

Solo local to team & organizational scale—on one set of contracts:

Scale How LoopX runs Authority, collaboration & governance posture
Solo developer & local agent python3 -m pip install --upgrade loopx with zero external infrastructure; connect your existing CLI/Desktop runtime Canonical local SQLite store with hard leases (plus existing File setups), surviving restarts and compaction at zero idle tokens
Engineering team & enterprise path Peer workers claim todos and return reviewed artifacts on shared Goals via Desktop Workspace, GitHub, and Lark (three-agent demo) Preserves worker ownership and human approval gates; extends to staged PostgreSQL remote authority (provider) and planned org governance—RBAC, SSO, quotas, signed audit—in the adoption & SaaS roadmap

See LoopX in Action

LoopX 2.0, the long-horizon research workbench for enterprise teams, research organizations and independent builders; recorded research history with count ribbons redrawn to scale in a labelled App frame
Watch the research-workbench film · 86s · transcripts, subtitles and sources. Recorded App excerpts, synthetic examples and illustrations are labelled.

Research that can continue

Open a Goal to inspect its work, responsible Agents and recorded Explore history. Use Deep analysis to inspect a registered trajectory, its citations, native outcome readback and separately measured costs. Research also shows source-bound human attention, with recorded inputs, timing coverage and inspectable optimization points. An Agent prepares the source; opening a page or reading a result does not start a model call. Explicit analysis uses the configured host and account.

Keep supported, refuted and unknown findings visible. Inspect why an approach changed or continued, then carry the evidence into the next attempt.

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.

For a new default Codex Goal, review the task and workspace permission before confirming Create Goal and start first run. The original task continues in its original conversation when independent checks and allowance are ready; ordinary messages remain read-only. Follow the workspace guide for waiting, result readback and recovery.

LoopX 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 current 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 NSIS preview installers support the same signed update flow on the main channel, with a separately installed CLI; the stable channel and MSI installs stay manual, App rollback and repair are unavailable, and the installer carries no Authenticode certificate (Windows may show a SmartScreen prompt). Desktop installation, updates, and source development.

Real Workspace recording: configure child-task capacity and allowed responsibility domains

Capability settings and reproducible workspace scenarios

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.

Watch the full 32-second walkthrough · Read the workspace guide · Try the five-minute tour

Try LoopX

Choose a walkthrough with a result you can inspect:

Start with What you'll do
Your first bug-fixing loop Reproduce two bugs in a small Python project, let the Agent fix them, then check the tests and patch.
Long-running coding work Fix an issue or keep improving your own repository, with review, evidence and recovery across sessions.
Personal Agent Workspace (中文) Follow the illustrated guide to manage projects, conversations, tasks and delivered results in the App.

Start From Your Agent

After the two-step setup, use the entry for your host in a session opened on your project:

Host Start and confirm continuation
Codex App $loopx <complex task>; confirm the heartbeat automation is saved.
Codex CLI $loopx <complex task>; activate the generated native /goal in the same session.
Claude Code /loopx <complex task>; follow the loop driver setup for recurring work.
DeepSeek Harness Install the native DSH plugin, select the loopx skill, then describe the task

LoopX reuses existing project state or connects the project, plans the work as Todos and guides host activation. Ask your Agent to confirm the active Goal, next Todo and continuation mechanism; a setup packet alone is not an active loop. Keep the host available for continued work. loopx status shows the Goal, decisions waiting for you and the next Todo; loopx doctor diagnoses the install.

Installing LoopX covers native Windows, pipx, upgrades, rollback and uninstall.

Upgrading from 1.x? Read the 2.0 migration and recovery guide before continuing existing Goals.

Other hosts, loop drivers and custom runners
Host Recommended start Loop driver
Codex App $loopx <complex task>, or choose loopx from /skills, in a thread opened on the project. Codex App heartbeat automation, refreshed from quota should-run.scheduler_hint
Codex App over SSH loopx agent-onboard --agent-type codex-app-ssh --project . The returned visible /goal <task_body>
Codex CLI Start codex in the project, then $loopx <complex task> or /skills. Visible /goal <task_body>; no hidden headless execution by default
Claude Code Install the opt-in adapter, then run /loopx <task> followed by /loop. Native Claude Code /loop gated by LoopX
KunlunCode Run loopx-kunluncode connect --project . --goal-id <goal-id> --agent-id <registered-agent-id>, add a bounded todo, then run loopx-kunluncode run --project .. Native Goal Pro through app-server; LoopX writes completion and quota only after strict verification
OpenCode Install the static command facade; opt in to --with-goal-bridge for recurring goals. OpenCode command facade and explicit goal bridge
Pi Install the opt-in goal extension with loopx slash-commands --install --surface pi, then use /loopx <task> from a trusted Pi session. Visible Pi goal extension gated by LoopX quota (loopx_goal_activate + agent_settled continuation)
ZCode Install the skill facade with loopx slash-commands --install --surface zcode, then invoke the $loopx skill (or /loopx <complex task>) from a ZCode session in the project. The ZCode session's own turn loop; every continuation enters through quota should-run
Antigravity CLI (agy) Install the skill facade with loopx slash-commands --install --surface agy, then invoke the loopx skill (or /loopx <complex task>) from an agy session in the project. The session's native /goal loop (audited until <!-- GOAL_COMPLETE -->) with schedule self-wakes while the session lives; the facade instructs every turn/wake to re-enter through quota should-run — advisory pacing, not a host-enforced gate
Kiro CLI Install the skill facade with loopx slash-commands --install --surface kiro-cli, then run /loopx <complex task> from a kiro-cli session in the project. The session's native /goal --max <N> <task_body> Done when: <criteria> loop, with the acceptance criteria stated inside the goal statement because the host derives them from it, bounded by the host's own iteration budget (default 5) and settled through the built-in goal completion contract; the facade instructs every turn and iteration to re-enter through quota should-run — advisory pacing, not a host-enforced gate
DeepSeek Harness (dsh) Install the native DSH plugin, select the loopx skill, and describe the task. The dsh goal-mode adapter remains available for headless turns. Native same-session continuation and GoalBar, or headless dsh segments; both remain gated by LoopX authority
Cursor, shell, or custom runner loopx start-goal --guided --project . --goal-text "<task>", or call LoopX from your runner. Your shell, scheduler, or runner

The exact, copy-ready setup messages and host recovery paths live in Getting Started. Host integrations can inspect the Codex App host command registry contract, the Codex CLI packaged install path, the Claude Code adapter, the KunlunCode native Goal adapter, the Kiro CLI goal-mode adapter, or the DeepSeek Harness turn adapter.

See the 60-second DSH × LoopX Replan recording and reproducible fixture for the native path: install the plugin, select one skill, change a material constraint, and inspect the preserved decision trail.

For custom runners, start with the minimal custom runtime example (python3 examples/custom-runtime-minimal-cli-turn-smoke.py), then the full Embed LoopX in Your Agent Runner guide and the worker bridge install contract. The core tick is deliberately small:

loopx quota should-run      # should this registered agent act now?
loopx todo claim            # who owns this slice?
loopx todo update           # what changed?
loopx refresh-state         # what should the next turn see?
loopx quota spend-slot      # account for a completed, validated slice

Clone-based install is only for contributors who want the live canary wrapper:

git clone https://github.com/loopx-project/loopx ~/loopx
~/loopx/scripts/install-local.sh
loopx doctor

First-Run Feedback

If LoopX works for you, a one-minute public issue helps us learn what a real first run looks like. It is optional, contains no telemetry, and should not include logs, paths, credentials, internal project names, or goal contents:

loopx first-run-report prints the same prefilled link locally without sending anything.

Basic usage statistics default on after first-use disclosure: a daily random-ID heartbeat for platform support and continued use, plus separate ID-free CLI counts. No content is collected. Disable both in Settings → Capability Center or with loopx usage-ping disable / LOOPX_USAGE_PING=0; inspect payloads with loopx usage-ping status. See Basic usage statistics.

Evidence

LHTB: Higher Mean Reward With the Same Model

LoopX 1.0.3 Heartbeat reaches 0.4948 mean reward across 46 matched tasks: +17.3% over Plain Codex and +10.6% over native Codex Goal. All three use GPT-5.6 Sol, max reasoning effort, and disabled Web Search. Long-Horizon Terminal-Bench goes beyond coding: these tasks span research reproduction, scientific simulation, multimodal analysis, professional workflows, games, and systems work.

Execution mode Mean reward ↑ Strict pass rate (≥0.95) Pass rate (≥0.80)
Plain Codex 0.4218 7/46 (15.2%) 12/46 (26.1%)
Native Codex Goal 0.4475 4/46 (8.7%) 14/46 (30.4%)
LoopX 1.0.3 Heartbeat 0.4948 7/46 (15.2%) 15/46 (32.6%)

The ≥0.80 threshold is a supplementary, post-hoc view; ≥0.95 remains the benchmark's strict solved threshold. No score in this study equals 0.80, so these counts also match the study brief's >0.80 view.

Against native Goal, task-level rewards improve on 23, tie on 13, and regress on 10 tasks. Strict solves match Plain Codex, so the mean gain is not a claim that every task improves or that more tasks are fully solved than Plain. Mean reward also credits partial progress.

One effective trial per task and mode; designated replacement trials and unequal runtime/budgets, including longer budgets for some Heartbeat replacements. These are observed system results, not an equal-budget efficiency result or an isolated causal estimate of LoopX's effect.

Interactive results, task comparisons and methodology · Five-arm study and limits · Public task-level scores

Beyond benchmarks, LoopX also has inspectable long-running project evidence. The public OpenViking contribution sequence spans 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 the visual to inspect the public-safe task graph, evidence branches, and cross-turn decisions; the case states its source and reproducibility boundary.

Open-Source Issue Fix

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

Open-source issue-fix trajectory linking focused PR delivery with reusable LoopX capabilities
Contribution sources and evidence boundary

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.

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.
  • Independent user · vLLM optimization merged upstream. Zheng Cai reports using LoopX as the workflow engine for profiling, research, experiments, and correctness checks. vLLM PR #54951 merged a sparse-indexer optimization; its reported 32.59% total-token throughput gain is for GLM-5.3-Flash at 1M input tokens, 4×H200, TP4, C1. Inspect the workflow, full conditions, and evidence boundary.

These are four featured independent-user 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: The results above lead into five execution mechanisms, task-level comparisons, regressions, and exploratory task-type analysis.
  • 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.

More inspectable surfaces:

Capabilities

Start with the outcome you need. Optional capabilities reuse the same Goal, work ownership and evidence; check their support and permission boundaries.

Product Capability Paths

Capabilities turn those generic primitives into outcome-owned work lanes. Start from the outcome, then inspect the current registered implementation and its write boundary:

You need to... Capability Start with
Turn a public issue into a reviewable, evidence-backed change Issue Fix loopx capability show issue-fix --format json
Qualify the exact final diff before delivery Change Quality loopx capability show change-quality-qualification --format json
Notice busy-but-off-goal work rounds before the periodic review Progress-Review Sentinel loopx capability show progress-review-sentinel --format json
Preserve a changing stack of already reviewed branches Integration Branch loopx capability show integration-branch-reconcile --format json
Explore uncertain research without losing hypotheses and findings Explore loopx capability show explore --format json
Rebase decisions on current evidence and verified outcomes Decision Context loopx capability show decision-context --format json
Produce scheduled or progress-triggered reports with receipts Periodic Report loopx capability show periodic-report --format json

Run loopx capability list --format json for the authoritative catalog in the installed release. A capability detail reports its user value, maturity, provider readiness, entry commands, write boundaries, protocols, and durable validation. Browse the human-readable capability index to choose by outcome; use Extensions and Capabilities when installing or building a provider.

Core Control-Plane Promises

The Kernel folds its mechanics into five questions. Each question delivers one product promise on top of any agent harness: objective → long-horizon state; next → semantic decisions; human judgment → human-agent collaboration; evidence → recovery; continuation → governance.

Question What LoopX keeps visible
What is the objective? The active goal, explicit scope, and current authority.
What happens next? Ordered user and agent todos, ownership, claims, and leases.
What needs human judgment? Concrete user gates instead of a vague "waiting for owner."
What evidence changed? Compact run history, validation, blockers, and accepted writeback.
May the loop continue? Quota, capabilities, safe fallback, scheduler hints, and stop conditions.
Architecture, control-plane surfaces and runtime responsibilities

LoopX keeps the architecture explicit so the same governed outcome can survive a change of agent harness or external provider. The terms describe different boundaries rather than interchangeable kinds of plugin:

Boundary Meaning Go deeper
Kernel Owns durable goal, todo, gate, evidence, quota, recovery, and scheduling truth. Architecture
Capability Defines a stable, provider-neutral contract for producing one bounded, verifiable caller outcome from LoopX state. Capability catalog
Provider Calls an external system or local implementation and returns bounded observations, effect results, and readback. Provider responsibilities
Extension Packages and operates an optional provider through explicit install, readiness, enable, upgrade, disable, and rollback lifecycle. Extension lifecycle

Host declarations such as --available-capability shell describe observed execution support. They are runtime capacities in this product map, not product capabilities and not permission grants. The effective capability still applies its own policy and authority checks before proposing a transition.

Control-Plane Surface

Surface What it does Start with
Goal state and status Tracks active state, todos, claims, gates, evidence, run history, and first-screen attention. loopx status, loopx diagnose, loopx review-packet
Quota and interaction contract Decides whether a turn should deliver, ask, wait, self-repair, or stay quiet. loopx quota should-run, quota allocation
Agent runtime bridges Keeps Codex App, Codex CLI, Claude Code, and generic workers aligned with the same guard. loopx heartbeat-prompt, loopx codex-cli-bootstrap-message, loopx worker-bridge
Operator surfaces Renders compact status without making the browser the state authority. loopx serve-status, dashboard
Session dash Starts a live single-page panel that tracks fleet progress: sessions, their goals, and each goal's status/todo progress, with result statistics; auto-refreshes in place. loopx dash, session dash design
External projections Projects todos and gates into collaboration surfaces while LoopX remains authoritative. loopx lark-kanban, Lark Kanban adapter
Domain capabilities Packages repeatable work lanes such as issue fixing, content operations, value connector planning, ML experiment advice, benchmark evidence, and Explore. loopx issue-fix, loopx content-ops, loopx value-connectors, loopx ml-experiment, loopx benchmark, Explore
Experimental context learning Lets named registered agents trial provider-neutral Reward Memory through ignored, default-off project configuration. OpenViking is one provider option, not a global dependency. loopx reward-memory experiment-status, Reward Memory architecture
Governance patterns Captures reusable routing, gate, evidence, projection, and planning shapes. interaction patterns, state model

The shipped primitives include lifetime goals, concrete user gates, audited safe fallbacks, peer todo ownership, quota and steering, compact run history, evidence-backed handoff, a read-first management surface, project-level value signals, and public/private boundary checks.

Runtime Responsibilities

Role Responsibility
Agent Plans, analyzes, uses tools, and performs one bounded action through a host/runtime.
Provider Calls external systems and returns observations, effect results, and readback.
Capability Defines the caller outcome, normalizes provider output, validates it, and proposes a typed transition.
Kernel Owns durable todos, gates, monitors, accepted writeback, quota, recovery, and scheduling.

The execution path is Agent -> Capability -> Provider; the control path returns Provider readback -> Capability transition -> Kernel. An extension is how an optional provider is packaged and managed, not another control-plane owner. See Architecture and Extensions and Capabilities.

Personal agents, teams and self-improving workflows

Personal Agents, Teams, and Self-Improving Workflows

Meta Muse, Grok Bot, and Anthropic's Building always-on agents make persistent personal agents and sleep/wake event-driven runs a familiar product and architecture model. LoopX approaches that space as an open, provider-neutral 24/7 control plane for agents you already run—not as a hosted replacement for either product.

  • Personal agent: use the shipped Workspace and connected Lark surfaces to inspect goals, steer work and resolve decisions. The persistent steward and semantic handoff RFC extends this toward one capable front door for a team; the complete journey remains under qualification.
  • Agent team: share goals without erasing worker ownership. Claims, evidence and explicit returns keep implementation and review connected. See the three-agent collaboration demo for a bounded example, including corrections and two review rounds.
  • Self-improving workflows: connect feedback to the next attempt through Reward Memory, and evaluate candidate changes through Explore. Both are optional. The link to recursive self-improvement (RSI) is the engineering loop—propose, test, review, retain—not a claim that LoopX has demonstrated autonomous model improvement or compounding capability gains.

A personal steward is an interaction role, not a second source of authority. Background execution still needs an available host and configured runtime. The overall roadmap separates shipped foundations from the next end-to-end acceptance milestones.

2.0 background and migration
A shared control plane A long-horizon research workbench
TypeScript owns the migrated transactions, authority and recovery rules. Python retains real host/provider IO and specialized computation. Follow a research question through delegated work, Explore history, artifacts, trajectory analysis and the next decision.
Two months of engineering, source history and core statistics Watch the 86-second film · Read the analysis contract

Upgrading from 1.x? 2.0 retires ordinary writes to unpromoted Markdown Goals. Review the migration and recovery guide before continuing those Goals. Installation does not silently convert existing state.

Advanced Paths

The first useful loop does not require every optional surface. Add these only when the work needs them.

Inspect the current goal's read-only capability catalog before enabling an advanced path:

loopx configure-goal --goal-id <goal-id>

Without --execute, this reports current/default state, fit, boundaries, and copyable commands without changing project state.

Recurring Work Presets

Safe presets cover daily triage, changelog drafts, and PR watching. Start with the beginner preset guide.

loopx preset list
loopx preset show daily-triage

Preset inspection is read-only. For a connected recurring goal, loopx ready-score --goal-id <goal-id> --agent-id <agent-id> reports whether the loop is ready to run repeatedly.

Governed Turns

LoopX can generate one pure, bounded turn decision from a validated receipt, fresh quota state, and a provider-neutral budget. The current Codex CLI quickstart and activation contract are documented in LoopX Turn for Codex CLI.

Explore Graph and Harness

Explore is supported, optional, and default-off. It works best when a task has a measurable offline evaluation, baseline, treatment, and guardrails; it is not a substitute for production approval. Start with the Explore capability and its Lark presentation mapping.

Review Agent Work

Use loopx review-packet for a compact owner-facing view of decisions, evidence, validation, and unresolved gates. The intelligent management surface describes the operator model; the project-level reward model describes conservative value signals across output quantity, quality, token cost, and user attention cost.

For a concrete peer workflow, start with the Agent collaboration guide: a builder consumes an analyst's artifact, obtains independent review, handles an owner correction and returns the checked result. The guide distinguishes the runnable same-host example from the earlier cross-runtime design sketch.

App and Projection Paths

Optional projections make state easier to inspect; they do not become the source of truth.

Operating and Recovery

Start daily inspection with:

loopx status
loopx history --goal-id your-project-goal
loopx quota should-run --goal-id your-project-goal

Automatic turns must check quota first and append spend only after validated writeback. Quiet skips, preflight failures, and dry-run previews do not spend. When a user gate blocks one lane, a separately audited safe fallback may continue, but it must not bypass the gate.

Peer agents use loopx todo claim before delivery and loopx todo update after validation so ownership and evidence remain visible.

Scheduler cadence follows quota should-run.scheduler_hint; installed Codex App automations acknowledge the current hint through the returned ack_hint.cli_args. Collision recovery, monitor semantics, self-repair, and the exact operator commands are maintained in Getting Started, Quota Allocation, and Long-Task Cadence Policy.

Before publishing public docs or examples:

loopx check \
  --scan-path README.md \
  --scan-path docs/ \
  --scan-path examples/

Current Technical Directions

LoopX has three active strategic programs plus an architecture and research incubator. These are direction signals, not delivery promises; main, released artifacts, and stable reference contracts remain the source of shipped truth.

  • Long-Horizon Benchmarks and Evidence: reproducible capability evidence and controlled mechanism research across complementary benchmark environments. Direction tracker
  • Operator Surface and IM Integration: an operator workspace, session records, and bounded collaboration surfaces. The Personal Workspace is shipped; unified steward, execution, and recovery journeys remain under qualification, with @maxliux5 as implementation lead. Direction tracker
  • Shared Goal Authority and Cross-host Coordination: provider-neutral coordination for explicitly shared goals, with NoKV as an unpromoted provider candidate rather than a new control-plane authority. Direction tracker
  • Architecture and Research Incubator: Effect Program hardening, TypeScript parity migration, hierarchical stride, research exploration, human attention, artifact lifecycle, and memory utility work at explicitly different maturity levels. Direction tracker

Read the canonical Technical Directions map for stages, promotion gates, contributor-safe cuts, and ownership boundaries. Use the pinned GitHub Discussion for community discussion. Core control-plane reliability continues as the shared foundation beneath these programs.

Advanced Documentation

Product website · Blog · Developer Book

Start with the path that matches your current task. Use the hosted documentation portal for the published docs site; the documentation index remains the complete source map. This list stays selective; each category index owns its deeper documents and versioned protocols.

Use and Operate

Understand the Control Plane

Integrate and Extend

Build and Review LoopX

Inspect Outcomes

Project and Community

Partner Projects

LoopX welcomes collaboration with other open-source projects to build the long-running agent ecosystem. Our confirmed partners include:

  • OpenViking - Self-evolving context database for AI agents
  • NoKV - AI native distributed file system

Current Status

LoopX is a usable local control plane for long-running agent work and is entering broader adoption. It is not a full agent platform, an agent runtime, or an autonomous production controller.

Today LoopX ships a durable state kernel for goals, typed todos and decision scopes, peer claims and leases, evidence and writeback, quota-aware scheduling, and cross-turn continuation. Guided start, recurring heartbeat, isolated Codex CLI turns, evidence-backed Issue-Fix admission, optional Explore and auto research paths, public validation canaries, and the multi-project Personal Workspace all build on that shared control state.

Support levels remain explicit. The state and CLI contracts are the stable center; several host integrations and advanced paths are optional, default-off, or experimental. LoopX does not grant credentials, approve destructive or production actions, publish on a user's behalf without authorization, or turn an unverified run into evidence of success.

Current investment is organized through the Technical Directions map: long-horizon benchmark evidence, operator surface and IM integration, shared-goal cross-host coordination, and an explicitly staged architecture and research incubator.

Community & Contributing

Help shape how long-horizon Agent teams work. Share a workflow, reproduce a bug, build an integration, or show what your Agents accomplished. Code, documentation, examples, reviews and carefully bounded evidence studies are all welcome.

See Support for channel routing and official sources, and our Code of Conduct for community participation.

Before sharing code, logs or examples

Keep .loopx/, legacy .codex/goals/, live ACTIVE_GOAL_STATE.md, raw Agent sessions and benchmark traces, credentials, private logs, internal links, sensitive user/team data and operator artifacts out of public contributions.

Contributors

Thank you to everyone contributing code, documentation, bug reports, reviews and real-world feedback. You help make long-horizon Agent work easier to run, inspect and trust.

LoopX GitHub contributors

All GitHub contributors · Authors and contribution records · Governance · Project history · Name and marks.

Community chats

LoopX Lark developer group QR code LoopX WeChat contact QR code

Lark: scan to join directly
WeChat: huangrt00 · mention LoopX in the friend request

Star History

LoopX GitHub star history from verified snapshots

Recent activity

commits and pull requests

Releases and announcements

663 total
  1. Qualified main runtime fef679d1819231fdd15be9bfd7d9858f691758bcruntime-main-fef679d1819231fdd15be9bfd7d9858f691758bcNov 15, 2026pre-release9 downloads

    Immutable runtime snapshot. Stable users continue with PyPI or the stable runtime.

  2. Qualified main runtime eaff94c7449c2fa3ce49edf3adc7e6258ccd8b0cruntime-main-eaff94c7449c2fa3ce49edf3adc7e6258ccd8b0cNov 15, 2026pre-release8 downloads

    Immutable runtime snapshot. Stable users continue with PyPI or the stable runtime.

  3. Qualified main runtime cbdc7655482e3db8cc70c5b0c4e49451d902a360runtime-main-cbdc7655482e3db8cc70c5b0c4e49451d902a360Nov 15, 2026pre-release8 downloads

    Immutable runtime snapshot. Stable users continue with PyPI or the stable runtime.

  4. Qualified main runtime c5ff8fdc32b6a6b806cf91f4c0154d912a381e8eruntime-main-c5ff8fdc32b6a6b806cf91f4c0154d912a381e8eNov 15, 2026pre-release7 downloads

    Immutable runtime snapshot. Stable users continue with PyPI or the stable runtime.

  5. Qualified main runtime b46a76d2d64b3c14877bdf288953c56ae1c7793bruntime-main-b46a76d2d64b3c14877bdf288953c56ae1c7793bNov 15, 2026pre-release10 downloads

    Immutable runtime snapshot. Stable users continue with PyPI or the stable runtime.

Code frequency

additions and deletions
+424.5K-424.5KWeek of 2026-05-31: +64,145 linesWeek of 2026-05-31: -11,050 linesWeek of 2026-06-07: +56,393 linesWeek of 2026-06-07: -990 linesWeek of 2026-06-14: +159,315 linesWeek of 2026-06-14: -40,616 linesWeek of 2026-06-21: +264,863 linesWeek of 2026-06-21: -136,314 linesWeek of 2026-06-28: +181,120 linesWeek of 2026-06-28: -80,398 linesWeek of 2026-07-05: +147,787 linesWeek of 2026-07-05: -63,780 linesWeek of 2026-07-12: +147,801 linesWeek of 2026-07-12: -23,203 linesWeek of 2026-07-19: +82,377 linesWeek of 2026-07-19: -27,698 linesWeek of 2026-07-26: +67,728 linesWeek of 2026-07-26: -14,425 linesWeek of 2026-08-02: +93,421 linesWeek of 2026-08-02: -34,870 linesWeek of 2026-08-09: +123,246 linesWeek of 2026-08-09: -22,995 linesWeek of 2026-08-16: +424,509 linesWeek of 2026-08-16: -289,085 linesWeek of 2026-08-23: +133,080 linesWeek of 2026-08-23: -42,053 linesWeek of 2026-08-30: +104,100 linesWeek of 2026-08-30: -15,353 linesMay 31, 2026Aug 30, 2026
+2M lines added, -802.8K removed over the last year.

Commits per week

last 52 weeks
14310Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 0 commitsWeek of 2026-03-29: 0 commitsWeek of 2026-04-05: 0 commitsWeek of 2026-04-12: 0 commitsWeek of 2026-04-19: 0 commitsWeek of 2026-04-26: 0 commitsWeek of 2026-05-03: 0 commitsWeek of 2026-05-10: 0 commitsWeek of 2026-05-17: 0 commitsWeek of 2026-05-24: 0 commitsWeek of 2026-05-31: 284 commitsWeek of 2026-06-07: 187 commitsWeek of 2026-06-14: 347 commitsWeek of 2026-06-21: 650 commitsWeek of 2026-06-28: 716 commitsWeek of 2026-07-05: 647 commitsWeek of 2026-07-12: 514 commitsWeek of 2026-07-19: 307 commitsWeek of 2026-07-26: 210 commitsWeek of 2026-08-02: 241 commitsWeek of 2026-08-09: 338 commitsWeek of 2026-08-16: 276 commitsWeek of 2026-08-23: 346 commitsWeek of 2026-08-30: 348 commitsWeek of 2026-09-06: 575 commitsWeek of 2026-09-13: 926 commitsWeek of 2026-09-20: 1108 commitsWeek of 2026-09-27: 878 commitsWeek of 2026-10-04: 1402 commitsWeek of 2026-10-11: 1431 commitsWeek of 2026-10-18: 1034 commitsWeek of 2026-10-25: 929 commitsWeek of 2026-11-01: 1151 commitsWeek of 2026-11-08: 1030 commitsWeek of 2026-11-15: 48 commitsNov 23, 2025Nov 15, 2026
15.9K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 116 commitsSun 1:00 — 102 commitsSun 2:00 — 153 commitsSun 3:00 — 120 commitsSun 4:00 — 74 commitsSun 5:00 — 75 commitsSun 6:00 — 47 commitsSun 7:00 — 57 commitsSun 8:00 — 54 commitsSun 9:00 — 46 commitsSun 10:00 — 62 commitsSun 11:00 — 72 commitsSun 12:00 — 66 commitsSun 13:00 — 107 commitsSun 14:00 — 88 commitsSun 15:00 — 88 commitsSun 16:00 — 98 commitsSun 17:00 — 88 commitsSun 18:00 — 117 commitsSun 19:00 — 91 commitsSun 20:00 — 92 commitsSun 21:00 — 88 commitsSun 22:00 — 47 commitsSun 23:00 — 98 commitsMon 0:00 — 88 commitsMon 1:00 — 99 commitsMon 2:00 — 112 commitsMon 3:00 — 66 commitsMon 4:00 — 53 commitsMon 5:00 — 45 commitsMon 6:00 — 35 commitsMon 7:00 — 44 commitsMon 8:00 — 32 commitsMon 9:00 — 37 commitsMon 10:00 — 33 commitsMon 11:00 — 88 commitsMon 12:00 — 80 commitsMon 13:00 — 74 commitsMon 14:00 — 64 commitsMon 15:00 — 72 commitsMon 16:00 — 66 commitsMon 17:00 — 82 commitsMon 18:00 — 68 commitsMon 19:00 — 88 commitsMon 20:00 — 87 commitsMon 21:00 — 61 commitsMon 22:00 — 47 commitsMon 23:00 — 71 commitsTue 0:00 — 110 commitsTue 1:00 — 139 commitsTue 2:00 — 98 commitsTue 3:00 — 57 commitsTue 4:00 — 46 commitsTue 5:00 — 54 commitsTue 6:00 — 52 commitsTue 7:00 — 43 commitsTue 8:00 — 28 commitsTue 9:00 — 49 commitsTue 10:00 — 49 commitsTue 11:00 — 61 commitsTue 12:00 — 109 commitsTue 13:00 — 98 commitsTue 14:00 — 61 commitsTue 15:00 — 91 commitsTue 16:00 — 93 commitsTue 17:00 — 106 commitsTue 18:00 — 91 commitsTue 19:00 — 94 commitsTue 20:00 — 82 commitsTue 21:00 — 65 commitsTue 22:00 — 64 commitsTue 23:00 — 75 commitsWed 0:00 — 92 commitsWed 1:00 — 91 commitsWed 2:00 — 76 commitsWed 3:00 — 60 commitsWed 4:00 — 44 commitsWed 5:00 — 51 commitsWed 6:00 — 41 commitsWed 7:00 — 46 commitsWed 8:00 — 36 commitsWed 9:00 — 40 commitsWed 10:00 — 59 commitsWed 11:00 — 74 commitsWed 12:00 — 109 commitsWed 13:00 — 86 commitsWed 14:00 — 51 commitsWed 15:00 — 76 commitsWed 16:00 — 82 commitsWed 17:00 — 109 commitsWed 18:00 — 104 commitsWed 19:00 — 79 commitsWed 20:00 — 87 commitsWed 21:00 — 69 commitsWed 22:00 — 53 commitsWed 23:00 — 75 commitsThu 0:00 — 123 commitsThu 1:00 — 115 commitsThu 2:00 — 86 commitsThu 3:00 — 51 commitsThu 4:00 — 39 commitsThu 5:00 — 48 commitsThu 6:00 — 56 commitsThu 7:00 — 47 commitsThu 8:00 — 42 commitsThu 9:00 — 49 commitsThu 10:00 — 60 commitsThu 11:00 — 94 commitsThu 12:00 — 107 commitsThu 13:00 — 62 commitsThu 14:00 — 71 commitsThu 15:00 — 73 commitsThu 16:00 — 84 commitsThu 17:00 — 90 commitsThu 18:00 — 76 commitsThu 19:00 — 67 commitsThu 20:00 — 87 commitsThu 21:00 — 75 commitsThu 22:00 — 83 commitsThu 23:00 — 113 commitsFri 0:00 — 89 commitsFri 1:00 — 96 commitsFri 2:00 — 67 commitsFri 3:00 — 29 commitsFri 4:00 — 30 commitsFri 5:00 — 36 commitsFri 6:00 — 21 commitsFri 7:00 — 28 commitsFri 8:00 — 24 commitsFri 9:00 — 39 commitsFri 10:00 — 42 commitsFri 11:00 — 71 commitsFri 12:00 — 98 commitsFri 13:00 — 77 commitsFri 14:00 — 67 commitsFri 15:00 — 67 commitsFri 16:00 — 85 commitsFri 17:00 — 66 commitsFri 18:00 — 60 commitsFri 19:00 — 59 commitsFri 20:00 — 77 commitsFri 21:00 — 62 commitsFri 22:00 — 77 commitsFri 23:00 — 70 commitsSat 0:00 — 108 commitsSat 1:00 — 96 commitsSat 2:00 — 81 commitsSat 3:00 — 53 commitsSat 4:00 — 43 commitsSat 5:00 — 44 commitsSat 6:00 — 47 commitsSat 7:00 — 30 commitsSat 8:00 — 34 commitsSat 9:00 — 41 commitsSat 10:00 — 63 commitsSat 11:00 — 67 commitsSat 12:00 — 80 commitsSat 13:00 — 72 commitsSat 14:00 — 90 commitsSat 15:00 — 113 commitsSat 16:00 — 69 commitsSat 17:00 — 100 commitsSat 18:00 — 78 commitsSat 19:00 — 109 commitsSat 20:00 — 106 commitsSat 21:00 — 99 commitsSat 22:00 — 95 commitsSat 23:00 — 103 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Sep 4, 2026monthly#16+5,297
Sep 3, 2026monthly#16+5,297
Sep 2, 2026monthly#7+5,248
Sep 1, 2026monthly#7+5,239
Aug 16, 2026weekly#10+1,455
Aug 15, 2026weekly#10+1,455
Aug 14, 2026weekly#5+1,967
Aug 13, 2026weekly#3+2,509
Aug 12, 2026weekly#2+2,687
Aug 11, 2026weekly#1+2,947
Aug 8, 2026daily#4+847
Aug 7, 2026daily#4+847
Aug 6, 2026daily#2+326
  • public-apis/public-apis

    A collective list of free APIs

    500.5K stars · Python

  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • donnemartin/system-design-primer

    Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

    378.7K stars · Python

  • affaan-m/ECC

    The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

    307.9K stars · JavaScript

  • practical-tutorials/project-based-learning

    Curated list of project-based tutorials

    290.1K stars · Python

  • NousResearch/hermes-agent

    The agent that grows with you

    265K stars · Python