Skip to content
/
Tier A A6 Multi-agent orchestrator

Roo Commander (jezweb)

roo-commander · jezweb/roo-commander · ★ 725 · last commit 2025-11-20

Bridge Claude Code's 60+ production-tested skills to Roo Code via an orchestrator mode and CLI skill-discovery tool.

Best whenThe orchestrator should check a skills index before delegating — using documented patterns saves 60-87% tokens over web search + trial-and-error.
Skip ifUsing Roo Commander for simple edits (use Code mode directly), Implementing features in the orchestrator mode (delegate, never implement)
vs seeds
agent-os(markdown scaffold + CLI installer), but adds real hierarchical orchestration via Roo Code's mode system with tool-permi…
Primitive shape 12 total
Commands 9 Subagents 3
00

Summary

Roo Commander — Summary

Roo Commander is a three-component system (CLI tool, custom mode, slash commands) that brings Claude Code's skill library to Roo Code VS Code extension through intelligent orchestration. The core concept is a lightweight "orchestrator mode" that analyzes user requests, searches a skills index for relevant production-tested patterns, and delegates implementation to specialized Roo Code modes (Code, Architect, Debug) with skill-loaded context. The framework ships an npm CLI (roocommander) with five subcommands for skill management and one Roo Code mode (roo-commander), plus 9 custom slash commands for session and project management. By serving as a bridge between Claude Code's documented skills and Roo Code's execution modes, it aims to save 60-87% tokens versus web search and trial-and-error approaches. The project is archived (November 2025) after the broader Roo Code ecosystem evolved.

differs_from_seeds: Most similar to agent-os (Archetype 4 — markdown scaffold that writes markdown), but with an important twist: it ships a real CLI binary (roocommander) that installs and manages the framework rather than relying solely on file-copy. The orchestration model — checking a skills index before delegating to specialized modes — resembles BMAD-METHOD's persona-based delegation, but Roo Commander delegates to IDE-native modes rather than LLM personas. The session management pattern (SESSION.md + git checkpoint) also mirrors agent-os's .agent-os/ state directory concept. Primary target is Roo Code (VS Code extension), making it the only framework in this batch with explicit Roo Code mode integration.

01

Overview

Roo Commander — Overview

Origin

Created by jezweb (GitHub) as v9.5.0. Archived November 2025. Described as a bridge tool to "bring Claude Code's 60+ production-tested skills to Roo Code VS Code extension."

Philosophy

"Think of it like having a virtual, specialized software development team right inside your editor, orchestrated by the 👑 Roo Commander, powered by Roo Code on VS Code"

Core philosophy from the .roomodes definition:

"Your role: Analyze user requests, check the skills index for relevant patterns, then delegate implementation to specialized execution modes (Code, Architect, Debug) with clear instructions that include skill loading commands. You do NOT implement features yourself. You orchestrate by: 1. Understanding the user's request, 2. Checking .roo/rules/01-skills-index.md for relevant skills, 3. Selecting the appropriate mode for execution, 4. Delegating with complete context + skill loading instructions, 5. Tracking completion and summarizing results."

"Philosophy: Skills contain production-tested patterns that save tokens and prevent errors. Always check the skills index before delegating implementation work."

Design Principles

  1. Skill-first: Check for relevant skills before implementing anything
  2. Delegate, don't do: The orchestrator mode never implements — always delegates to Code/Architect/Debug
  3. Token efficiency: Using documented skills saves 60-87% tokens vs web search + trial-and-error
  4. Session continuity: SESSION.md + git checkpoints maintain progress across sessions

When to Use / Not Use (from .roomodes)

"Use when: Starting new features (checks for relevant skills first), Coordinating multi-step workflows, Need automatic skill discovery before implementation" "Don't use when: Simple edits or quick fixes (use Code mode directly), Already know which skill to use (load it and use Code mode)"

v9 Architecture Change

Version 9 (v9.0.0 → v9.5.0) restructured from a content-heavy system to a lightweight orchestrator that delegates to Roo Code's built-in modes, rather than defining its own execution personas.

02

Architecture

Roo Commander — Architecture

Distribution

npm package (roocommander) with a dedicated CLI binary. Published to npm.

Install

# Install CLI
npm install -g roocommander

# Initialize globally (available in all projects)
roocommander init

# OR project-scoped
cd your-project && roocommander init --project

Directory Tree

roo-commander/
├── src/
│   ├── cli.ts                  # CLI entry point
│   ├── index.ts                # Main export
│   ├── commands/               # CLI command handlers
│   │   ├── generate-index.ts
│   │   ├── init.ts
│   │   ├── list.ts
│   │   ├── read.ts
│   │   └── search.ts
│   ├── generator/              # Index generation
│   ├── installer/              # Init/install logic
│   ├── parser/                 # Rule/skill parser
│   └── templates/              # Templates installed by init
│       ├── .roomodes-entry.yaml
│       ├── commands/           # 9 slash command templates
│       ├── rules/              # Rules installed to .roo/rules/
│       │   ├── 02-cli-usage.md
│       │   └── 03-skill-patterns.md
│       └── rules-roo-commander/  # Mode-specific rules
├── .roo/                       # Installed runtime files
│   └── rules/
│       └── 01-skills-index.md  # Generated skills index
├── .roomodes                   # Mode definition (YAML)
├── SESSION.md                  # Session state tracking
├── package.json
└── README.md

Global Install Output (~/.config/Code/...)

When roocommander init runs:

  • Writes .roomodes entry to VS Code's global custom_modes.yaml
  • Copies rules to ~/.roo/rules-roo-commander/

Project Install Output

When roocommander init --project runs:

  • .roo/rules/ — skills index, CLI usage, patterns
  • .roo/rules-roo-commander/ — mode-specific rules
  • .roo/commands/ — 9 slash commands
  • .roomodes — Roo Commander mode entry

Rule File Formats

.roomodes (YAML):

customModes:
  - slug: roo-commander
    name: 🎯 Roo Commander
    roleDefinition: "..."
    whenToUse: "..."
    groups: [read, mcp]

.roo/rules/*.md (Plain markdown): Rules files loaded by Roo Code for the active mode.

.roo/commands/*.md (Plain markdown with YAML front matter): Slash command definitions.

Target AI Tools

Primary: Roo Code VS Code extension

  • Uses Roo Code's .roomodes custom mode system
  • Delegates to Roo Code built-in modes: Code, Architect, Debug
  • Uses Roo Code's .roo/rules/ and .roo/commands/ directories

Required Runtime

  • Node.js (for the CLI)
  • Roo Code VS Code extension
  • VS Code
03

Components

Roo Commander — Components

CLI Binary: roocommander

Subcommand Purpose
roocommander list Show all 60+ skills
roocommander search <keyword> Search skills by keyword
roocommander read <skill-name> Load specific skill content
roocommander generate-index Create/update .roo/rules/01-skills-index.md
roocommander init [--project] Install Roo Commander globally or project-scoped

Mode: Roo Commander (roo-commander)

Defined in .roomodes:

  • Role: Lightweight orchestrator — analyzes requests, checks skills index, delegates to Code/Architect/Debug
  • Tool permissions: read, mcp only (explicitly NOT edit/write)
  • Does NOT implement: Only orchestrates

Slash Commands (9 total)

Session Management

Command File Purpose
/wrap-session commands/wrap-session.md Save SESSION.md progress + create git checkpoint before session end
/continue-session commands/continue-session.md Resume work from SESSION.md state
/list-skills commands/list-skills.md Browse available skills
/load-skill <name> commands/load-skill.md Load and inject specific skill content

Planning

Command File Purpose
/explore-idea commands/explore-idea.md Research and validate project idea
/plan-project commands/plan-project.md Create IMPLEMENTATION_PHASES.md
/plan-feature commands/plan-feature.md Add feature to existing project

Release

Command File Purpose
/github-release <version> commands/github-release.md Create GitHub release
/workflow commands/workflow.md General workflow guidance

Rules Files (Installed to .roo/rules/)

File Purpose
01-skills-index.md Generated index of all available skills (auto-generated by CLI)
02-cli-usage.md How to use roocommander CLI commands
03-skill-patterns.md Patterns for loading and using skills

SESSION.md

Project-root file tracking:

  • Current phase and stage
  • Completed/pending tasks
  • Known issues
  • Last checkpoint hash
  • Next action

Scripts

TypeScript source compiled to dist/ — not user-facing scripts.

05

Prompts

Roo Commander — Prompts

Prompt 1: Roo Commander Mode Definition

From .roomodes:

Technique: Role definition with explicit "do NOT implement" constraint and delegation protocol.

roleDefinition: >
  You are Roo Commander, a lightweight orchestration agent for the Roo Code
  VS Code extension.

  Your role: Analyze user requests, check the skills index for relevant
  patterns, then delegate implementation to specialized execution modes
  (Code, Architect, Debug) with clear instructions that include skill
  loading commands.

  You do NOT implement features yourself. You orchestrate by:
  1. Understanding the user's request
  2. Checking .roo/rules/01-skills-index.md for relevant skills
  3. Selecting the appropriate mode for execution
  4. Delegating with complete context + skill loading instructions
  5. Tracking completion and summarizing results

  Philosophy: Skills contain production-tested patterns that save tokens and
  prevent errors. Always check the skills index before delegating
  implementation work.
whenToUse: Use this mode when starting new features or complex workflows
  where you want automatic skill discovery before delegating to
  implementation modes.

Technique: Explicit "You do NOT implement" constraint paired with a numbered delegation protocol. Tool permissions (groups: [read, mcp]) enforce this — without edit/write permissions, the orchestrator literally cannot write code.

Prompt 2: wrap-session Command

From templates/commands/wrap-session.md:

Technique: Procedural git checkpoint + state management command.

### Step 4: Create Git Checkpoint

1. Confirm changes are ready to commit:
   - No broken functionality
   - Tests pass (if applicable)
   - Changes make sense as a checkpoint

2. Create checkpoint commit:
   git add -A
   git commit -m "checkpoint: [brief description] [timestamp]"

3. Note the commit hash from the output.

### Step 5: Update SESSION.md

Write the updated SESSION.md with:
- Phase status updated
- Progress checklist updated (✅ for completed)
- Verified checkpoint hash
- Clear next action

Technique: Human-readable procedural command that combines git state management with session continuity tracking. The "Define concrete Next Action" requirement (file path + line number) is a structured handoff format that enables reliable session resumption.

Prompt 3: Skill-Discovery Protocol

From templates/rules/02-cli-usage.md (installed to .roo/rules/):

Technique: Rules document that teaches the orchestrator how to use the CLI tools to find skills.

# Roo Commander CLI Usage

Before implementing any feature, check the skills index:

1. Search for relevant skills: `roocommander search <keyword>`
2. Review the index: `.roo/rules/01-skills-index.md`
3. Load relevant skill: `roocommander read <skill-name>`
4. Include skill content in delegation instructions

Technique: Rules-file-as-behavior-protocol. By injecting these rules into the mode's context (via .roo/rules/ directory), the orchestrator's behavior is shaped without modifying the system prompt.

09

Uniqueness

Roo Commander — Uniqueness

differs_from_seeds

Roo Commander most resembles agent-os (Archetype 4 — markdown scaffold) in its file-based, non-code approach to agent behavior, but adds two significant dimensions absent from all seeds: (1) a real CLI binary (roocommander) for skills management that is not merely a file-copy helper, and (2) explicit hierarchical orchestration via Roo Code's mode system with tool-permission enforcement (orchestrator mode has no edit permissions by design). The delegation pattern — "check skills index, select mode, delegate with skill context" — is philosophically similar to BMAD's persona routing but implemented via IDE-native mode switching rather than LLM role prompting. Compared to superpowers (which ships the skills themselves), Roo Commander is a skills discovery and routing layer that assumes skills live elsewhere (Claude Code's skill library). No seed framework bridges two different AI coding tools (Claude Code skills → Roo Code runtime) the way this does.

Positioning

  • Niche: Developers using Roo Code who want access to Claude Code's documented skills library
  • Bridge function: Translates between two ecosystem-incompatible AI coding tools
  • Archived: November 2025; the ecosystem evolved

Observable Failure Modes

  1. External dependency on Claude Code skills: The value proposition requires the user to have Claude Code's skills installed somewhere — this repo alone does not provide the skills content.
  2. Archived status: No longer maintained; Roo Code's ecosystem has evolved.
  3. Soft multi-agent: The "delegation to modes" is a Roo Code UI concept, not true process isolation — if the orchestrator delegates to Code mode and Code mode makes a mistake, there is no rollback mechanism.
  4. Skills index staleness: The 01-skills-index.md must be manually regenerated when skills change. Stale index leads to missed skill recommendations.
  5. Token efficiency claim unverified: The "60-87% token savings" claim is asserted but not measured in any documented benchmark.
04

Workflow

Roo Commander — Workflow

Core Orchestration Flow

User request
    ↓
Roo Commander mode activated
    ↓
Check .roo/rules/01-skills-index.md for relevant skills
    ↓
Select appropriate mode: Code / Architect / Debug
    ↓
Delegate with skill loading instructions
    ↓
Track completion → summarize results

Feature Development Workflow

  1. Explore (optional): /explore-idea — research and validate before committing
  2. Plan: /plan-project → produces IMPLEMENTATION_PHASES.md
  3. Feature planning: /plan-feature — add feature to project
  4. Implementation: delegate to Code mode with skill context
  5. Session end: /wrap-session — saves SESSION.md + git checkpoint
  6. Session resume: /continue-session — loads from SESSION.md

wrap-session Workflow Detail

From commands/wrap-session.md:

  1. Read current SESSION.md from project root
  2. Determine completion status (phase complete vs in-progress vs blocked)
  3. Update progress checklist (mark completed tasks with ✅)
  4. Define concrete "Next Action" with file path + line number
  5. Create git checkpoint commit (git add -A && git commit)
  6. Update SESSION.md with new checkpoint hash

Phase-to-Artifact Map

Phase Artifact
Explore Research notes (in-chat)
Plan IMPLEMENTATION_PHASES.md
Feature Plan feature plan document
Session Save SESSION.md (updated) + git commit

Approval Gates

Gate Type When
Skill discovery confirmation choice-list Before delegation — confirm which skills apply
Mode selection choice-list Which mode to delegate to (Code/Architect/Debug)

Delegation Protocol

Roo Commander does NOT implement. It:

  1. Identifies 1-3 relevant skills from the index
  2. Selects the appropriate mode
  3. Writes delegation instructions with: roocommander read <skill> commands + task description + context
  4. Switches to selected mode with those instructions
06

Memory Context

Roo Commander — Memory & Context

State Storage

File-based, project-scoped.

Primary State File: SESSION.md

Located at project root. Contains:

  • Current phase number and name
  • Current stage (Implementation/Verification/Debugging)
  • Progress checklist (completed ✅ / pending)
  • Known issues
  • Last checkpoint hash (git commit hash)
  • Next action (specific file path + line number + task)

Skills Index: .roo/rules/01-skills-index.md

Generated by roocommander generate-index. Contains a searchable index of all available Claude Code skills with:

  • Skill names
  • Descriptions
  • Keywords for search

Updated by roocommander sync-index when new skills are added.

Planning Artifacts

  • IMPLEMENTATION_PHASES.md — project implementation phases (written by /plan-project)

Persistence

Project-level via SESSION.md + git-tracked files. Cross-session continuity via /continue-session which reads SESSION.md.

Compaction

No explicit compaction. Session state is kept compact in SESSION.md rather than accumulating conversation history.

Cross-Session Handoff

Yes. The SESSION.md + git checkpoint pattern is explicitly designed for this:

  1. /wrap-session saves state + creates checkpoint
  2. /continue-session reads SESSION.md and resumes from exact state

Memory Type Summary

Dimension Value
Memory type file-based
Persistence scope project
State files SESSION.md, IMPLEMENTATION_PHASES.md, .roo/rules/01-skills-index.md
Search mechanism full-text (skills index search via CLI)
Compaction none
07

Orchestration

Roo Commander — Orchestration

Multi-Agent

Yes — in a soft sense. The Roo Commander mode delegates to specialized modes (Code, Architect, Debug). These are not separate agent processes but separate Roo Code mode contexts.

Orchestration Pattern

Hierarchical (commander + workers). The orchestrator never implements — it always delegates to a specialized mode:

Roo Commander (orchestrator)
    ├── → Code mode (implementation)
    ├── → Architect mode (design)
    └── → Debug mode (troubleshooting)

Mode Tool Permissions

The orchestration boundary is enforced by Roo Code's permission system:

Mode Permissions
Roo Commander read, mcp (NO edit/write)
Code read, edit, command, browser, mcp
Architect read, edit
Debug read, edit, command

This is a hard constraint: the orchestrator mode cannot write code because it lacks edit permissions.

Isolation Mechanism

None beyond Roo Code's mode boundaries. No git worktree, no container.

Multi-Model

No. The model is selected globally in Roo Code settings, not per-role.

Execution Mode

Interactive loop. User interacts with Roo Commander, which orchestrates and delegates.

Prompt Chaining

Yes. The delegation instructions include skill content loaded by the CLI, creating a chain: request → skill discovery → delegation prompt with skill context → implementation.

Consensus Mechanism

None.

Summary Table

Dimension Value
Multi-agent yes (mode-based delegation)
Orchestration pattern hierarchical
Max concurrent agents 1 active mode at a time
Isolation none
Consensus none
Prompt chaining yes (skill-enriched delegation)
Multi-model no
Execution mode interactive-loop
Crash recovery yes (SESSION.md + git checkpoint)
08

Ui Cli Surface

Roo Commander — UI / CLI Surface

Dedicated CLI Binary

Yes.

Binary Package Purpose
roocommander roocommander npm package (v9.5.0) Skill management + framework installation

Subcommands:

roocommander list              # Show all 60+ skills
roocommander search <keyword>  # Search by keyword
roocommander read <name>       # Load skill content
roocommander generate-index    # Create skills index
roocommander init [--project]  # Set up Roo Commander

The CLI is a thin wrapper over the installed skills library — it reads skill files and prints them.

Local UI / Dashboard

None dedicated. The UI is Roo Code's built-in VS Code extension interface.

IDE Integration

Primary: Roo Code VS Code extension

Integration surfaces:

  • .roomodes — registers the Roo Commander mode in Roo Code's mode selector (with 👑 crown emoji)
  • .roo/rules/ — rules files loaded by Roo Code for the active mode
  • .roo/commands/ — slash commands available in Roo Code's command palette
  • Global install: ~/.config/Code/.../custom_modes.yaml for availability in all projects

Roo Code Mode Selector

After roocommander init, the 👑 Roo Commander mode appears in Roo Code's mode picker. Users must reload VS Code to see it.

Observability

  • SESSION.md tracks progress and git checkpoint hashes
  • Git commit log serves as implicit audit trail
  • No structured logging

Cross-Tool Portability

Low. The .roomodes format, .roo/rules/ directory, and global mode registration are all Roo Code-specific. The CLI could be used standalone for skill browsing, but the orchestration features require Roo Code.

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k
A6 Multi-agent orchestrator

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k
A6 Multi-agent orchestrator

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k
A6 Multi-agent orchestrator

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k
A6 Multi-agent orchestrator

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k
A6 Multi-agent orchestrator

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k
A6 Multi-agent orchestrator

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…