loom

Durable · local-first · review-gated orchestration

Weave a fleet of real Claude Code agents into one fabric.

Every agent is the genuine interactive claude, driven over a PTY and owned by a daemon on your own machine, so sessions are durable: a lead decomposes a goal, delegates to workers on isolated branches, and reviews each diff before it merges. A whole fleet runs on the Claude subscription (Pro/Max) you already pay for, with no per-token API bill for the orchestration.

View on GitHub See how it works
  • Durable, on your machine
  • Review-gated merges
  • Runs on your Pro/Max plan

Agents still consume your subscription's usage and obey its rate limits, and how that usage is billed is Anthropic's policy to set and evolve.

Engine

Real interactive claude, over PTY

State

Local daemon · SQLite · your git + vault

Orchestration

1 lead → N workers, review-gated merges

Subscription

Claude Pro / Max, not metered API

What it is

One fabric for the work, the agents, and the knowledge.

Loom drives the real interactive claude, the same terminal session you'd run by hand rather than a headless one-shot or an API-key agent loop. A daemon on your own machine owns those sessions, so they're durable — closing the window never kills the work — and one lead agent decomposes a goal, delegates to workers on isolated branches, reviews their diffs, and merges through a build gate. Your code, transcripts, and vault stay on your hardware. And because every agent is a genuine claude session, a whole fleet of them runs on your existing Claude subscription (Pro/Max), with no separate per-token API bill for the orchestration.

Features

Built like an instrument.

  • Durable real sessions

    Every agent is the genuine interactive claude driven over a PTY, never claude -p / headless, never an API-key agent loop, and owned by a daemon rather than your shell, so sessions are resumable and outlive any viewer: a closed tab or a reboot doesn't lose the thread. And because each one is a real claude session, a whole fleet runs on the Claude subscription (Pro/Max) you already pay for, with no per-token API bill for the orchestration.

  • Multi-agent orchestration

    A lead session plans, delegates to worker sessions on isolated worktree branches, reviews each diff, and merges through a gate. A whole batch of ready branches can land in one gate run, and a change that can't affect the build doesn't pay for one. Workers report up; the lead holds the whole picture.

  • Every gate in one place

    Merge, deploy, and worker self-check gates all run daemon-wide through a single concurrency budget, and the Gates page is the view of all of them: which lanes are busy, what's queued behind them, and the history of settled runs, filterable per project.

  • Multi-repo projects

    One project can register more than one writable repository and route each board card to a specific repo, threaded through worktree creation, the merge gate, and the per-card merged badge. A front end and a back end in separate checkouts, one board.

  • The terminal cockpit

    A stateless web viewport attaches over WebSockets and follows a live status feed: Mission Control, live terminals, the board, Memory, gates, runs and the repository, all in one phosphor-on-dark instrument panel.

  • Your data, on your hardware

    Everything Loom keeps is local: a loopback-bound daemon, an SQLite store, your git checkouts, transcripts, and vault. Loom adds no cloud service of its own — Loom itself never uploads your code, transcripts or history, because there's no account and no Loom server to upload them to. Every UI write route needs a local access credential, so another process on the box can't drive the API just by reaching the socket. What does leave the machine — the agents' own conversations with Anthropic (or, on the opt-in Codex harness, your Codex CLI's provider), a plan-usage poll, an update check on an npm install, and opt-in webhooks and package downloads — is listed in the README, with how to stop each one that can be stopped.

  • Reach it from another device

    Forward a port over SSH and the loopback daemon is on your laptop or phone, with one token step per device and nothing new listening. Loom can also bind an interface itself — a gateway token per client, TLS required off a tailnet, a fail-closed route allowlist — but read that as an authenticated API, not a second cockpit. A same-host reverse proxy such as Tailscale Serve is supported as a read-and-steer cockpit, not yet verified on a live tailnet. Off by default.

  • Vault + Memory knowledge

    Design notes, decisions, and session logs live in an Obsidian vault woven alongside the code, auto-committed so they stay versioned. On top of it, Memory is a browsable window into the durable memory the fleet itself writes and recalls across sessions.

  • A task board agents can use

    Tasks are a first-class, project-scoped surface backed by an MCP server, so agents read the board, create cards, and move work through columns as part of the same loop you watch, the same board the lead uses to decompose a goal into worker tasks.

  • A chat-native companion

    Spin up a long-lived companion agent you chat with over Telegram or an in-app web chat, on the same durable real-claude runtime. It keeps a durable memory recalled at the start of each chat, sets one-shot and recurring reminders, writes its own private skills, and can proactively check in. Grant it a lever and it will commit and push on your behalf too, asking first. Fail-closed and human-only: it can never change what it's allowed to do.

  • Editable skills, injected per session

    Loom ships a curated skill set and mirrors it into every session as project-local skills, leaving your personal ~/.claude/skills untouched. A profile can pin which skills its sessions get, and a built-in editor lets you read, edit, create, reset, and three-way-merge Loom's shipped updates into your own; changes take effect on the next session spawn.

  • Opt-in per-worker browser testing

    A worker profile can be granted its own isolated headless Playwright browser, so QA-style sessions can drive a running app and verify UI before reporting back. Off by default, enabled per profile.

  • Guided setup + a Platform operator

    A built-in Platform operator greets you on first run and stays one click away. It helps you create and configure projects, agents, and profiles, and can set them up on your behalf, confirming the big moves first, on a deliberately narrow, safe tool surface — one lifecycle move on it, archiving a project, and nothing that deletes.

  • Suggest-only Workspace Auditor

    A read-only reviewer scans your own recent sessions for vague instructions in your agent prompts and skills, and for prompts you type repeatedly worth saving as one-click presets, then files improvement suggestions as cards. It never changes anything itself. Run it on demand or on a schedule.

  • A built-in cron scheduler

    Run a manager, or the Workspace Auditor, on a cron cadence; each fire boots a real interactive session against the agent you pick, behind concurrency and usage-limit gates. Off by default; enable it in Settings and restart the daemon to arm the ticker.

  • Agents as authenticated API endpoints

    Flag a project agent as an endpoint, mint a scoped API key with concurrency, token, and spend caps, then trigger structured async runs over POST /api/runs. The Runs page shows every run's input, result, usage, and transcript, with a per-key kill-switch.

  • Connections the agent never sees

    Store a credential once, say a GitHub token, encrypted at rest. A session's profile allowlists which connections it may use, and the agent reaches the API through Loom without the secret ever entering its context. Write-only and human-managed.

  • Opt-in document conversion

    Grant a worker profile a markitdown MCP and its sessions can convert PDFs, Office files, images, and HTML to Markdown, useful for research and document-heavy work. Off by default, human-enabled per profile.

How it works

Plan, delegate, review, merge.

  1. 01

    Run the daemon

    A single local daemon owns the durable state on 127.0.0.1: sessions, the PTY host, the gateway, git, and the vault.

  2. 02

    Open the cockpit

    The web viewport attaches over WebSockets and detaches freely. The session keeps running on the daemon whether or not you're watching.

  3. 03

    Give a lead a goal

    The lead decomposes the goal into tasks and spawns workers, each on its own worktree branch, each driving a real Claude Code session.

  4. 04

    Review and weave it in

    Workers report up; the lead reviews each diff, merges what passes, and the vault + board keep the decisions and progress versioned alongside the code.

Quickstart

Two commands to a live fleet.

Install the management CLI from npm and start the local daemon — loom start runs in the foreground and opens the cockpit for you. It runs on your own machine, bound to loopback. Prefer the source? Clone the repo and run it with pnpm.

  • MIT licensed
  • Loopback by default
  • macOS · Linux · Windows
loom · quickstart

# install the manager CLI (bin: loom)

$ npm i -g loomctl

# start the daemon and open the cockpit

$ loom start

# or run from source (build first — the daemon imports the built shared contract)

$ pnpm install && pnpm build && pnpm daemon

Read the source.

Loom is an in-progress project that runs on your own machine. The code, the architecture, and the design decisions live in the repository.

View on GitHub