Rune

Rune

Multi-agent engineering orchestration for Claude Code.

> Built on [Discipline Engineering](docs/discipline-engineering.md) — a proof-based architecture that treats specification compliance, not just code quality, as the primary metric.

Plan, implement, review, test, and audit your codebase using coordinated Agent Teams — each teammate with its own dedicated context window.

[](https://docs.anthropic.com/en/docs/claude-code) [](.claude-plugin/marketplace.json) [](LICENSE) [](#agents) [](#skills)

---

What Is This?

Rune is a Claude Code plugin that turns a single-agent coding session into a coordinated multi-agent engineering team. It provides 116 specialized AI agents (74 core + 42 extended), 44 skills, and a 45-phase end-to-end pipeline that handles planning, implementation, code review, testing, and PR creation — all orchestrated through Claude Code's Agent Teams.

Compatibility: Requires Claude Code 2.1.81+ with Agent Teams support. macOS 12+ or Linux. See [full requirements](#requirements).

---

Why This Exists

Claude Code is powerful on its own — but a single agent has a single context window. As tasks grow in scope (reviewing a 50-file diff, planning a feature across multiple services, running a full implementation pipeline), one context window becomes the bottleneck:

• Context saturation — A single agent reviewing 40 files loses focus on file 35. Rune gives each reviewer its own full context window, so the last file gets the same attention as the first.
• Specialization over generalization — One agent trying to catch security issues, performance bugs, and naming inconsistencies simultaneously does none of them well. Rune dispatches Ward Sentinel for security, Ember Oracle for performance, and Pattern Seer for consistency — each focused on what it does best.
• Parallelism — Sequential work on 6 implementation tasks takes 6x as long. Swarm workers claim and complete tasks independently, bounded only by file-level conflicts.
• Separation of concerns — Planning, implementing, reviewing, and testing in one context creates confirmation bias (the same agent reviews code it just wrote). Rune enforces phase boundaries: different agents plan, build, and critique.

These problems are symptoms of a deeper issue: AI agents optimize for completion signals, not specification compliance. Rune's architecture is designed around the [Discipline Engineering](docs/discipline-engineering.md) framework — five layers of decomposition, comprehension verification, proof-based completion, and anti-rationalization gates that ensure agents deliver what was specified, not just what compiles.

The trade-off is token cost — multi-agent workflows consume more tokens than a single session. Rune is designed for cases where quality, thoroughness, and coverage matter more than minimizing API usage.

---

> [!WARNING] > Rune is token-intensive and time-intensive. > > Each workflow spawns multiple agents, each with its own dedicated context window. This means higher token consumption and longer runtimes than single-agent usage. > > | Workflow | Typical Duration | Why | > |----------|-----------------|-----| > | /rune:devise | 10–30 min | Up to 7 agents across 7 phases (brainstorm, research, synthesize, forge, review) | > | /rune:appraise | 5–20 min | Up to 8 review agents analyzing your diff in parallel — scales with LOC changed | > | /rune:audit | 10–30 min | Full codebase scan — same agents, broader scope | > | /rune:strive | 10–30 min | Swarm workers implementing tasks in parallel | > | /rune:arc | 1–2 hours | Full 45-phase pipeline (forge → plan review → work → gap analysis → code review → mend → test → ship → merge) | > | /rune:arc (complex) | up to 3 hours | Large plans with multiple review-mend convergence loops | > > /rune:arc is intentionally slow because it runs the entire software development lifecycle autonomously — planning enrichment, parallel implementation, multi-agent code review, automated fixes, 3-tier testing, and PR creation. Each phase spawns and tears down a separate agent team. The result is higher quality, but it takes time. > > Want faster iterations? Run the steps individually instead of the full pipeline: > > `` > /rune:plan → /rune:work → /rune:review > (10–30 min) (10–30 min) (5–20 min) > ` > > This gives you the same core workflow (plan → implement → review) in **25–80 minutes** with manual control between steps — versus 1–3 hours for /rune:arc which adds forge enrichment, gap analysis, automated mend loops, 3-tier testing, and PR creation on top. > > **Claude Max ($200/month) or higher recommended.** Use --dry-run` where available to preview scope before committing.

---

Install

/plugin marketplace add https://github.com/vinhnxv/rune
/plugin install rune

Restart Claude Code after installation.

Local development

claude --plugin-dir /path/to/rune

Setup

Rune requires Agent Teams. Enable it in .claude/settings.json or .claude/settings.local.json:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  },
  "includedGitignorePatterns": [
    "plans/",
    "todos/",
    "tmp/",
    "reviews/",
    ".rune/",
    ".claude/CLAUDE.local.md"
  ]
}

includedGitignorePatterns lets Claude Code read Rune's output directories that are typically gitignored.

For configuration details (hardcoded v3.x defaults, override paths) see the [Configuration](#configuration) section below.

---

How It Works

Rune orchestrates multi-agent workflows where specialized AI teammates collaborate through shared task lists and file-based communication. Instead of one agent doing everything in a single context window, Rune splits work across purpose-built agents — each with its own full context window.

You ──► /rune:devise ──► Plan
                           │
         /rune:arc ◄───────┘
             │
             ├─ Forge & Validate     enrich plan, review architecture, refine
             ├─ Work                 swarm workers implement in parallel
             ├─ Gap Analysis         detect and remediate implementation gaps
             ├─ Review & Mend        multi-agent code review + auto-fix findings
             ├─ Test                 3-tier testing (unit → integration → E2E)
             ├─ Ship                 validate and create PR
             └─ Merge               rebase and merge

---

Workflows

Quick Start (New Users)

| Command | What it does | Alias for | |---------|-------------|-----------| | /rune:plan | Plan a feature or task | /rune:devise | | /rune:work | Implement a plan with AI workers | /rune:strive | | /rune:review | Review your code changes | /rune:appraise | | /rune:brainstorm | Explore ideas through dialogue | /rune:brainstorm | | /rune:quick | Quick 3-phase pipeline (plan -> work -> review) | /rune:arc-quick |

/rune:tarnished — The Unified Entry Point

Don't remember which command to use? /rune:tarnished is the intelligent master command that routes natural language to the correct Rune workflow. It understands both English and Vietnamese.

# Route by keyword — passes through to the right skill
/rune:tarnished plan add user authentication
/rune:tarnished work plans/my-plan.md
/rune:tarnished review
/rune:tarnished arc plans/my-plan.md
/rune:tarnished arc-quick plans/my-plan.md

# Chain workflows — multi-step with confirmation between steps
/rune:tarnished review and fix
/rune:tarnished plan then work

# Natural language — classifies intent automatically
/rune:tarnished implement the latest plan
/rune:tarnished fix the findings from the last review

# Guidance — ask Rune anything
/rune:tarnished help
/rune:tarnished what should I do next?
/rune:tarnished khi nào nên dùng audit vs review?

When run with no arguments, /rune:tarnished scans your project state (plans, reviews, git changes) and suggests the most logical next action.

Core Commands

| Command | What it does | Agents | Duration | |---------|-------------|--------|----------| | [/rune:devise](#devise) | Turn ideas into structured plans with parallel research | up to 7 | 10–30 min | | [/rune:strive](#strive) | Execute plans with self-organizing swarm workers | 2-6 | 10–30 min | | [/rune:appraise](#appraise) | Multi-agent code review on your diff | up to 8 | 5–20 min | | [/rune:audit](#audit) | Full codebase audit with specialized reviewers | up to 8 | 10–30 min | | /rune:arc-quick | Quick pipeline: plan → work → review → mend (4 phases) | varies | 25–60 min | | [/rune:arc](#arc) | End-to-end pipeline: plan → work → review → test → ship | varies | 1–3 hours | | [/rune:mend](#mend) | Parallel resolution of review findings | 1-5 | 3–10 min | | [/rune:forge](#forge) | Deepen a plan with topic-aware research enrichment | 3-12 | 5–15 min | | [/rune:goldmask](#goldmask) | Impact analysis — what breaks if you change this? | 8 | 5–10 min | | [/rune:inspect](#inspect) | Plan-vs-implementation gap audit (10 dimensions) | 4 | 5–10 min | | [/rune:elicit](#elicit) | Structured reasoning (Tree of Thoughts, Pre-mortem, 5 Whys) | 0 | 2–5 min |

Utilities

| Command | What it does | |---------|-------------| | /rune:rest | Clean up tmp/ artifacts from completed workflows | | /rune:file-todos | Structured file-based todo tracking with YAML frontmatter | | /rune:cancel-arc | Gracefully stop a running arc pipeline | | /rune:cancel-review | Stop an active code review | | /rune:cancel-audit | Stop an active audit | | /rune:team-delegate | Task delegation dashboard | | /rune:plan-review | Review plan code samples for correctness | | /rune:pr-guardian | Automated PR shepherd — lint, CI, rebase, migrations, browser test, auto-merge (cron every 5 min) |

---

Workflow Details

/rune:devise — Planning

Transforms a feature idea into a structured plan through a multi-phase pipeline:

1. Brainstorm — structured exploration with elicitation methods
2. Research — parallel agents scan your repo, git history, echoes, and external docs
3. Solution Arena — competing approaches evaluated on weighted dimensions
4. Synthesize — consolidate findings into a plan document
5. Predictive Goldmask — risk scoring for files the plan will touch
6. Forge — topic-aware enrichment by specialist agents
7. Review — automated verification + optional technical review

/rune:devise                  # Full pipeline
/rune:devise --quick          # Skip brainstorm + forge (faster)

Output: plans/YYYY-MM-DD-{type}-{name}-plan.md

/rune:arc — End-to-End Pipeline

The full pipeline from plan to merged PR, with 45 phases:

Forge → Plan Review → Refinement → Verification → Semantic Verification
  → Design Extraction → Task Decomposition → Work → Storybook Verification
  → Design Verification → UX Verification → Gap Analysis
  → Gap Remediation → Goldmask Verification → Code Review (--deep)
  → Goldmask Correlation → Mend → Verify Mend → Design Iteration
  → Test → Test Coverage Critique → Pre-Ship Validation → Release Quality Check
  → Ship → Bot Review Wait → PR Comment Resolution → Merge

/rune:arc plans/my-plan.md
/rune:arc plans/my-plan.md --resume        # Resume from checkpoint
/rune:arc plans/my-plan.md --no-forge      # Skip forge enrichment
/rune:arc plans/my-plan.md --skip-freshness  # Bypass plan freshness check

Features: checkpoint-based resume, adaptive review-mend convergence loop (3 tiers: LIGHT/STANDARD/THOROUGH), diff-scoped review, co-author propagation.

How arc phases work: Arc uses Claude Code's Stop hook to drive the phase loop — when one phase finishes, the stop hook reads state from .rune/arc-phase-loop.local.md, determines the next phase, and re-injects a prompt. Each phase is literally a new Claude Code turn with its own fresh context window. This solves the context degradation problem (phase 18 gets the same quality as phase 1) but means the stop hook chain is a critical path — a bug in any hook silently breaks the pipeline. See [docs/state-machine.md](docs/state-machine.md) for the full phase graph.

/rune:strive — Swarm Execution

Self-organizing workers parse a plan into tasks and claim them independently:

/rune:strive plans/my-plan.md
/rune:strive plans/my-plan.md --approve    # Require human approval per task

/rune:appraise — Code Review

Multi-agent review of your git diff with up to 8 specialized Ashes:

/rune:appraise                # Standard review
/rune:appraise --deep         # Multi-wave deep review (up to 18 Ashes across 3 waves)

Built-in reviewers include: Ward Sentinel (security), Pattern Seer (consistency), Flaw Hunter (logic bugs), Ember Oracle (performance), Depth Seer (missing logic), and more. Stack-aware intelligence auto-adds specialist reviewers based on your tech stack.

/rune:audit — Codebase Audit

Full-scope analysis of your entire codebase (not just the diff):

/rune:audit                   # Deep audit (default)
/rune:audit --standard        # Standard depth
/rune:audit --deep            # Multi-wave investigation
/rune:audit --incremental     # Stateful audit with priority scoring and coverage tracking

/rune:mend — Fix Findings

Parse a TOME (aggregated review findings) and dispatch parallel fixers:

/rune:mend tmp/reviews/{id}/TOME.md

/rune:forge — Plan Enrichment

Deepen a plan with Forge Gaze — topic-aware agent matching that selects the best specialists for each section:

/rune:forge plans/my-plan.md
/rune:forge plans/my-plan.md --exhaustive  # Lower threshold, more agents

/rune:goldmask — Impact Analysis

Three-layer analysis: Impact (what changes), Wisdom (why it was written that way), Lore (how risky the area is):

/rune:goldmask                # Analyze current diff

/rune:inspect — Gap Audit

Compares a plan against its implementation across 10 quality dimensions:

/rune:inspect plans/my-plan.md
/rune:inspect plans/my-plan.md --focus "auth module"

/rune:elicit — Structured Reasoning

24 curated methods for structured thinking: Tree of Thoughts, Pre-mortem Analysis, Red Team vs Blue Team, 5 Whys, ADR, and more.

/rune:elicit

---

Agents

116 specialized agents (74 core + 42 extended in registry):

Review Agents

Core reviewers active in every /rune:appraise and /rune:audit run. UX and design reviewers (below) are conditionally activated for frontend files. Stack specialists are additionally auto-activated based on detected tech stack:

| Agent | Focus | |-------|-------| | Ward Sentinel | Security (OWASP Top 10, auth, secrets) | | Pattern Seer | Cross-cutting consistency (naming, error handling, API design) | | Flaw Hunter | Logic bugs (null handling, race conditions, silent failures) | | Ember Oracle | Performance (N+1 queries, algorithmic complexity) | | Depth Seer | Missing logic (error handling gaps, state machine incompleteness) | | Void Analyzer | Incomplete implementations (TODOs, stubs, placeholders) | | Wraith Finder | Dead code (unused exports, orphaned files, unwired DI) | | Phantom Warden | Phantom implementations (spec-to-code gaps, dead specs, unenforced rules) | | Tide Watcher | Async/concurrency (waterfall awaits, race conditions) | | Forge Keeper | Data integrity (migration safety, transaction boundaries) | | Trial Oracle | Test quality (TDD compliance, assertion quality) | | Simplicity Warden | Over-engineering (YAGNI violations, premature abstractions) | | Rune Architect | Architecture (layer boundaries, SOLID, dependency direction) | | Mimic Detector | Code duplication (DRY violations) | | Blight Seer | Design

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: vinhnxv
• Source: vinhnxv/rune
• License: MIT

Install and usage instructions live in the source repository linked above.