weft hues above are assigned the way the TUI colors agents: six named dyes, then golden-angle steps around the wheel.
teradata-labs/loom · v1.4.0 · Apache-2.0 · Go 1.25+
Loom runs multi-agent systems behind a single gRPC API — 152 RPCs, proto-first. Describe the agent you need in plain English and the Weaver assembles it from 158 YAML patterns. After that the harness does the hauling: context assembly, memory, token budgets, compression, tracing. No prompt archaeology.
brew install teradata-labs/tap/loom
$ loom --thread weaver you> Create a Teradata query optimizer that reads EXPLAIN plans and flags product joins. weaver> Analyzing requirements... patterns teradata/explain-analysis, sql-core, performance workflow pipeline Agent "explain-optimizer" is live. Attach with: $ loom --thread explain-optimizer
the harness
Most frameworks give you an agent loop and leave the hard part — deciding what the model sees each turn — as an exercise for the reader. Loom treats context as managed infrastructure. Every turn, the harness assembles the window from salience-ranked graph memory, session history, and whichever patterns match the intent, inside a token budget you set once and stop thinking about.
Memory is honest about being memory: immutable records with lineage, so a correction supersedes the old fact instead of overwriting it, and salience decays until something is worth recalling again. When the window fills, the compressor role does the summarizing — and per-role providers let you pin that role to a cheaper model.
patterns matched to intent, drawn from 158 graph memory salience-ranked entities + records budget 20% of the context window, configurable salience decays 0.95/day · boosted on access history FTS5-searchable, restored on attach corrections SUPERSEDES lineage, never overwrite compressor its own model, via per-role providers
pattern-guided learning
Every agent draws on 158 patterns across 16 domains: Teradata analytics, Postgres tuning, SQL validation, prompt technique, document extraction, and so on. A pattern is plain-English YAML — write one and your agent becomes a specialist; version it and your team's expertise stops living in someone's chat history.
Learning agents close the loop. They watch their own successes and failures and propose
edits back to the patterns, with three autonomy levels: manual, human-approval,
and full. You choose how much rope to hand out.
| teradata/ | ML models, analytics, data quality, FastLoad, performance | 84 |
| libraries/ | domain bundles — sql-core, teradata-analytics, … | 20 |
| postgres/ | query optimization, index analysis, vacuum tuning | 12 |
| weaver/ | workflow patterns — debate, pipeline, fork-join, swarm | 9 |
| sql/ | validation, profiling, duplicate detection | 8 |
| prompt_engineering/ | chain-of-thought, few-shot, structured output | 4 |
| documents/ | PDF extraction, Excel analysis, CSV import | 4 |
| …9 more | vision, code, debugging, REST, evaluation, NASA | 17 |
orchestration
Multi-agent coordination is a first-class type, not a for-loop you maintain. The Weaver picks a topology automatically; you can also declare one in YAML.
Sequential stages. ETL, multi-step analysis.
Independent tasks, all at once.
Split the work, merge the results.
Agents argue perspectives, reach consensus.
Route on an agent's decision.
Dynamic collaboration, membership decided at runtime.
A pipeline that restarts itself on failure.
Two agents, one piece of code.
One agent teaches and grades the other.
the full spread
One repo, three binaries. Everything below is in v1.4.0 — shipped, not roadmapped.
| weaver | Builds agents from a sentence; picks a workflow topology when the job needs more than one agent. | 158 patterns |
| context & memory | Salience-scored graph memory with correction lineage; token-budgeted injection every turn. | 20% budget default |
| workflows | Orchestration as typed proto, not glue code you maintain. | 9 topologies |
| judges | Multi-judge scoring with pluggable aggregation and sync, async, or hybrid execution. DSPy-optimizable. | 6 strategies · 3 modes |
| learning agents | Watch their own successes and failures, then propose edits back to the patterns. | 3 autonomy levels |
| skills | Activatable behaviors — slash command, keyword trigger, or always-on — with hot-reload. | — |
| tools | Sandboxed shell, files, HTTP and gRPC calls, inter-agent messaging, shared state, human-in-the-loop. | 18 built-ins |
| mcp | Any MCP server via config; built-in UI apps; agents can compile dashboards from a JSON spec at runtime. | 4 apps · 14 components |
| providers | Mid-session model switching; cheaper models assignable to judge, classifier, and compressor roles. | 8 providers · 73 models |
| artifacts | Session-scoped file storage with full-text search and soft delete you can walk back. | 30-day recovery |
| observability | Self-contained tracing with OTLP export and per-call cost tracking in the TUI. | — |
| storage | SQLite with FTS5 or PostgreSQL; versioned migrations; automatic backups before every upgrade. | — |
scale
Loom is Go all the way down: looms serve is one static binary, agents are
goroutines rather than sidecar processes, and every claim about concurrency is enforced
by CI — the whole suite runs under -race, and the standing count is zero.
A single binary and SQLite with FTS5. No daemons, no queue, no docker-compose ritual. The container image, if you want one, is distroless and CGO-free.
Point the same binary at PostgreSQL. Identical versioned migrations, advisory-locked so concurrent instances can't trample a schema upgrade. Every client speaks gRPC or REST with SSE.
Parallel, fork-join, and swarm topologies fan the work out; per-role providers keep the bill sane by pinning judge, classifier, and compressor traffic to cheaper models. The TUI's color generator never runs out of distinct hues — which tells you what it was built expecting.
We could print a requests-per-second number from our hardware, and you would rightly
ignore it. The load-bench harness ships in the repo instead — loom-bench-server
and loom-bench-harness under cmd/, with a distroless build in
deploy/. Run it on yours.
production
install
Packages publish automatically with every tagged release.
brew install teradata-labs/tap/loom
winget install Teradata.Loom # or: choco install loom
git clone https://github.com/teradata-labs/loom && cd loom && ./quickstart.sh
Releases are GPG-signed with SLSA provenance — verification steps in docs/installation.