Loom

Template engine for coding agent workspaces. Share and apply workspace configurations — instructions, skills, prompts, MCP servers, agents, and repos — across GitHub Copilot, Claude Code, and Cursor.

Loom lets teams maintain reusable workspace templates in a GitHub repository and apply them with a single chat command. No database, no server — just Git and GitHub Pages.

Demo

https://github.com/user-attachments/assets/8c937a54-cd23-45e6-9eb8-f7e2c86ec3f6

Why Loom?

Coding agents (Copilot, Claude Code, Cursor) rely on workspace-level configuration: instruction files, skill definitions, MCP servers, prompt files, and repository references. Teams often need to share and reuse these configurations across projects:

• Onboarding — new team members get a ready-to-go agent workspace in seconds
• Consistency — shared instructions and skills stay in sync across projects
• Multi-agent support — one template renders to Copilot, Claude Code, or Cursor format
• Personal setups — host your own templates on a personal GitHub repo

Quick Start

1. Install

npm install -g @agent-loom/loom

2. Set up a registry

loom registry add my-templates https://github.com/<your-org>/<your-templates>

3. Search and apply templates

In your coding agent's chat (Copilot, Claude Code, etc.):

Search for available Loom templates

Apply the functions-dev template to this workspace

The agent handles the whole workflow — searching, selecting, and applying the template to your workspace.

Launch an agent (loom <agent>)

Once a template is applied (or in any workspace with .github/agents/<id>.agent.md files), start a single agent in your terminal:

# From inside a workspace (walks up to find .github/agents/)
loom my-agent

# Pass extra args through to the runtime after `--`
loom my-agent -- --model=claude-sonnet-4.5

# Or use the dedicated --model / --add-dir flags directly:
loom my-agent --model=claude-sonnet-4.5

# Launch from anywhere by pointing at a workspace
loom my-agent --workspace /path/to/workspace

# Launch an agent that isn't in any local workspace — stages it from a
# configured registry into ~/.loom/sessions/<id>/workspace/
loom some-registry-agent

# Headless single-shot execution (no TTY): give a prompt, exit when done
loom my-agent -p "investigate failing test" --no-interactive

The verb-less form (loom <agent>) is the interactive surface — it inherits your tty and lets you talk to the agent (mirrors the copilot CLI). For scripted / structured one-shot execution, use either the loom run subcommand or the run() SDK from @agent-loom/loom/run, both of which capture stdout, honor a hard timeout, and return structured results (SESSION:, REPORT:, PROGRESS: artifact paths).

# Run a template-instantiated agent headlessly and collect artifacts
loom run my-template my-agent \
  --prompt "what's broken?" \
  --work-dir /tmp/loom-run-1 \
  --timeout-ms 300000

Every launch is recorded under ~/.loom/sessions/<id>/. Inspect past runs:

loom sessions list              # recent sessions
loom sessions show <id>         # full metadata
loom sessions tag <id> bug-repro
loom sessions note <id> "this one reproduced #1234"

Escape hatches: --no-session (skip recording), --no-registry-fallback (disable the registry fallback), --registry <name> (restrict to one registry).

Available Skills

Loom ships with 5 skills that teach your coding agent how to use the system:

| Skill | Purpose | |-------|---------| | loom-setup | Install CLI, configure registries, verify setup | | loom-search | Search and discover templates across registries | | loom-apply | Apply templates to scaffold workspaces | | loom-scaffold | Create new templates from existing projects | | loom-workspaces | Manage workspace history and navigate past projects |

All skills are bundled with the Craft catalog. Install them with npx @agent-loom/craft add <skill-name>.

How It Works

Template Registry (GitHub repo)
  ├── index.yaml              ← auto-generated template index
  ├── shared/                 ← reusable instructions, MCP, repos, prompts
  └── templates/
      └── my-template/
          └── manifest.yaml   ← declarative workspace definition
              ↓
          loom apply
              ↓
      ┌──── Target: Copilot ──────────────────┐
      │ .github/copilot-instructions.md        │
      │ .github/instructions/*.instructions.md │
      │ .github/agents/*.agent.md              │
      │ .github/skills/*/SKILL.md              │
      │ .github/prompts/*.prompt.md            │
      │ .vscode/mcp.json                       │
      └────────────────────────────────────────┘
      ┌──── Target: Claude Code ──────────────┐
      │ CLAUDE.md                              │
      │ .claude/agents/*.md                    │
      │ .claude/skills/*/SKILL.md              │
      │ .claude/settings.json                  │
      │ .mcp.json                              │
      └────────────────────────────────────────┘

Templates are declarative manifest.yaml files. Shared resources (instructions, MCP servers, repos, prerequisites) live in shared/ and are referenced via $ref. Loom resolves all references, fetches registry skills, and renders target-specific files.

Template Registries

A template registry is a GitHub repository with a specific layout:

my-registry/
  ├── index.yaml
  ├── shared/
  │   ├── instructions/
  │   ├── mcp/
  │   ├── repos/
  │   ├── prerequisites/
  │   └── prompts/
  └── templates/
      ├── template-a/
      │   └── manifest.yaml
      └── template-b/
          └── manifest.yaml

Create a GitHub repository with a template registry layout. See the documentation for a working example with CI/CD and a GitHub Pages catalog.

Catalog UI

Registries can publish a browsable catalog site to GitHub Pages using @agent-loom/loom-ui. The catalog is a static Next.js export that displays all templates with their full manifest details, built and deployed automatically via CI/CD.

Documentation

• Getting Started — Chat-based usage guide
• CLI Reference — Full command reference
• Architecture — System design and internals
• Skills Specification — How skills are defined and resolved

Packages

| Package | Description | |---------|-------------| | @agent-loom/loom | CLI + core library | | @agent-loom/loom-ui | Static catalog site generator (Next.js) |

Development

npm install
npm run build
npm test
node dist/cli.js --help

Working on a branch

To dogfood a local build globally:

cd <your-loom-worktree>
npm run build
npm link                        # exposes `loom` from this worktree on PATH
loom some-agent                 # uses your local build

# When done:
npm unlink -g @agent-loom/loom  # restore the published `loom`

npm link pins loom to the current worktree path. If you switch branches or blow away node_modules, re-run npm run build (no need to re-link).

License

ISC