Open source · MIT · v0.4

Ship whileyou sleep.

OpenLoop turns your AI coding agent into a tireless developer that works across every repo you own: planning tasks, writing code, running validations, and promoting changes on a loop, without babysitting.

Start the loopStar on GitHub
pi · claude code · codex · aider · opencode git-native risk-gated
openloop · daemonlive
$ openloop project add api ~/work/api --init
✓ linked project api → ~/work/api
✓ detected stack: Node · pnpm · vitest · eslint
control plane ready · policy, ledger, specs → .openloop/
$ openloop task add -p api --title "Harden webhook retries" \
--kind bugfix --risk low
✓ task harden-webhook-retries · low risk · ready
$ openloop service start
● daemon running · 3 projects · round-robin
budget $0.00 / $25.00 · timeout 30m · max 3 attempts
$ openloop digest
✓ promoted add-rate-limit-headers api auto-merge
◉ running harden-webhook-retries api validating
○ review migrate-auth-lib web high risk
spend $1.84 · 2 runs · confidence high
How it works

You define the work.
The loop handles the rest.

OpenLoop is one CLI and one daemon. Every linked repository gets its own control plane, task ledger, and safety policy.

01

Link a repository

One command registers a repo by alias and materializes its control plane: task ledger, scope policy, validation config, and agent instructions.

$ openloop project add api ~/work/api --init
02

Enqueue the work

Add tasks from titles or GitHub/GitLab issues. Each carries a kind, a risk class, an optional scope, and acceptance criteria.

$ openloop task add -p api --title "Harden webhook retries"
03

Let the daemon run

A single resident daemon schedules agent runs across every linked project: implement, validate, then promote by risk.

$ openloop service start
Every task, every time
  1. Plan
  2. Implement
  3. Validate
  4. Review
  5. Promote
runs fail → retried up to 3 times · still failing → blocked for review · idle → the loop proposes its own improvements
Capabilities

An orchestration layer,
not another chat window.

OpenLoop doesn't call model APIs; it drives real coding-agent CLIs as subprocesses, wraps them in a scheduler, a ledger, and a promotion pipeline, and keeps them honest.

One daemon, every repo

A single resident service orchestrates your whole fleet. One active worker per project, with round-robin, priority, or focus selection.

openloop statusdaemon ●
api · 2 ready · 1 running ● active
web · 0 ready · idle ○ proposing tasks
cli · 1 in review · 4 done ◉ promotion queue

Any coding agent

Swap agents per project. Cost and usage are parsed from each provider's output.

piclaude codecodexaideropencodecustom

default: pi · per-project override

Self-healing

Lint, type, and localized test failures are triaged into bounded fix tasks automatically. Anything else is blocked from running unattended.

lint-fixtype-fixlocalized-test-fix

Issue sync

GitHub and GitLab issues labeled openloop become tasks. Status comments and PR links are posted back to the issue.

gh: #142 "Rate-limit /login" → task · ready

Hooks, MCP & views

Lifecycle hooks (command or webhook) on every event, an MCP server for your editor's agent, plus a TUI, a live watch view, and a web dashboard.

hooksopenloop mcptuidashboard

Risk-gated promotion

Every run ends in an explicit decision. Validations must be configured and green before anything merges itself.

low risk · lint ✓ test ✓ type ✓auto-merge
medium riskpull request
high risk · scope drift detectedmanual review

Scope policy on real diffs

Declare what agents may touch. Deny globs and high-risk areas are enforced against the actual diff, with secret detection before anything is promoted.

allow: ["src/**", "tests/**"]
deny:  ["infra/**", ".github/**"]
high-risk: ["src/auth/**"]
Autonomy, contained

An unattended agent you can actually trust.

Autonomy without brakes is a liability. OpenLoop ships with runaway protection on by default: budgets, attempts, timeouts, and scope enforcement are not add-ons; they are the architecture.

budget-blocked → hooks fire → daemon self-pauses
$25 / day
spend ceiling; the daemon pauses itself when exhausted
3 attempts
per task, then it is blocked for human review
30 min
hard timeout per agent run, with no-progress detection
0
high-risk changes merged without a human, by design
  • Scope policy is enforced against the real diff: allow/deny globs, high-risk areas, and scope-drift detection downgrade risky promotions automatically.
  • A deterministic post-implementation review checks for scope drift and leaked secrets; blocking findings turn auto-merges into manual review.
  • Auto-merge is refused when a project has no validation commands configured; green checks are a precondition, not a suggestion.
  • Backpressure: a project with three pending promotions is skipped until the queue drains. Stuck tasks recover themselves on daemon start.
Quickstart

From zero to looping in under a minute.

Install, link a repo: the setup wizard detects your stack and configures lint, test, and typecheck commands, then enqueue work and walk away. Prefer a wizard? openloop setup walks through all of it.

  • Stack detection for Node, Python, Go, Rust, Ruby, JVM, and .NET
  • Agent instructions and prompts installed into the repo automatically
  • Works with the agent binary you already have on PATH
sh · first loop
# install from source
$ git clone https://github.com/jaltez/openloop && cd openloop
$ npm install && npm run build && npm link
# link a repository and give the loop some work
$ openloop project add myapp ~/code/myapp --init
$ openloop task add -p myapp --title "Add pagination to /orders"
# start the daemon. you are done
$ openloop service start
daemon running · myapp · task 1 of 1 · budget $0.00 / $25.00

Put your agents on the clock.

Free and open source. Bring your own agents, your own models, and your own repos; OpenLoop keeps the loop running.

Install OpenLoopView source