loom

On your Claude subscription · not metered API

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

Every agent is the genuine interactive claude driven over a PTY, so a whole fleet runs on the Claude subscription (Pro/Max) you already pay for, with no per-token API bill for the orchestration. A lead decomposes a goal and delegates to workers on isolated branches, all on your own machine.

View on GitHub See how it works
  • Runs on your Pro/Max plan
  • No per-token API bill
  • Your data, on your hardware

Agents still consume your subscription's usage and obey its rate limits.

Subscription

Claude Pro / Max, not metered API

Engine

Real interactive claude, over PTY

State

Local daemon · SQLite · your git + vault

Orchestration

1 lead → N workers, isolated branches

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. 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. Those sessions are durable: a daemon on your own machine owns them, so closing the window never kills the work, and your code, transcripts, and vault stay on your hardware. Around them, one lead agent decomposes a goal, delegates to workers on isolated branches, reviews their diffs, and merges.

Features

Built like an instrument.

  • Runs on your subscription

    Every agent is the genuine interactive claude driven over a PTY, never claude -p / headless, never an API-key agent loop, so a whole fleet runs on the Claude subscription (Pro/Max) you already pay for, with no per-token API bill for the orchestration. Sessions are resumable and outlive any viewer, so a closed tab or a reboot doesn't lose the thread.

  • Multi-agent orchestration

    A lead session plans, delegates to worker sessions on isolated worktree branches, reviews each diff, and merges through a gate. Workers report up; the lead holds the whole picture.

  • The terminal cockpit

    A stateless web viewport attaches over WebSockets: Mission Control, a task board, live terminals, runs and git, 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, so your code and history stay on your machine.

  • Vault-backed knowledge

    Design notes, decisions, and session logs live in an Obsidian vault woven alongside the code, and Loom auto-commits vault writes so the knowledge layer stays versioned with the work.

  • 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, behind a fail-closed, human-only security model.

  • Editable skills, injected per session

    Loom ships a curated skill set and mirrors it into every session, shadowing your personal ~/.claude/skills. A built-in editor lets you read, edit, create, reset, and three-way-merge Loom's shipped updates into your own edits; 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, configure, and archive projects, agents, and profiles, and can set them up on your behalf, confirming the big moves first, on a deliberately narrow, safe tool surface.

  • 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.

  • 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. The cockpit runs on your own machine, bound to loopback. Prefer the source? Clone the repo and run it with pnpm.

  • MIT licensed
  • Loopback only
  • macOS · Linux · Windows
loom · quickstart

# install the manager CLI (bin: loom)

$ npm i -g loomctl
$ loom start
$ loom open

# or run from source

$ pnpm install && 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