ctxloom

Context Loom - Weave context for AI coding agents

Get Started View on GitHub

Why Use ctxloom?

Save Hours Per Week

Write context once, reuse across all sessions. Stop re-explaining your coding standards.

Consistent Across Projects

Store your standards in a git repo, pull into any project.

Share Across Teams

Shared remotes for org standards, personal remotes for yours.

Multi-LLM Support

Write once, run everywhere. Same context works with Claude Code, Antigravity CLI, and more.

What ctxloom Does

Capability	Description
Context Assembly	Combine fragments into profiles, inject into Claude/Antigravity via MCP
Slash Commands	Prompts become `/commands` in Claude Code and Antigravity automatically
Session Memory	Persist context across `/clear`, recover seamlessly
Remote Pull	Pull bundles from GitHub/GitLab, lockfile for reproducibility
Token Optimization	AST-aware distillation compresses code/prose 70-90%

Quick Example

# Initialize
ctxloom init

# Run with context fragments
ctxloom run -f go-development -f security "implement auth"

# Use a profile (pre-configured fragment set)
ctxloom run -p backend-developer "review this PR"

# Reference a remote bundle in a local profile, then pull
ctxloom profile create testing -b ctxloom-main/testing
ctxloom remote pull

Slash Commands

Prompts in bundles become slash commands in Claude Code and Antigravity CLI:

prompts:
  code-review:
    description: "Review code for issues"
    content: |
      Review this code for:
      - Security vulnerabilities
      - Performance issues
      - Best practice violations

Then in your AI CLI:

/code-review src/auth.go

Session Memory

Claude Code’s /compact has a fundamental flaw: it needs context space to run, but you only think to use it when context is almost full. You try /compact, it fails, and you’re stuck.

ctxloom works after exhaustion:

Clear - Run /clear when you hit context limits
Recover - /recover distills the previous session from disk
Continue - The summary is injected, you keep working

# When you hit context limits
/clear
/recover

ctxloom reads the raw JSONL transcript from disk and uses a separate LLM (default: Haiku) to distill it - operating outside your exhausted context window.

ctxloom includes a built-in command:

/recover - Recover context from a previous session after /clear

How It Works

flowchart LR
    Bundles["Bundles<br/>(fragments)"] --> Profiles["Profiles<br/>(combos)"]
    Profiles --> Context["Context<br/>(assembled)"]
    Bundles --> Remotes["Remotes<br/>(GitHub/GL)"]
    Context --> AI["Claude/Antigravity<br/>(via MCP)"]

Bundles contain fragments (context), prompts (skills), and MCP servers
Profiles combine bundles with inheritance and exclusions
Context is assembled and injected via MCP protocol
Remotes provide team sharing and community bundles

Core Concepts

Concept	What It Is
Fragment	A piece of context (guidelines, patterns, examples)
Prompt	A saved prompt template, exposed as a slash command
Bundle	A versioned YAML containing fragments + prompts + MCP servers
Profile	A named configuration referencing bundles/tags
Remote	A GitHub/GitLab repository containing bundles

Installation

macOS (Homebrew):

brew install ctxloom/tap/ctxloom-full   # or ctxloom for the lighter build

Linux (script):

curl -fsSL https://raw.githubusercontent.com/ctxloom/ctxloom/main/scripts/install.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/ctxloom/ctxloom/main/scripts/install.ps1 | iex

More options (manual download, build from source, security verification)

Running

# Standalone (wraps Claude/Antigravity)
ctxloom run -p developer "help with code"

# As MCP server (integrate with existing Claude Code)
ctxloom mcp serve

Configuration

llm:
  default: claude-code
defaults:
  profiles:
    - ctxloom-main/go-developer

Next Steps

Installation

Full installation guide

Quick Start

Create your first bundle

Bundles

Fragment and prompt structure

Session Memory

Preserve context across sessions

llm-tool-killer (ltk)

Companion tool — guide the commands your agent runs, not just its context.