Skip to content
This repository was archived by the owner on Jun 26, 2026. It is now read-only.
BranchesTags

Repository files navigation

Rune

Multi-agent engineering orchestration for Claude Code.

Built on Discipline Engineering — 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.

Claude Code Version License: MIT 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.

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 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 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 Turn ideas into structured plans with parallel research up to 7 10–30 min
/rune:strive Execute plans with self-organizing swarm workers 2-6 10–30 min
/rune:appraise Multi-agent code review on your diff up to 8 5–20 min
/rune: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 End-to-end pipeline: plan → work → review → test → ship varies 1–3 hours
/rune:mend Parallel resolution of review findings 1-5 3–10 min
/rune:forge Deepen a plan with topic-aware research enrichment 3-12 5–15 min
/rune:goldmask Impact analysis — what breaks if you change this? 8 5–10 min
/rune:inspect Plan-vs-implementation gap audit (10 dimensions) 4 5–10 min
/rune: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 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 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
Cross-Shard Sentinel Cross-shard consistency for Inscription Sharding (naming drift, pattern inconsistency, auth boundary gaps)
Shard Reviewer Universal sharded review — all dimensions for assigned file subset
Sediment Detector Feature sediment detection (dead code paths, unused config)

UX & Design Reviewers (conditionally activated for frontend files):

Agent Focus
Aesthetic Quality Reviewer Visual quality beyond pixel-perfect fidelity (AI slop detection, generic layouts)
UX Flow Validator User flow completeness (loading, error, empty states, confirmations)
UX Cognitive Walker First-time user cognitive walkthrough (discoverability, learnability)

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)
Axum Reviewer Axum/SQLx (extractor ordering, N+1 queries, IDOR, transaction boundaries)
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)

Investigation Agents

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 (+ inspect, plan-review variants), Ruin Prophet (+ inspect, plan-review), Sight Oracle (+ inspect, plan-review), Vigil Keeper (+ inspect, plan-review)
Deep Analysis Breach Hunter, Decay Tracer, Decree Auditor, Ember Seer, Fringe Watcher, Hypothesis Investigator, Order Auditor, Rot Seeker, Ruin Watcher, Signal Watcher, Strand Tracer, Truth Seeker
Synthesis Goldmask Coordinator, Lore Analyst, Wisdom Sage

Research Agents

Agent Purpose
Repo Surveyor Codebase structure and pattern analysis
Context Builder Block-by-block trust-boundary, invariant, and state-flow mapping for audits
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
Activation Pathfinder Maps activation path for new code (migrations, config, deployment)
Wiring Cartographer Maps integration points where new code connects to existing system

Work Agents

Agent Purpose
Rune Smith TDD-driven code implementation
Trial Forger Test generation following project patterns
Gap Fixer Automated remediation of inspection gaps from VERDICT.md
Blind Verifier Independent acceptance-criteria verification (no anchoring on diff/worker output)
Micro Evaluator Lightweight per-task quality evaluation (Haiku model)

Utility Agents

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
State Weaver Plan state machine validation (phases, transitions, I/O contracts)
Veil Piercer Plan reality-gap analysis
Veil Piercer (Plan) Plan-level reality-gap analysis and assumption validation
Evidence Verifier Factual claim validation with grounding scores
Research Verifier Research output quality verification
Finding Verifier Classifies TOME findings as TRUE_POSITIVE / FALSE_POSITIVE / NEEDS_CONTEXT before mend
Forge Warden Multi-perspective backend code review for forge enrichment
Verdict Binder Inspection aggregator — merges Inspector findings into VERDICT.md

Testing Agents

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
Extended Test Runner Extended-tier test execution with checkpoint/resume protocol
Contract Validator API contract validation (request/response schemas)

QA Agents

Agent Purpose
Phase QA Verifier Single parametric verifier for arc phase completion artifacts. Phase-specific behavior comes from injected manifest checklists (qa-manifests/{phase}.yaml) — replaces the per-phase QA agents collapsed in v3.0.0-alpha.2

Meta-QA Agents

Agent Purpose
Prompt Linter Lints agent definition files for consistency (15 rules)
Workflow Auditor Audits arc workflow definitions for structural integrity
Rule Consistency Auditor Detects contradictions between CLAUDE.md and skills
Hook Integrity Auditor Validates hooks.json entries match actual scripts
Improvement Advisor Generates fix proposals for meta-QA findings
Hallucination Detector Detects phantom claims and evidence fabrication in arc artifacts
Effectiveness Analyzer Per-agent finding accuracy and false-positive tracking
Convergence Analyzer Retry efficiency, quality trajectory, stagnation detection

Skills

44 skills providing background knowledge, workflow orchestration, and tool integration. Source of truth: plugins/rune/CLAUDE.md.

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-quick Workflow Quick 4-phase pipeline: plan → work → review → mend
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
verify Workflow Verify TOME findings before mend (TRUE_POSITIVE/FALSE_POSITIVE classification)
brainstorm Workflow Collaborative idea exploration (solo, roundtable, deep modes)
debug Debugging ACH-based parallel hypothesis debugging
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
resolve-todos Workflow File-based TODO resolution with verify-before-fix pipeline
file-todos Tracking Structured file-based todos
post-findings Workflow Post review findings to GitHub PR as formatted comment
supply-chain-audit Security Dependency risk analysis (maintainer count, CVE history, abandonment)
variant-hunt Analysis Systematic variant analysis — "find more like this" for confirmed findings
pr-guardian Automation Cron-based PR shepherd loop — comments, lint, CI, rebase, migrations, browser test, auto-merge
self-audit Quality Meta-QA self-audit of Rune's own plugin infrastructure
cc-inspect Workflow Run Claude Code built-in inspection script
skill-testing Development TDD for skill development
tarnished Routing Unified entry point — natural language to workflow
using-rune Reference Workflow discovery and routing
status Reporting Background dispatch status reporting
team-status Reporting Active agent team monitoring dashboard
runs Reporting Inspect per-agent structured artifacts from workflow runs
rune-orchestration Orchestration Core coordination patterns (file-based handoff, conflict resolution)
roundtable-circle Orchestration Review/audit 7-phase lifecycle
team-sdk Orchestration Centralized team management SDK (ExecutionEngine, lifecycle)
context-weaving Orchestration Context overflow prevention
discipline Quality Proof-based orchestration discipline for spec compliance
inner-flame Quality Universal self-review protocol
stacks Intelligence Stack-aware detection and routing
systematic-debugging Debugging 4-phase debugging methodology
testing Testing Test orchestration pipeline knowledge for arc test phase
elicitation Reasoning 24 structured reasoning methods
chome-pattern Compatibility Multi-account config resolution
polling-guard Reliability Monitoring loop fidelity
zsh-compat Compatibility macOS zsh shell safety
ash-guide Reference Agent invocation guide
git-worktree Isolation Worktree-based parallel execution

Configuration

Rune v3.x ships with hardcoded defaults — there is no talisman.yml config layer. See plugins/rune/references/v3-defaults.md for the full inventory of baked-in values across arc, audit, devise, gates, goldmask, inspect, integrations, misc, plan, pr_comment, process_management, review, settings, teammate_lifecycle, testing, ux, and work sections.

To deviate from a baked default, use one of the override paths documented in v3-defaults.md:

  1. Per-session env vars — A subset of defaults are env-readable (${VAR:-default} patterns in scripts). Set the env var in .envrc or your shell profile.
  2. Local fork of an agent definition — Custom Ashes are wired in the orchestration layer rather than configured. Place your custom agent at .claude/agents/<name>.md and update the relevant skill's summon list. See custom-ashes.md for the wiring contract.

Migration note for v2.x users: Existing .rune/talisman.yml is silently ignored in v3.x. SessionStart warns once when this file is detected. To restore prior behavior, pin to v2.x in your marketplace.json.

Architecture

rune/
├── .claude-plugin/
│   └── marketplace.json          # Marketplace registry
└── plugins/
    └── rune/                     # Main plugin
        ├── .claude-plugin/
        │   └── plugin.json       # Plugin manifest (see plugin.json for current version)
        ├── agents/               # 74 core agent definitions
        │   ├── investigation/    #   23 investigation agents
        │   ├── utility/          #   16 utility agents
        │   ├── review/           #   13 review agents
        │   ├── meta-qa/          #    9 meta-QA agents
        │   ├── research/         #    7 research agents
        │   ├── work/             #    5 work agents
        │   ├── qa/               #    1 QA verifier (parametric, manifest-driven)
        │   └── shared/           #   13 shared resources (templates, protocols)
        ├── registry/             # 42 extended agents
        ├── skills/               # 44 skills
        ├── commands/             # 11 slash commands
        ├── hooks/                # Event-driven hooks
        │   └── hooks.json
        ├── scripts/              # Hook & utility scripts (256 .sh/.py files)
        ├── .mcp.json             # MCP server config (echo-search, agent-search, context7)
        ├── CLAUDE.md             # Plugin instructions
        ├── CHANGELOG.md
        └── README.md             # Detailed component reference

State Machine Reference

Every Rune workflow is an explicit state machine with named phases, conditional gates, and error recovery tiers. See docs/state-machine.md for mermaid diagrams of all 10 workflows — useful for debugging pipeline failures, understanding phase transitions, and verifying correctness.

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
Forge Gaze Topic-aware agent matching for plan enrichment
Inscription Contract file (inscription.json) for agent coordination
Seal Deterministic completion marker emitted by Ashes
Discipline Engineering The architectural backbone — 5-layer proof-based system ensuring spec compliance over task completion. See full document

Known Gotchas

A few things to know when working with Rune — especially if you're debugging a pipeline failure or writing custom hooks/scripts:

Gotcha Details
macOS bash is 3.2 The system bash on macOS is ancient (3.2). No associative arrays, no readarray, no |&. Rune's enforce-zsh-compat.sh hook auto-fixes 5 common patterns at runtime, but custom scripts must target bash 3.2.
status is read-only in zsh zsh (macOS default shell) treats status as read-only. Using status= in any script will silently fail or crash. Use task_status or tstat instead. Enforced by enforce-zsh-compat.sh.
Hook timeout budget is tight PreToolUse hooks: 5s. Stop hooks: 15s (arc-phase) or 30s (detect-workflow). A slow git or gh call in a hook can cause silent timeout — the hook is killed and the phase loop breaks.
Stop hooks chain in sequence Stop hooks fire in order: arc-phase-stop-hook.sh (inner) → detect-workflow-complete.sh → on-session-stop.sh (outer). A crash in an inner hook breaks all outer hooks. (Batch / hierarchy / issues hooks were removed in v3.0.0-alpha.1.)
SEAL convention for completion Ashes emit <seal>TAG</seal> as their last output line. The on-teammate-idle.sh hook checks for this marker to distinguish "done writing" from "idle mid-task". Missing seals cause premature aggregation.

See the Troubleshooting guide for more operational details.

Requirements & Compatibility

Requirement Minimum Recommended
Claude Code 2.1.81+ Latest
OS macOS 12+, Linux (Ubuntu 20.04+) macOS 14+, Ubuntu 22.04+
Shell bash 3.2+ or zsh 5.0+ zsh (macOS default)
Python 3.11+ (for MCP servers) 3.12+
Node.js 18+ (for Context7 MCP) 20+
jq 1.6+ Latest
git 2.25+ Latest
Claude Plan Pro ($20/mo) for basic use Max ($200/mo) for full Arc pipeline

Windows: Not currently supported. WSL2 with Ubuntu may work but is untested.

Resources Overview

Resource What you'll find
Getting Started First-time walkthrough — plan, work, review in 3 commands
Plugin Component Reference All agents, skills, commands, hooks in detail
Arc & Batch Guide End-to-end pipeline, batch mode, GitHub Issues
v3.x Defaults Catalog Hardcoded defaults reference
Troubleshooting Debugging, cost optimization, common issues
Documentation Hub All guides, English + Vietnamese
State Machines Mermaid diagrams of all 10 workflow state machines
Changelog Release history

Links

License

MIT

About

Rune - Discipline Engineering - Multi-agent engineering orchestration for Claude Code. Plan, work, review, and audit using Agent Teams.

Topics

agentagent-swarmagent-teamagent-teamsagenticagentsclaudeclaude-codeclaude-code-pluginclaude-skillsclaude-swarmdiscipline-engineeringfigmamcpmcp-servermulti-agentorchestrationswarm-intelligenceteammatesuntitledui

Resources

Readme
MIT license

Code of conduct

Code of conduct

Contributing

Contributing
Activity

Stars

6 stars

Watchers

0 watching

Forks

3 forks
Report repository

Releases

Contributors

Languages