{weave}
Weave
v0.3.2 · MIT License

Weave agents, tools, and skills into
structured workflows.

Stop context-switching. Start orchestrating.

A lean OpenCode plugin with multi-agent orchestration. 8 specialized agents. Plan-execute workflow. Zero config to start.

Get Started View on GitHub npm ↗
bash
$ bun add @opencode_weave/weave $ echo '{"plugin":["@opencode_weave/weave"]}' > opencode.json ✓ Weave loaded. 8 agents ready.
Built for the OpenCode ecosystem
{why_weave}

Why Multi-Agent?

Manual Workflow

  • ✗ Context-switching between tasks
  • ✗ No structured planning
  • ✗ Lost work on interruption
  • ✗ Single-threaded execution
  • ✗ No security review

Single Agent

  • ✓ AI-assisted coding
  • ✗ No specialization
  • ✗ No review or validation
  • ✗ Context window limits
  • ✗ No security auditing
Recommended

Weave

  • ✓ 8 specialized agents
  • ✓ Plan → Review → Execute
  • ✓ Checkpoint-based resumption
  • ✓ Per-agent tool permissions
  • ✓ Security auditing built in
{features}

Features

Everything you need for structured multi-agent development

🤖

8 Specialized Agents

Weaving-themed agents — from Loom the orchestrator to Warp the security auditor — each with distinct roles, models, and tool permissions.

📋

Plan → Review → Execute

Pattern creates structured plans. Weft validates them. Tapestry executes step-by-step with checkpoint-based resumption. No work is ever lost.

🧠

Skills System

Injectable domain expertise via markdown files. Modify agent behavior by prepending domain-specific instructions to system prompts.

📊

Context Window Monitoring

Automatic token tracking with warnings at 80% and recovery strategies at 95%. Never lose context mid-task.

⚡

Background Agent Management

Run multiple agents in parallel with configurable concurrency limits. Independent tasks execute simultaneously.

🔒

Tool Permissions & Safety

Per-agent access control ensures read-only agents can't write. Pattern can only create .md files in .weave/. Safety by design.

⚙️

Zero Config / Deep Customization

Works out of the box. JSONC configuration with comments for when you want to override models, temperatures, skills, and tool access per agent.

🔄

Session Resilience

Interrupt anytime. Resume with /start-work and pick up from the first unchecked task. Progress persisted in .weave/state.json.

{agents}

Meet the Agents

8 specialized agents, each with a distinct role in your development workflow

🧵

Loom

primary

Main Orchestrator

Plans tasks, coordinates work, delegates to specialized agents. The central team lead.

🪡

Tapestry

primary

Execution Engine

Executes plans step-by-step. Marks checkboxes. Resumes seamlessly from interruptions.

🚀

Shuttle

all

Category Specialist

Domain-specific worker with full tool access, dispatched via the category system.

📐

Pattern

subagent

Strategic Planner

Researches the codebase and produces structured implementation plans in markdown.

🔍

Thread

subagent

Codebase Explorer

Fast, read-only navigation — grep, glob, read. Precise answers with file paths.

🌐

Spindle

subagent

External Researcher

Fetches documentation, reads APIs, synthesizes findings with source citations.

✅

Weft

subagent

Reviewer / Auditor

Validates plans and reviews work. Approval-biased — rejects only for blocking issues.

🔐

Warp

subagent

Security Auditor

Audits for security vulnerabilities. Skeptical bias — rejects by default on security patterns.

Tool Permission Matrix

Agent Read Write Edit Task WebFetch Glob Grep Bash
🧵 Loom ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓
🪡 Tapestry ✓ ✓ ✓ ✗ ✓ ✓ ✓ ✓
🚀 Shuttle ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓
📐 Pattern ✓ .md* .md* ✗ ✓ ✓ ✓ ✓
🔍 Thread ✓ ✗ ✗ ✗ ✓ ✓ ✓ ✓
🌐 Spindle ✓ ✗ ✗ ✗ ✓ ✓ ✓ ✓
✅ Weft ✓ ✗ ✗ ✗ ✓ ✓ ✓ ✓
🔐 Warp ✓ ✗ ✗ ✗ ✓ ✓ ✓ ✓

* Pattern's Write/Edit restricted to .weave/*.md files only

{workflow}

How It Works

A structured workflow that scales from quick fixes to complex implementations

1

Pattern

Plan

Loom assesses complexity and delegates to Pattern. Pattern researches the codebase via Thread, consults external docs via Spindle, and produces a structured plan with checkboxed tasks in .weave/plans/.

# Add Search Functionality
- [ ] Create search index service
- [ ] Build search API endpoint
- [ ] Add search UI component
↓
2

Weft

Review

Weft validates the plan — checks file references exist, tasks have sufficient context, no contradictions. Approval-biased: only rejects for true blocking issues. If rejected, Pattern revises.

[APPROVE]
Plan is solid. Tasks are well-scoped
and references resolve correctly.
↓
3

Tapestry

Execute

Run /start-work to begin. Tapestry reads the plan, executes tasks sequentially — writing code, running commands, verifying output — and marks each checkbox. Interrupted? Resume from exactly where you left off.

- [x] Create search index service
- [x] Build search API endpoint
- [x] Add search UI component
✓ 3/3 tasks complete

Simple tasks? Loom handles them directly — no plan needed.

{install}

Get Started in 30 Seconds

1

Install the package

bun add @opencode_weave/weave
2

Add to opencode.json

{
  "plugin": ["@opencode_weave/weave"]
}
3

Restart OpenCode

✓

Restart OpenCode. Weave loads automatically with zero configuration. All 8 agents are immediately available.

Requires OpenCode and Bun or Node.js

{config}

Configure Everything. Or Nothing.

Zero config out of the box. JSONC configuration with comments when you need control.

  • Override models and temperature per agent

    Use Claude for planning, GPT-4o-mini for exploration, Gemini for UI work.

  • Define domain categories with specialized models

    Route visual-engineering tasks to vision-capable models automatically.

  • Inject custom skills from markdown files

    Prepend domain knowledge to agent prompts without touching source code.

  • Disable specific hooks, agents, or tools

    Turn off what you don't need. Full control over the agent roster.

  • Tune background agent concurrency

    Control how many agents run in parallel to manage cost and rate limits.

  • Project-level and user-level config merging

    Team defaults in the repo, personal overrides in ~/.config/.

Project: .opencode/weave-opencode.jsonc
User: ~/.config/opencode/weave-opencode.jsonc
{
  // Override agent models
  "agents": {
    "loom": {
      "model": "anthropic/claude-3-5-sonnet",
      "temperature": 0.1
    },
    "thread": {
      "model": "openai/gpt-4o-mini"
    }
  },
  // Category-based dispatch
  "categories": {
    "visual-engineering": {
      "model": "google/gemini-2-pro"
    }
  },
  // Feature toggling
  "disabled_hooks": [],
  "disabled_agents": []
}

weave-opencode.jsonc

{faq}

Frequently Asked Questions

What models does Weave support?

Any model supported by OpenCode — Claude, GPT-4o, Gemini, local models via Ollama. Override models per agent in your config. Mix and match based on cost and capability.

Does Weave work with my existing OpenCode setup?

Yes. Install the plugin, add it to opencode.json, and restart. Your existing config and workflows are untouched. Weave layers on top.

Can I customize which agents are available?

Yes. Disable any agent via disabled_agents in config, override models and temperatures per agent, or inject custom skills from markdown files to specialize behavior.

Is Weave free?

Yes. MIT licensed, open source, free forever. You pay only for the AI model API calls you make — Weave itself has no cost.

How is this different from just using OpenCode?

OpenCode gives you one powerful agent. Weave gives you eight specialized agents that collaborate — planning, reviewing, and executing structured workflows. Pattern writes the plan. Weft validates it. Tapestry executes it. Warp audits for security. Each agent excels at its role.