Loopy — a local-first agent operating system

Loopy is a free, open-source, local-first AI coding tool — an agent operating system for software teams. Put work in a workflow and a governed fleet of agentic AI coding agents watches it, does the work under policy, and produces reviewable evidence — looping until it ships. Runs on your machine with your keys, across 43 coding-agent CLIs (Codex, Claude Code, Cursor, Gemini, Copilot, and more).

Not to be confused with LOOPY (the systems-thinking sketch tool) or Loopy Pro (the audio looper). Loopy = the AI agent operating system at loopy.yachts.

Keywords: agent operating system · agentic coding tool · local-first AI coding tool · free AI coding agent · open-source coding agent · AI agent orchestration · autonomous coding agents

TL;DR

Loopy is a local agent company on your laptop. You give it a product idea — it researches the market, plans the build, writes code with your coding agent, runs tests, syncs GitHub and Linear, and emails you progress updates. It keeps looping until the product is done or you tell it to stop. Everything runs on your machine with your API keys; nothing is uploaded to a hosted sandbox.

It plugs into 43 coding-agent CLIs — Codex, Claude Code, Cursor, Copilot, Gemini, OpenClaw, Freebuff, and dozens more. Run multiple projects in parallel, split each turn across two agents (backend + frontend), or queue builds overnight. Default turn budget supports up to ~9 hours of unattended runtime.

Loopy stays on track with a single source of truth: Linear issues synced every turn, a durable build plan on disk, and Mem0 memory so long sessions don't drift. Nebius routes each turn from live tracker state — not vibes. You can take over anytime by queuing a steering message mid-run; Loopy injects it into the next agent turn. Gmail sends kickoff, per-turn progress, and completion emails so you don't have to watch the dashboard.

Integrations are deep, not decorative: Tavily and Firecrawl for research, Mem0 + SuperCompress for memory, Nebius for planning and routing, Composio for GitHub, Linear, Gmail, and Firecrawl ops. When it's done, you get a Ship Receipt — repo URL, Linear project, email proof, sponsor ledger — copy-paste ready.

Live site: loopy.yachts · Source: github.com/arjunkshah/loopy

---

Quick start

curl -fsSL loopy.yachts/install | bash
loopy serve

The installer adds a loopy command (via pipx, or an isolated env it manages for you) — no repo clone, no source on disk. The UI ships inside the package. If you already have pipx, pipx install git+https://github.com/arjunkshah/loopy.git does the same thing.

Already installed? Update in place — no reinstall:

loopy update

Developing on Loopy? Get the source instead:

git clone https://github.com/arjunkshah/loopy.git && cd loopy
./bootstrap.sh && source .venv/bin/activate && loopy serve

Open http://127.0.0.1:8787 → onboard → describe your idea → Send.

loopy run --idea "CLI that syncs Linear to markdown" --agent codex   # headless + live progress
loopy run --idea "Add OAuth login" --workdir ~/code/my-app           # build in place on an existing repo
loopy run --verbose                                                 # stream agent output
loopy run --demo                                                    # pipeline without live keys
loopy doctor                                                        # verify keys, Composio, agents

---

Run on an existing repo

Loopy isn't greenfield-only — point it at any directory and it builds in place instead of scaffolding from scratch:

loopy run --workdir ~/code/my-app --idea "Add OAuth login and a settings page"
loopy run -C .         --idea "Fix the failing auth tests"   # -C is shorthand for --workdir

In the dashboard, click Choose folder under the prompt and pick the repo (leave it on Default for a fresh build under ~/.loopy).

When the target directory already contains code, Loopy:

• Detects the existing codebase and tells the agent to read it and modify in place — no new scaffold, no overwriting unrelated files.
• Skips template scaffolding so your files are never clobbered (templates only seed empty workdirs).
• Never deletes your repo — Loopy's project cleanup only removes folders it manages under ~/.loopy/projects.

Phrase the idea as a change request ("Add…", "Fix…", "Refactor…"). Loopy creates a safe loopy/<slug> branch, reuses your GitHub remote, and plans surgical edits instead of a greenfield MVP. Commit or branch first so each turn's push/PR has a clean baseline.

---

Launch marketing (Resend + Ayrshare)

When a build completes, Loopy can auto-run a launch campaign:

| Channel | Provider | What it does | |---------|----------|--------------| | Email | Resend | Launch email to your list or segment | | Social + video | Ayrshare | One API call → X, LinkedIn, Instagram, TikTok, YouTube, Threads, Reddit, … |

In Settings → Launch marketing:

1. Enable Marketing on ship
2. Resend — API key + From address + recipients (or segment ID)
3. Ayrshare — API key + platforms (twitter,linkedin,instagram or all)
4. Optional Media URL — HTTPS video/image for Reels/TikTok/YouTube posts

Connect your social accounts once in the Ayrshare dashboard. Gmail (Composio) still handles your build notifications; this handles audience launch.

---

The loop

 Idea ──► Tavily research ──► Firecrawl scrape
              │
              ▼
       Memory recall + SuperCompress
              │
              ▼
    Nebius plan · brand · route (reads Linear each turn)
              │
              ▼
   Coding agent(s) — 43 CLIs, optional parallel split
              │
              ▼
      pytest QA · browser review
              │
              ▼
  Composio: Linear kanban · GitHub · Gmail · Firecrawl
              │
              ▼
         Ship Receipt + proof ledger

---

Integrations

Every partner is wired into the orchestrator — not a logo slide.

| Partner | Role in Loopy | |---------|----------------| | Tavily | Market research and ideation at kickoff | | Firecrawl | Deep spec extraction from competitor URLs (via Composio) | | Memory stack | Pluggable persistent memory — Mem0 or Supermemory (auto-detected) | | SuperCompress | Learned KV eviction — shows token savings % in the dashboard | | Nebius Token Factory | Build plan, brand, and per-turn routing (Llama 3.3 70B) | | Composio | OAuth for GitHub, Linear, Gmail, and Firecrawl | | 43 coding CLIs | Local terminal agents — auth stays on your machine | | Stripe / Qdrant / MotherDuck | Optional SDK scaffolds in the template layer |

---

Choose your memory stack

Already running a memory layer? Keep it. Loopy's persistent memory is pluggable — set it once at install and it carries forward to every run:

| Provider | What it is | How Loopy detects it | |----------|------------|----------------------| | mem0 | Hosted semantic memory | mem0_api_key set | | supermemory | Hosted memory API (api.supermemory.ai) | supermemory_api_key set | | off | No persistent memory (SuperCompress still runs) | — |

// ~/.loopy/config.json
{
  "memory_provider": "auto",        // auto | mem0 | supermemory | off
  "mem0_api_key": "...",            // for mem0
  "supermemory_api_key": "..."      // for supermemory
}

• Offered at first-install onboarding with live detection — the wizard probes your machine (GET /api/memory/status) and tells you which stacks it found, defaulting to auto.
• auto (default) probes your machine and picks the first stack it finds (mem0 → supermemory), so existing users keep their own memory with zero config.
• Pin a specific provider to override auto-detection; off disables persistent recall entirely.
• The MemoryBridge interface is pluggable, so additional backends can be added without touching the orchestrator.
• Every backend fails closed: a memory outage never breaks a build turn.

loopy doctor   # shows your memory setting, the resolved provider, and which stacks are detected

---

Run autonomously for hours

Loopy is built for unattended, overnight builds:

• 200-turn default budget (configurable per project, max 200) — Nebius receives this from turn one and sizes the plan accordingly
• ~9 hours typical at average turn pace (research/setup once, then agent + QA + ops per turn)
• Overnight queue — loopy queue-add <project> + loopy queue-run or loopy schedule --enable
• Concurrent portfolio — run up to 10 projects at once; extras wait in queue
• Agent failover — auto-switches coding CLIs when usage limits hit (Codex ↔ Claude ↔ …)

Kick back. Loopy keeps looping until done or budget exhausted.

---

Auto-branch safety

Point Loopy at one of your existing repos and it won't touch your main. Before the first build turn, Loopy detects an existing git repo with commits and checks out a dedicated working branch — loopy/<slug> (derived from the product/repo slug or idea) — so every commit lands on the safety branch and your current branch stays clean. Review the loop's work, then merge (or open a PR) on your terms.

• Best-effort and safe — if git is missing, the path isn't a repo, or it has no commits, Loopy skips the step silently and never crashes a run.
• Idempotent — re-running on an existing loopy/ branch keeps you there; an existing branch is checked out rather than recreated.
• Opt-out — set auto_branch: false in ~/.loopy/config.json (or via the /api/secrets endpoint) to build on whatever branch is currently checked out.

The chosen branch is emitted on the live timeline (working_branch event) and included in the Ship Receipt.

---

Single source of truth

Agents drift when context is scattered. Loopy keeps one durable thread:

| Layer | What it tracks | |-------|----------------| | Linear issues | Plan issues created at kickoff; statuses synced after every turn — Todo / In Progress / Done | | Nebius routing | Reads live Linear state + QA results + build plan to decide the next follow-up (or stop) | | Workdir artifacts | RESEARCH.md, BUILD_PLAN.md, PRODUCT.md, turn lessons — written to disk each phase | | Memory stack | Recalls product decisions and prior turns before SuperCompress trims context (mem0 / supermemory) | | GitHub | Source of truth for code — pushed or PR'd after every turn |

Nebius never reruns full research unless explicitly refreshed. Each turn gets compressed context + fresh Linear snapshot — so the agent stays aligned with what actually shipped.

---

Manual takeover

You don't have to babysit — but you can steer anytime:

1. Start a loop from the dashboard or CLI
2. While the run is active, open Manual takeover in the live build view
3. Queue a message (e.g. “Drop Stripe, focus on CLI only” or “Fix the auth bug first”)
4. Loopy injects it into the next agent turn as highest-priority ste