Rune

Multi-agent engineering orchestration for Claude Code.

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

Install

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

Restart Claude Code after installation.

Local development

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

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/",
    ".claude/arc/",
    ".claude/echoes/",
    ".claude/arc-batch-loop.local.md",
    ".claude/CLAUDE.local.md",
    ".claude/talisman.yml"
  ]
}

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

Quick Configuration (Optional)

Generate a talisman.yml tailored to your project's tech stack:

/rune:talisman init      # Auto-detect stack and generate .claude/talisman.yml
/rune:talisman audit     # Check existing config for missing/outdated sections
/rune:talisman status    # Overview of current configuration health

See the Talisman deep dive for all 21 configuration sections.

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: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-batch plans/*.md
/rune:tarnished arc-issues --label "rune:ready"

# 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
`/rune:devise`	Turn ideas into structured plans with parallel research	up to 7
`/rune:strive`	Execute plans with self-organizing swarm workers	2-6
`/rune:appraise`	Multi-agent code review on your diff	up to 8
`/rune:audit`	Full codebase audit with specialized reviewers	up to 8
`/rune:arc`	End-to-end pipeline: plan → work → review → test → ship	varies
`/rune:mend`	Parallel resolution of review findings	1-5
`/rune:forge`	Deepen a plan with topic-aware research enrichment	3-12
`/rune:goldmask`	Impact analysis — what breaks if you change this?	8
`/rune:inspect`	Plan-vs-implementation gap audit (9 dimensions)	4
`/rune:elicit`	Structured reasoning (Tree of Thoughts, Pre-mortem, 5 Whys)	0

Batch & Automation

Command	What it does
`/rune:arc-batch`	Run `/rune:arc` across multiple plans sequentially
`/rune:arc-issues`	Fetch GitHub issues by label, generate plans, run arc for each
`/rune:arc-hierarchy`	Execute hierarchical parent/child plan decompositions

Utilities

Command	What it does
`/rune:rest`	Clean up `tmp/` artifacts from completed workflows
`/rune:echoes`	Manage persistent agent memory (show, prune, reset)
`/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

Workflow Details

`/rune:devise` — Planning

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

Brainstorm — structured exploration with elicitation methods
Research — parallel agents scan your repo, git history, echoes, and external docs
Solution Arena — competing approaches evaluated on weighted dimensions
Synthesize — consolidate findings into a plan document
Predictive Goldmask — risk scoring for files the plan will touch
Forge — topic-aware enrichment by specialist agents
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 18 phases:

Forge → Plan Review → Refinement → Verification → Semantic Verification
  → Work → Gap Analysis → Codex Gap Analysis → Gap Remediation
  → Goldmask Verification → Code Review → Goldmask Correlation
  → Mend → Verify Mend → Test → Pre-Ship Validation → Ship → 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.

`/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 9 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

89 specialized agents across 6 categories:

Review Agents (40)

Core reviewers that participate in /rune:appraise and /rune:audit:

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)
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 anti-patterns (God Service, leaky abstractions)
Refactor Guardian	Refactoring completeness (orphaned callers, broken imports)
Reference Validator	Import paths and config reference correctness
Phantom Checker	Dynamic references (getattr, decorators, string dispatch)
Naming Intent Analyzer	Name-behavior mismatches
Type Warden	Type safety (mypy strict, modern Python idioms)
Doubt Seer	Cross-agent claim verification
Assumption Slayer	Premise validation (solving the right problem?)
Reality Arbiter	Production viability (works in isolation vs. real conditions)
Entropy Prophet	Long-term consequence prediction
Schema Drift Detector	Schema drift between migrations and ORM/model definitions
Agent Parity Reviewer	Agent-native parity, orphan features, context starvation
Senior Engineer Reviewer	Persona-based senior engineer review, production thinking

Stack Specialists (auto-activated by detected tech stack):

Agent	Stack
Python Reviewer	Python 3.10+ (type hints, async, Result patterns)
TypeScript Reviewer	Strict TypeScript (discriminated unions, exhaustive matching)
Rust Reviewer	Rust (ownership, unsafe, tokio)
PHP Reviewer	PHP 8.1+ (type declarations, enums, readonly)
FastAPI Reviewer	FastAPI (Pydantic, IDOR, dependency injection)
Django Reviewer	Django + DRF (ORM, CSRF, admin, migrations)
Laravel Reviewer	Laravel (Eloquent, Blade, middleware, gates)
SQLAlchemy Reviewer	SQLAlchemy (async sessions, N+1, eager loading)
TDD Compliance Reviewer	TDD practices (test-first, coverage, assertion quality)
DDD Reviewer	Domain-Driven Design (aggregates, bounded contexts)
DI Reviewer	Dependency Injection (scope, circular deps, service locator)
Design Implementation Reviewer	Design-to-code fidelity (tokens, layout, responsive, a11y, variants)

Investigation Agents (24)

Used by /rune:goldmask, /rune:inspect, and /rune:audit --deep:

Category	Agents
Impact Tracers	API Contract, Business Logic, Data Layer, Config Dependency, Event Message
Quality Inspectors	Grace Warden, Ruin Prophet, Sight Oracle, Vigil Keeper
Deep Analysis	Breach Hunter, Decay Tracer, Decree Auditor, Ember Seer, Fringe Watcher, Order Auditor, Rot Seeker, Ruin Watcher, Signal Watcher, Strand Tracer, Truth Seeker
Synthesis	Goldmask Coordinator, Lore Analyst, Wisdom Sage

Research Agents (5)

Agent	Purpose
Repo Surveyor	Codebase structure and pattern analysis
Echo Reader	Surfaces relevant past learnings from Rune Echoes
Git Miner	Git archaeology — commit history, contributors, code evolution
Lore Scholar	Framework docs via Context7 MCP + web search fallback
Practice Seeker	External best practices and industry patterns

Work Agents (4)

Agent	Purpose
Rune Smith	TDD-driven code implementation
Trial Forger	Test generation following project patterns
Design Sync Agent	Figma extraction and Visual Spec Map creation
Design Iterator	Iterative design refinement (screenshot-analyze-fix loop)

Utility Agents (11)

Agent	Purpose
Runebinder	Aggregates multi-agent review outputs into TOME
Mend Fixer	Applies targeted code fixes for review findings
Elicitation Sage	Structured reasoning method execution
Scroll Reviewer	Document quality review
Flow Seer	Feature spec analysis for completeness
Decree Arbiter	Technical soundness validation
Knowledge Keeper	Documentation coverage review
Horizon Sage	Strategic depth assessment
Veil Piercer	Plan reality-gap analysis
Truthseer Validator	Audit coverage quality validation
Deployment Verifier	Deployment artifact generation (Go/No-Go checklists, rollback plans)

Testing Agents (4)

Agent	Purpose
Unit Test Runner	Diff-scoped unit test execution
Integration Test Runner	API, database, and business logic tests
E2E Browser Tester	Browser automation via agent-browser CLI
Test Failure Analyst	Root cause analysis of test failures

Skills

41 skills providing background knowledge, workflow orchestration, and tool integration:

Skill	Type	Purpose
`devise`	Workflow	Multi-agent planning pipeline
`strive`	Workflow	Swarm work execution
`appraise`	Workflow	Multi-agent code review
`audit`	Workflow	Full codebase audit
`arc`	Workflow	End-to-end pipeline orchestration
`arc-batch`	Workflow	Sequential batch arc execution
`arc-hierarchy`	Workflow	Hierarchical plan execution
`arc-issues`	Workflow	GitHub Issues-driven batch arc
`forge`	Workflow	Plan enrichment with Forge Gaze
`goldmask`	Workflow	Cross-layer impact analysis
`inspect`	Workflow	Plan-vs-implementation gap audit
`mend`	Workflow	Parallel finding resolution
`elicitation`	Reasoning	24 structured reasoning methods
`roundtable-circle`	Orchestration	Review/audit 7-phase lifecycle
`rune-orchestration`	Orchestration	Core coordination patterns
`context-weaving`	Orchestration	Context overflow prevention
`rune-echoes`	Memory	5-tier persistent agent memory
`stacks`	Intelligence	Stack-aware detection and routing
`frontend-design-patterns`	Intelligence	Design-to-code patterns (tokens, a11y, responsive, components)
`design-sync`	Workflow	Figma design sync (extraction, implementation, fidelity review)
`inner-flame`	Quality	Universal self-review protocol
`ash-guide`	Reference	Agent invocation guide
`tarnished`	Routing	Unified entry point — natural language to workflow
`using-rune`	Reference	Workflow discovery and routing
`codex-cli`	Integration	Cross-model verification
`testing`	Testing	3-tier test orchestration
`agent-browser`	Testing	E2E browser automation knowledge
`systematic-debugging`	Debugging	4-phase debugging methodology
`file-todos`	Tracking	Structured file-based todos
`git-worktree`	Isolation	Worktree-based parallel execution
`polling-guard`	Reliability	Monitoring loop fidelity
`zsh-compat`	Compatibility	macOS zsh shell safety
`chome-pattern`	Compatibility	Multi-account config resolution
`resolve-gh-pr-comment`	Workflow	Resolve a single GitHub PR review comment
`resolve-all-gh-pr-comments`	Workflow	Batch resolve all open PR review comments
`skill-testing`	Development	TDD for skill development
`talisman`	Configuration	Deep talisman.yml management (init, audit, update, guide, status)

Configuration

Rune is configured via talisman.yml (21 top-level sections, 100+ keys):

# Project-level (highest priority)
.claude/talisman.yml

# User-global
~/.claude/talisman.yml

Quickest way to configure: Run /rune:talisman init to auto-detect your stack and generate a tailored config.

Example configuration

version: 1

# File classification — decides which Ashes get summoned
rune-gaze:
  backend_extensions: [.py]
  skip_patterns: ["**/migrations/**", "**/__pycache__/**"]

# Work execution
work:
  ward_commands: ["ruff check .", "mypy .", "pytest --tb=short -q"]
  max_workers: 3

# Arc pipeline
arc:
  timeouts:
    forge: 900000               # 15 min
    work: 2100000               # 35 min
    code_review: 900000         # 15 min
  ship:
    auto_pr: true
    merge_strategy: "squash"

# Review settings
review:
  diff_scope:
    enabled: true
    expansion: 8

# Goldmask impact analysis
goldmask:
  enabled: true
  devise:
    depth: enhanced             # basic | enhanced | full

# Cross-model verification
codex:
  enabled: true
  workflows: [devise, arc, appraise]

# Custom Ashes
ashes:
  custom:
    - name: "my-reviewer"
      agent: "my-custom-agent"
      source: ".claude/agents/my-custom-agent.md"

See talisman.example.yml for the full schema with all options.

Architecture

rune-plugin/
├── .claude-plugin/
│   └── marketplace.json          # Marketplace registry
└── plugins/
    └── rune/                     # Main plugin
        ├── .claude-plugin/
        │   └── plugin.json       # Plugin manifest (v1.113.2)
        ├── agents/               # 89 agent definitions
        │   ├── review/           #   40 review agents
        │   ├── investigation/    #   24 investigation agents
        │   ├── utility/          #   11 utility agents
        │   ├── research/         #    5 research agents
        │   ├── testing/          #    4 testing agents
        │   └── work/             #    4 work agents
        ├── skills/               # 41 skills
        ├── commands/             # 14 slash commands
        ├── hooks/                # Event-driven hooks
        │   └── hooks.json
        ├── scripts/              # Hook scripts (20+)
        ├── .mcp.json             # MCP server config (echo-search)
        ├── talisman.example.yml  # Configuration reference
        ├── CLAUDE.md             # Plugin instructions
        ├── CHANGELOG.md
        └── README.md             # Detailed component reference

Key Concepts

Term	Meaning
Tarnished	The orchestrator/lead agent that coordinates workflows
Ash	Any teammate agent (reviewer, worker, researcher)
TOME	Aggregated findings document from a review
Talisman	Configuration file (`talisman.yml`)
Forge Gaze	Topic-aware agent matching for plan enrichment
Rune Echoes	5-tier persistent agent memory (`.claude/echoes/`)
Inscription	Contract file (`inscription.json`) for agent coordination
Seal	Deterministic completion marker emitted by Ashes

Requirements

Claude Code with plugin support
Claude Max ($200/month) or higher recommended

Warning

Rune is token-intensive. Each workflow spawns multiple agents with their own dedicated context windows. A single /rune:arc run can consume a significant portion of your weekly usage. Use --dry-run where available to preview scope before committing.

Links

Detailed component reference — all agents, skills, commands, hooks
Rune user guide (English): arc + arc-batch — operational guide with greenfield/brownfield use cases
Hướng dẫn Rune (Tiếng Việt): arc + arc-batch — hướng dẫn vận hành kèm use case greenfield/brownfield
Rune planning guide (English): devise + forge + plan-review + inspect — how to write and validate plan files correctly
Hướng dẫn planning Rune (Tiếng Việt): devise + forge + plan-review + inspect — cách lập plan và review plan đúng chuẩn
Rune code review and audit guide (English): appraise + audit + mend — multi-agent review, codebase audit, and finding resolution
Hướng dẫn review và audit Rune (Tiếng Việt): appraise + audit + mend — review đa agent, audit codebase, và xử lý finding
Rune work execution guide (English): strive + goldmask — swarm implementation and impact analysis
Hướng dẫn thực thi Rune (Tiếng Việt): strive + goldmask — implementation swarm và phân tích tác động
Rune advanced workflows guide (English): arc-hierarchy + arc-issues + echoes — hierarchical execution, GitHub Issues batch, and agent memory
Hướng dẫn workflow nâng cao Rune (Tiếng Việt): arc-hierarchy + arc-issues + echoes — thực thi phân cấp, batch GitHub Issues, và bộ nhớ agent
Rune getting started guide (English) — quick start for first-time users
Hướng dẫn bắt đầu nhanh Rune (Tiếng Việt) — hướng dẫn nhanh cho người mới
Rune talisman deep dive (English) — master all 21 configuration sections
Hướng dẫn talisman chuyên sâu Rune (Tiếng Việt) — làm chủ 21 section cấu hình
Rune custom agents and extensions (English) — build custom Ashes, CLI-backed reviewers, Forge Gaze integration
Hướng dẫn custom agent và mở rộng Rune (Tiếng Việt) — xây dựng custom Ash, CLI reviewer, tích hợp Forge Gaze
Rune troubleshooting and optimization (English) — debug failures, reduce token cost, tune performance
Hướng dẫn xử lý sự cố và tối ưu Rune (Tiếng Việt) — chẩn đoán lỗi, giảm token, tối ưu hiệu suất
Rune engineering solutions (English) — 30 unique solutions across 200+ commits
Giải pháp kỹ thuật Rune (Tiếng Việt) — 30 giải pháp đặc biệt qua hơn 200 commits
Changelog — release history
Configuration guide — full talisman schema

License

MIT

Name		Name	Last commit message	Last commit date
Latest commit History 247 Commits
.claude-plugin		.claude-plugin
.claude		.claude
docs		docs
plugins/rune		plugins/rune
tests		tests
.codexignore		.codexignore
.gitattributes		.gitattributes
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md

License

vinhnxv/rune-plugin

Folders and files

Latest commit

History

Repository files navigation

Rune

Install

Setup

Quick Configuration (Optional)

How It Works

Workflows

Quick Start (New Users)

/rune:tarnished — The Unified Entry Point

Core Commands

Batch & Automation

Utilities

Workflow Details

/rune:devise — Planning

/rune:arc — End-to-End Pipeline

/rune:strive — Swarm Execution

/rune:appraise — Code Review

/rune:audit — Codebase Audit

/rune:mend — Fix Findings

/rune:forge — Plan Enrichment

/rune:goldmask — Impact Analysis

/rune:inspect — Gap Audit

/rune:elicit — Structured Reasoning

Agents

Review Agents (40)

Investigation Agents (24)

Research Agents (5)

Work Agents (4)

Utility Agents (11)

Testing Agents (4)

Skills

Configuration

Architecture

Key Concepts

Requirements

Links

License

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 2

Packages 0

Uh oh!

Contributors 3

Uh oh!

Languages

`/rune:tarnished` — The Unified Entry Point

`/rune:devise` — Planning

`/rune:arc` — End-to-End Pipeline

`/rune:strive` — Swarm Execution

`/rune:appraise` — Code Review

`/rune:audit` — Codebase Audit

`/rune:mend` — Fix Findings

`/rune:forge` — Plan Enrichment

`/rune:goldmask` — Impact Analysis

`/rune:inspect` — Gap Audit

`/rune:elicit` — Structured Reasoning

Packages