Loom

An LLM agent framework for Go. Create agents from natural language, orchestrate them with workflow patterns, and give them domain knowledge as skills and patterns the model loads on demand.

Version: v1.4.0

---

Quick Start

# 1. Install
git clone https://github.com/teradata-labs/loom && cd loom
./quickstart.sh          # macOS/Linux (handles Go, Buf, patterns)
# .\quickstart.ps1       # Windows (PowerShell)

# 2. Set your LLM provider
export ANTHROPIC_API_KEY="your-key"    # or Bedrock, Ollama, OpenAI, etc.

# 3. Start the server
looms serve              # gRPC :60051, HTTP :5006

# 4. Launch the TUI
loom                     # Opens with Guide agent
loom --thread weaver     # Or go straight to the Weaver

The Weaver is a meta-agent that creates other agents from natural language:

You: Create a Teradata query optimizer that analyzes EXPLAIN plans
Weaver: Analyzing requirements... selecting patterns... activating agent.

API endpoints after looms serve:

• gRPC: localhost:60051 (151 RPCs)
• HTTP/REST: localhost:5006 (with SSE streaming)
• Swagger UI: localhost:5006/swagger-ui
• MCP Apps: localhost:5006/apps/

---

How It Works

Domain knowledge lives outside the system prompt, as YAML skills and patterns the model pulls into the conversation when it decides it needs them. Nothing is injected: the model decides what enters its own context.

User message → LLM call ─┬─ manage_skills(list)      → the skill catalog, each entry marked
                         │                             active for this session or not
                         ├─ manage_skills(load NAME) → skill instructions enter the conversation
                         ├─ load_pattern(REFERENCE)  → pattern content enters as a tool result
                         └─ any other tool           → result enters the conversation
                                                                     ↓
                                                                  Response

The system prompt carries only a menu of the agent's bound skills — name and description — rendered once when the session is created. A skill's body reaches the model only after a manage_skills load, and a pattern's body only after a load_pattern call.

Patterns and skills are plain-English YAML files anyone can write. They turn generic LLMs into domain specialists for SQL optimization, data quality, Teradata analytics, code review, and more.

---

Features

Weaver (Meta-Agent)

Describe what you need; the Weaver builds it:

• Analyzes requirements to determine domain and capabilities
• Selects patterns from the library (158 patterns across 16 domains)
• Generates YAML configuration and activates the agent
• Automatically selects workflow patterns for multi-agent tasks
• /agent-plan mode for guided requirement gathering with skills-based recommendations

Multi-Agent Workflows

9 orchestration patterns defined in proto:

Pattern	Use Case
Pipeline	Sequential stages (ETL, multi-step analysis)
Parallel	Independent concurrent tasks
Fork-Join	Parallel execution with merged results
Debate	Multiple agents argue perspectives, reach consensus
Conditional	Route based on agent decisions
Swarm	Dynamic agent collaboration
Iterative	Pipeline with autonomous restart on failure
Pair Programming	Two agents collaborate on code
Teacher-Student	One agent teaches/evaluates another

Judge Evaluation System

Multi-judge evaluation with 6 aggregation strategies (weighted-average, all-must-pass, majority-pass, any-pass, min-score, max-score) and 3 execution modes (synchronous, asynchronous, hybrid). Includes DSPy integration for judge optimization.

See Judge CLI Guide.

Learning Agents

Self-improving agents that analyze successes/failures and propose pattern improvements. Three modes: observation, proposal, and auto-apply. Integrates with DSPy for prompt optimization.

See Learning Agent Guide.

Pattern Library

158 YAML patterns across 16 domains, installed to $LOOM_DATA_DIR/patterns/:

Domain	Count	Examples
teradata/	84	ML models, analytics, data quality, performance, FastLoad
libraries/	20	Domain-specific pattern bundles (sql-core, teradata-analytics, etc.)
postgres/	12	Query optimization, index analysis, vacuum tuning
weaver/	9	Workflow patterns (debate, pipeline, fork-join, swarm, etc.)
sql/	8	Data validation, profiling, duplicate detection
fun/	5	Entertainment patterns
prompt_engineering/	4	Chain-of-thought, few-shot, structured output
documents/	4	PDF extraction, Excel analysis, CSV import
Others	12	Vision, code, text, document, debugging, REST API, NASA, evaluation

Write your own patterns in plain English YAML to make Loom agents into domain experts for your specific use cases.

MCP Integration

Connect any MCP server without code:

This is the beginning of the README. Read the rest at the original. Read the full README ↗