awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
loopx-project avatar

loopx-project/loopx

0
View on GitHub↗
loopx-project.github.io/loopx↗

Loopx

LoopX is a local-first control plane for long-running coding agents. It keeps goals, todos, claims, gates, quota and evidence in durable state outside any chat session, so work carries on across restarts, changes of owner and swaps of agent runtime. Agents are woken on a recurring heartbeat, and each turn is gated by quota and authority before one bounded segment of work runs. A completion claim is accepted only after an independent validator checks the real outcome.

What sets it apart is how it handles trust and ownership. An agent's own "done" is treated as unverified evidence, and results are committed only after validation, with receipts that let a crashed turn resume from the first uncommitted step. Peer agents share one goal through claims, time-limited leases and explicit handoffs, and stale executors are fenced out. Stalled routes trigger replanning obligations. It connects to several agent hosts, including Codex, Claude Code and Kiro CLI, as well as custom runners and generic CLI adapters, and keeps one shared goal lifecycle across them.

Around that core sits a human review layer: a local dashboard and chat workspace where people see agent lanes, review output as scoreable cards, give feedback, and answer scoped decision gates. Status views and kanban boards are read-only projections of canonical state. Optional capabilities cover issue-to-pull-request workflows, change-quality review receipts, scheduled reports, research exploration with evidence graphs, and mirroring to boards and chat channels such as Lark. Providers and extensions plug in around the kernel without taking over its authority.

LoopX is written in Python and installs as a command-line tool, with install, health-check and upgrade commands, slash-command skills for supported hosts, and an optional desktop app.

Features

  • Agent Safety and Verified Completion - Treats an agent's self-reported completion as unverified evidence that the control plane must verify and settle before work counts as finished.
  • Peer Claim and Lease Authority - Separates claims, time-bounded leases and lifecycle authority among peer agents so handoffs never imply completion rights.
  • Cross-Session Goal Continuity - Keeps goals, todos, dependencies, acceptance criteria and recovery points in durable local state so work survives across sessions and agent hosts.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
6,560 stars·614 forks·Python·Apache-2.0·1 view
  • Cross-Host Goal Continuity - Connects Codex, Claude Code and other runtimes to one shared goal state so work moves between hosts without losing evidence.
  • Goal and Todo Tracking for Agents - Stores goals, todos, claims, evidence, handoffs and gate decisions in durable local state so work carries over across sessions, hosts and providers.
  • Host-Driven Goal Loops - Turns an external agent session into a governed goal loop where each approved tick runs one bounded segment and returns one typed result.
  • Command-Based Outcome Validation - Runs a user-supplied command to check the real outcome and blocks commit or quota spend when validation fails.
  • Peer Ownership Leases - Lets peer agents share a goal through claims, time-limited leases and handoffs, with epoch fencing so stale executors cannot overwrite current owners.
  • Control Planes Above Execution Hosts - Provides a durable control plane for goals, tasks, replanning, evidence, quotas and continuation above the host that runs agent work.
  • Premature Completion Rejection - Treats an agent's self-reported done as unverified evidence, so work continues until independent verification passes.
  • Project-Owned Agent Control Planes - Keeps goal, work queue, authority, evidence and recovery conditions in a project-owned control plane so agent work survives sessions, owners and external waits.
  • Quota-Gated Agent Ticks - Wakes agents on a recurring heartbeat, gates each turn by quota and authority, runs one bounded segment, then validates, writes back and spends quota.
  • Durable Control-Plane State for Ephemeral Executors - Keeps goals and project intent in durable control-plane state while executor sessions stay ephemeral, so each turn starts clean.
  • Receipt-Based Turn Settlement - Orders each turn as validate, writeback, quota spend and close-out with identity-bound receipts so crashes resume without duplicate retries.
  • Native Goal Lifecycles - Claims a bounded task from the work queue and drives an agent runtime through a strict goal-and-verify lifecycle with verified writeback of results and quota.
  • Verified Single-Turn Execution - Runs one bounded coding task through an agent CLI, then has an independent validator check the postcondition before commit and a single spend.
  • Agent Run Resumption - Keeps a local journal of binding identity, native ids and writeback receipts so a rerun resumes the same thread without repeating completed steps.
  • Agent Task Ownership Transfers - Moves task ownership to another agent using handoff notes and typed transfer grants, keeping consultation and delegation separate from ownership adoption.
  • Agent Todo Claims and Handoffs - Lets registered peer agents claim individual todos, work within declared write scopes and write back evidence, with any temporary coordinator holding no standing authority.
  • Agent Value Scoring - Rates agent value by combining output quantity, review-based quality, token cost and user attention cost into reviewable ratings.
  • Agent Wake Cadence Scheduling - Manages wake cadence, due times and backoff, and confirms the host applied the proposed timer before re-reading state on each heartbeat.
  • Agent Work Review Feeds - Presents agent output as ranked scoreable cards with evidence, cost and next step, surfacing gates and evidence gaps before routine activity.
  • Semantic Context Handoffs - Passes work to another agent with purpose, decisions, constraints, evidence, commitments and expected return so the receiver continues instead of restarting.
  • Continuation Controls - Decides when authorized agent work may continue by applying heartbeat checks, scheduling, quota limits and explicit stop or wait conditions.
  • Cross-Runtime Agent Runs - Keeps goals, constraints and acceptance evidence consistent while models and execution runtimes change between runs.
  • Cross-Runtime Work Handoff - Carries goal state and evidence between agent sessions on different hosts so work continues without losing context or ownership.
  • Custom Runner Control Ticks - Exposes a small tick of commands that lets any shell or scheduler check whether to run, claim work, record progress and account for verified slices.
  • Drift-Triggered Replanning - Raises a mandatory replan obligation after repeated consecutive drift receipts, forcing stalled agents to change course.
  • Evidence-Tracked Agent Work - Tracks long-running agent tasks together with the evidence they produce so progress persists across sessions and runtimes and can be verified.
  • Goal and Task Workspaces - Presents goal direction, acceptance conditions, the work map and owner decisions in one workspace view, keeping task progress separate from goal acceptance.
  • Heartbeat Prompt Loaders - Generates a short visible goal line plus a bootstrap loader that binds a goal and agent and fetches the current execution contract on every wake.
  • Scoped Decision Gates - Blocks only the lanes, tasks or decisions awaiting approval while independent eligible work keeps running.
  • Concrete Gate Questions - Marks tasks needing a human decision as user-gate cards with a concrete question so agents stop and wait instead of guessing.
  • Run Reward Overlays - Appends operator judgments, reasons and correction lessons to exact runs as overlays that later surface in status and warn on contradicting actions.
  • Journal-Based Turn Recovery - Resumes interrupted agent turns by loading the original journaled plan and receipts so recovery restarts from the first uncommitted step.
  • Long-Run Goal Alignment - Preserves original intent and stable acceptance criteria across replanning and handoff so long agent runs stay aligned with their declared goal.
  • Peer Agent Task Coordination - Coordinates tasks across peer agents and passes work between them while the control plane remains the single source of truth.
  • Per-Turn Decision Packets - Projects canonical state into a compact versioned packet of identity, allowed actions, gates and writeback commands, regenerated each turn instead of replaying history.
  • Planned Long-Running Agent Work - Takes a concrete goal, plans first, writes ordered todos, and advances one bounded, validated slice at a time toward the result.
  • Provider-Neutral Goal Stores - Keeps goal authority behind interchangeable file, SQLite or PostgreSQL stores so run history, status, quota and scheduling stay consistent across machines.
  • Replan Obligation Discharge - Clears a replan obligation only when the next state refresh carries new evidence, a hypothesis, a concrete blocker, or an evidence-linked vision path.
  • Safe Long-Running Todo Execution - Drives long-horizon work as compact transitions: check the guard, pick one lane, validate, write durable state, spend once and refresh status.
  • Append-Only Event Ledgers - Records accounting, decision, evidence and work events in an append-only ledger so status is a replayable projection and past decisions stay auditable.
  • Shared Todo Ownership Contracts - Defines a shared todo contract covering work items, owners, approval gates and how tasks continue between agent sessions.
  • Stalled Route Replanning - Detects when the current approach can no longer satisfy the goal and triggers a new plan instead of repeating failing local attempts.
  • Structured Human Feedback on Agent Work - Captures one-tap human judgments such as useful, wrong direction, or risky on agent output, turning periodic reviews into a continuous feedback signal.
  • Transactional Turn Settlement - Validates the turn journal, authorizes external providers, checkpoints outcomes and reduces everything into one typed result so replays finish with a single call.
  • Turn Outcome Signals - Returns a compact typed turn result telling callers whether to commit, repair, replan, wait, or ask the user next.
  • Typed Control-Plane Tool Servers - Registers a tool server in the host's settings so sessions can check quota, claim and complete tasks, and review results through typed calls.
  • Typed Worker Turn Exchange - Exchanges structured turn envelopes and results with external workers, adding preview, durable commit, replay and recovery for programmatic hosts.
  • Peer Agent Handoff Contracts - Lets manager-to-worker and worker-to-worker agents request help, exchange accepted artifacts, challenge dependencies and propose replanning through one shared contract.
  • Agent Task Board Mirrors - Mirrors todos and decisions onto external collaboration surfaces such as a chat-based kanban while the local control plane remains authoritative.
  • Human and Agent Todo Assignment - Creates, lists and updates todos assigned to people or agents, keeping task ownership in durable state outside any chat.
  • Shared Human-Agent Workspaces - Brings people into agent work through a personal workspace and chat channels so they can steer, correct and review agents.
  • External State Stores - Persists goals, todos, claims, gates, quota and evidence in a local registry outside any chat session so work survives restarts and runtime swaps.
  • Agent Host Adapters - Provides thin per-host adapters connecting agent turns to Codex, Claude Code, Kiro CLI and custom runners so one team coordinates across runtimes.
  • Recurring Wake Prompts - Defines a recurring wake prompt contract so long-running goals resume across sessions without a person restarting them.
  • Per-Goal Agent Compute Quotas - Assigns each goal an automatic-compute allowance with a spend ledger and allocation states that automations check before running.
  • Agentic Session Persistence - Keeps goals and project state in durable storage outside the agent session so each new turn starts clean but retains original intent.
  • Atomic Lease Claims - Commits the task claim, execution lease and operation receipt together in one conditional transaction, so no half-claimed state exists between agents.
  • Host-Native Loop Launching - Starts long-running tasks from an existing agent session, plans them into todos, and activates the host's native continuation mechanism.
  • Kernel-Preserving Extension Layers - Separates capabilities, providers and extensions with their own lifecycles so optional integrations are added without changing the kernel's authority and acceptance rules.
  • Outcome-Owned Capability Lanes - Packages repeatable workflows such as issue fixing, change-quality review and periodic reporting into outcome-owned lanes with declared write boundaries and readiness checks.
  • Replaceable Integration Providers - Connects Git hosts, CI services and notifiers through replaceable providers behind stable capability contracts, shipped as independently installable extensions.
  • Issue-to-Merge Fix Loops - Drives an issue through fix, monitoring, review correction, user gate and terminal states, gating each step on checks, review and merge state.
  • Local Write Fencing - Uses per-todo leases, idempotency keys and revision checks so concurrent writers, duplicate heartbeats and stale updates fail closed, with a CLI fallback when the coordinator is down.
  • Validate-Then-Commit State Transitions - Treats provider observations as proposals until validated and committed by the kernel, keeping domain reasoning, external calls and durable lifecycle separate.

    • Star history

    Star history chart for loopx-project/loopxStar history chart for loopx-project/loopx

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does loopx-project/loopx do?

    LoopX is a local-first control plane for long-running coding agents. It keeps goals, todos, claims, gates, quota and evidence in durable state outside any chat session, so work carries on across restarts, changes of owner and swaps of agent runtime. Agents are woken on a recurring heartbeat, and each turn is gated by quota and authority before one bounded segment of work runs. A completion claim is accepted only after an independent validator checks the real outcome.

    What are the main features of loopx-project/loopx?

    The main features of loopx-project/loopx are: Agent Safety and Verified Completion, Peer Claim and Lease Authority, Cross-Session Goal Continuity, Cross-Host Goal Continuity, Goal and Todo Tracking for Agents, Host-Driven Goal Loops, Command-Based Outcome Validation, Peer Ownership Leases.

    Which projects share features with loopx-project/loopx?

    Projects with overlapping indexed features include: totec448-spec/chat-on-steroids — Chat on Steroids is a desktop companion app that connects ChatGPT to the user's own machine through local Model… lintsinghua/claude-code-book — This repository is a long-form technical book about how a production AI coding agent runtime, often called an agent… rlaope/oh-my-hermes — Oh My Hermes (Hermes Orchestrator) is a workflow layer that sits on top of the Hermes agent runtime. It routes… yetone/cumora — Cumora is a cross-platform team chat where AI agents join humans as teammates in shared rooms, direct messages, and… macro-inc/macro — Macro is a unified team workspace that brings email, chat, documents, tasks, calls, and customer records into one… entireio/cli — This project is a Git-based AI session tracker and context manager designed to record AI agent interactions,…

    Projects sharing features with Loopx

    These projects share indexed features with Loopx. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • totec448-spec/chat-on-steroidstotec448-spec avatar

      totec448-spec/chat-on-steroids

      5,144View on GitHub↗

      Chat on Steroids is a desktop companion app that connects ChatGPT to the user's own machine through local Model Context Protocol servers. It lets the chat read, search and patch files in a real project, run tests, keep terminals open, and observe or control the desktop, with a companion Chrome extension that drives real browser tabs in the background without changing the user's selected tab or foreground window. Access is split across separate Core, Desktop and Plugins connections, each authorized independently. What sets it apart is the permission layer around that access. File access is res

      TypeScriptautomationchatgptchrome-extension
      View on GitHub↗5,144
    • lintsinghua/claude-code-booklintsinghua avatar

      lintsinghua/claude-code-book

      4,359View on GitHub↗

      This repository is a long-form technical book about how a production AI coding agent runtime, often called an agent harness, is built. It dissects a real-world coding agent's architecture chapter by chapter and turns it into transferable lessons, and it also works as a step-by-step guide to designing and building your own harness around a language model. Python scripts in the repository support the book itself rather than the agent. The book's core subject is the machinery around the model: a streaming conversation loop that repeats tool calls until the model returns plain text, a tool protoc

      Pythonagentagent-architectureai-agent
      View on GitHub↗4,359
    • rlaope/oh-my-hermesrlaope avatar

      rlaope/oh-my-hermes

      5,229View on GitHub↗

      Oh My Hermes (Hermes Orchestrator) is a workflow layer that sits on top of the Hermes agent runtime. It routes requests to staged skills, external coding executors, and verification gates, through chat or a terminal interface. Completion is evidence-gated: every status carries a stage and confidence, and work is marked verified only after tests, reviews, or CI checks have actually passed. It is also distributed as a catalog of installable workflow skills and plugin hooks, for Hermes and other coding-agent hosts. Its main focus is multi-agent coding delegation. Scoped tasks are handed to codin

      Pythonagentaiai-agent
      View on GitHub↗5,229
    • macro-inc/macromacro-inc avatar

      macro-inc/macro

      6,195View on GitHub↗

      Macro is a unified team workspace that brings email, chat, documents, tasks, calls, and customer records into one place. Items are connected by mentions that create two-way links, so any email, document, task, or contact can be traced back to the conversations and work tied to it. Autonomous AI agents run inside the workspace and draw on a shared team memory that is refreshed each night from email, messages, tasks, documents, and calls. Agents can be started by assigning them work through direct messages, mentions, or routines, or automatically when configured triggers fire. They run in sandb

      Rustagentaiai-agents
      View on GitHub↗6,195
    Compare all 30 related projects→