Skip to content
/
Tier A A6 Multi-agent orchestrator

Symphony (sincover)

symphony-sincover · sincover/Symphony · ★ 260 · last commit 2025-04-20

12-role musical-metaphor hierarchy (Composer→Score→Conductor→Performer) for Roo Code, with three automation levels, Mermaid visualization, and append-only communication logs.

Best whenSoftware development teams need a musical conductor model — hierarchical specialization with explicit delegation protocols, not flat autonomous agents.
Skip ifProceeding without checking automation level, Files over 500 lines
vs seeds
bmad-method(12 named persona agents, hierarchical specialization, file-based state) but targets Roo Code instead of Claude Code, sh…
Primitive shape 13 total
Subagents 13
00

Summary

Symphony (sincover) — Summary

Symphony by sincover is a Roo Code multi-agent software development framework delivered as a .roo/ rules directory and custom_modes.json file. It defines 12 named persona modes (Composer, Score, Conductor, Performer, Checker, Researcher, Integrator, Security Specialist, DevOps, Dynamic Solver, UX Designer, Version Controller) — each a Roo Code custom mode with a roleDefinition and four rule files (01-role, 02-rules, 03-user-commands, 04-coding-principles). The orchestration metaphor is a musical hierarchy: Composer creates vision → Score does strategic planning → Conductor breaks into tasks → Performer implements → Checker verifies. The framework uses Roo Code's new_task tool for inter-agent delegation. It supports three automation levels (Low/Medium/High) that control how independently agents operate without human approval. Compared to seeds: closest to BMAD-METHOD in using named persona files as agents and a hierarchical specialization structure, but Symphony-sincover is Roo Code-specific (not Claude Code), uses a richer musical metaphor with 12 roles vs BMAD's 6, and ships explicit sequential-execution task management with Mermaid visualization as a first-class artifact.

01

Overview

Symphony (sincover) — Overview

Origin

Created by sincover. GitHub: https://github.com/sincover/Symphony. No license file. Version 0.2. Roo Code framework. 260 stars.

Philosophy

From the README:

"Symphony is a sophisticated multi-agent software development framework designed to orchestrate AI agents in a structured, efficient workflow. Inspired by the coordination of a musical orchestra, Symphony enables specialized AI agents to collaborate on complex software projects through well-defined roles, communication protocols, and file structures."

Core values:

  • Structure: every artifact has a defined location in symphony-[project-slug]/
  • Traceability: every step is documented (work logs, team logs, test reports)
  • Controlled automation: three automation levels (Low/Medium/High)

Agent metaphor

The musical orchestra metaphor maps to a software development team:

  • Composer — CTO/architect defining vision and architecture
  • Score — Technical program manager breaking vision into goals
  • Conductor — Engineering manager breaking goals into tasks
  • Performer — Individual contributor implementing tasks
  • Checker — QA engineer verifying implementations
  • Researcher — Technical researcher providing domain knowledge
  • Integrator — Integration engineer ensuring components work together
  • Security Specialist — Security engineer reviewing for threats
  • DevOps — Infrastructure/deployment engineer
  • Dynamic Solver — Complex problem-solver for blockers
  • UX Designer — UI/UX designer
  • Version Controller — Release/versioning manager

Automation levels

  • Low: explicit human approval for delegation and user commands
  • Medium: allows delegation but requires approval for user commands
  • High: permits autonomous delegation and user command execution

Key characteristic

Sequential execution focus — all task ordering is dependency-based and sequential within a goal. The README explicitly notes this as a known limitation.

02

Architecture

Symphony (sincover) — Architecture

Distribution

  • Zero install — drop .roo/ into workspace, copy custom_modes.json to Roo Code config
  • Prerequisites: Roo Code IDE

Directory structure

.roo/
  rules-symphony-composer/
    01-role.md
    02-rules.md
    03-user-commands.md
    04-coding-principles.md
    groups.json
  rules-symphony-score/         (same structure)
  rules-symphony-conductor/     (same structure)
  rules-symphony-performer/     (same structure)
  rules-symphony-checker/       (same structure)
  rules-symphony-integrator/    (same structure)
  rules-symphony-devops/        (same structure)
  rules-symphony-security-specialist/
  rules-symphony-ux-designer/
  rules-symphony-version-controller/
  rules-symphony-researcher/
  rules-symphony-dynamic-solver/
  rules-enhanced-recursive-engineer/

custom_modes.json              # Roo Code mode definitions

Project artifact structure (created during workflow)

symphony-[project-slug]/
  core/                  # core configuration
  specs/                 # project specifications + architecture
  planning/              # strategic goals + planning artifacts
  tasks/                 # task breakdowns + assignments
  logs/                  # work logs + progress tracking
  communication/         # agent interaction records
  testing/               # test plans + results
  security/              # security requirements + reviews
  integration/           # integration specs + tests
  research/              # research reports
  design/                # UX/UI design artifacts
  knowledge/             # knowledge base
  documentation/         # project documentation
  version-control/       # version control strategies
  handoffs/              # continuity documents for context limits

Config

  • custom_modes.json — Roo Code mode definitions with roleDefinition per agent
  • .roo/rules-*/groups.json — tool group permissions per mode

Target AI tools

Roo Code exclusively. This is a single-IDE framework.

03

Components

Symphony (sincover) — Components

Agent modes (12)

Mode Role
symphony-composer Visionary architect — project vision, architecture, client alignment
symphony-score Strategic planner — breaks vision into goals, coordinates conductors
symphony-conductor Tactical manager — transforms goals into tasks, coordinates performers
symphony-performer Implementation specialist — executes tasks, writes code
symphony-checker QA expert — verifies implementations, creates test plans
symphony-researcher Knowledge specialist — deep technical research
symphony-integrator Integration expert — ensures components work together
symphony-security-specialist Security expert — threat modeling, code review
symphony-devops Infrastructure — deployment pipelines, environments
symphony-dynamic-solver Complex analytical problem-solver
symphony-ux-designer UX/UI design specialist
symphony-version-controller Code versioning, release management

Plus one additional mode:

  • enhanced-recursive-engineer — recursive self-improving engineer (bonus mode)

Per-mode rule files (4 per mode)

Each mode directory contains:

  • 01-role.md — single-sentence role definition
  • 02-rules.md — detailed behavioral rules (20-50 lines)
  • 03-user-commands.md — slash commands available to user
  • 04-coding-principles.md — code quality rules (< 500 lines, modularity, low coupling)
  • groups.json — Roo Code tool group permissions (read, edit, browser, command, mcp)

User commands (per mode, examples)

Score commands: /status, /project-map, /goal-breakdown, /assign, /risk-analysis Conductor commands: /task-list, /task-details, /sequence-plan, /blockers, /progress-report Performer commands: /work-log, /implementation-plan, /self-test, /code-details, /documentation Checker commands: /test-plan, /test-results, /issues, /run-test-case, /security-scan Security commands: /threat-model, /security-requirements, /code-review, /vulnerability-scan, /risk-assessment

Communication mechanism

new_task — Roo Code's task delegation tool. Used by all agents to delegate to sub-agents. /continue — user command to handle context window limits via handoff documents.

05

Prompts

Symphony (sincover) — Prompt Excerpts

Excerpt 1: Composer role (01-role.md)

Source: .roo/rules-symphony-composer/01-role.md

You are the Symphony Composer, the visionary architect agent. You create the initial project
vision, establish core architectural decisions, define the crucial `symphony-core.md` file,
generate initial architecture diagrams, and ensure business/technical alignment. You initiate
the project workflow by delegating strategic planning to Symphony Score.

Prompting technique: Single-sentence persona establishment with delegation mandate. The role definition ends with an explicit next-step delegation trigger ("initiate by delegating to Symphony Score"), creating a forced handoff that bootstraps the multi-agent chain.

Excerpt 2: Conductor task delegation rules (02-rules.md excerpt)

Source: .roo/rules-symphony-conductor/02-rules.md

5. **Assign Tasks Sequentially:**
   * **CRITICAL:** Check automation level in `symphony-core.md`.
   * Identify the first task(s) with no unmet dependencies.
   * Use `new_task` to delegate the task to the appropriate specialist:
       * `symphony-performer` (implementation)
       * `symphony-ux-designer` (design elements)
       * `symphony-security-specialist` (security implementation/review)
       * `symphony-devops` (infrastructure tasks)
       * `symphony-version-controller` (complex versioning tasks)
   * Include the full task description, Task-ID, dependencies, and expected deliverables.
     Reinforce coding principles (modularity, file size limits < 500 lines).
   * Update the task status to `Assigned` and `Assigned to` field in `[goal-id]-sheet.md`
     using `apply_diff` or careful `write_to_file`. Verify update.
   * Log the assignment in `[goal-id]-team-log.md` using `append_to_file`. Include Task-ID,
     name, assignee, timestamp.

Prompting technique: Numbered procedural rules with CRITICAL emphasis gates (check automation level before proceeding), explicit tool directives (new_task, apply_diff, append_to_file), and mandatory verification steps after each state mutation. The coding principles (modularity, <500 lines) are injected at delegation time rather than embedded in performer rules.

09

Uniqueness

Symphony (sincover) — Uniqueness & Positioning

Differs from seeds

Closest to BMAD-METHOD in the named-persona hierarchical agent pattern, but with key differences:

  1. 12 roles vs BMAD's 6 — Symphony has more specialized roles (Integrator, Security Specialist, DevOps, Dynamic Solver, UX Designer, Version Controller) mapping more directly to a full software engineering team structure.

  2. Roo Code native (not Claude Code) — uses .roo/ rules directories and Roo Code custom modes instead of BMAD's Claude Code skills. The tool permission system (groups.json with read/edit/browser/command/mcp) is Roo Code-specific.

  3. Three automation levels — Low/Medium/High automation control. BMAD has no equivalent mechanism; it relies on human judgment for when to proceed.

  4. Mermaid visualization as first-class artifact — both goal dependency maps and task execution plans are generated as Mermaid diagrams. No other framework in the corpus makes visualization a mandatory workflow artifact.

  5. Team communication logs — the append-only team-log.md per goal is a structured audit trail of every delegation and completion. BMAD has no equivalent.

Observable failure modes

  • Sequential-only execution limits parallelism for independent tasks
  • Heavy documentation burden may slow down small-scope work
  • Roo Code lock-in — no path to Claude Code or other tools
  • No license file — adoption risk for enterprise use
  • Context window management is manual (requires human /continue intervention)

Competitive positioning

Symphony-sincover targets teams wanting a regimented, fully documented development workflow with clear role separation and an audit trail. The automation level control makes it suitable for organizations needing human oversight at specific checkpoints. The musical metaphor makes the hierarchy intuitive but is cosmetic — the underlying pattern is a standard team management model.

04

Workflow

Symphony (sincover) — Workflow

Seven-phase workflow

Phase Actor Artifact
Vision & Architecture Composer specs/project-specification.md, architecture diagrams
Strategic Planning Score planning/strategic-goals.md, project map visualization
Tactical Management Conductor tasks/[goal-id]/[goal-id]-sheet.md, execution plan
Implementation Performer code files, logs/[task-id]/[task-id]-work-log.md
Quality Assurance Checker testing/[task-id]/[task-id]-test-report.md
Integration Integrator integration/[component]-registry.md
Delivery Composer final architecture review, documentation/

Task lifecycle

Goal assigned → Conductor creates task sheet
→ Tasks assigned sequentially (dependency-ordered)
→ Performer implements + self-verifies
→ Conductor delegates to Checker (CRITICAL: check automation level first)
→ Checker creates test plan, runs tests
→ If PASS: next task unlocked
→ If FAIL: Performer re-assigned with test report feedback + iteration++
→ Goal complete → Score updates project map

Approval gates

Controlled by automation level (low / medium / high):

  • Low: human approval required for every delegation and user command
  • Medium: delegation allowed; user command execution requires approval
  • High: full autonomous delegation and command execution

Mermaid visualization

Conductors generate Mermaid flowchart diagrams for task dependency sequences. Score generates Mermaid graph for goal dependencies with color coding (complete/in-progress/not-started).

Context management

/continue command — when context limits are approached, current agent creates a handoff document in handoffs/ and instructs the user to start a new session pointing to that document.

06

Memory Context

Symphony (sincover) — Memory & Context

State storage

File-based — all state is in the symphony-[project-slug]/ directory tree:

  • core/symphony-core.md — project configuration, automation level, current phase
  • planning/strategic-goals.md — goal definitions and statuses
  • tasks/[goal-id]/[goal-id]-sheet.md — task status, assignments, iteration counts
  • logs/[task-id]/[task-id]-work-log.md — implementation notes
  • communication/[goal-id]/[goal-id]-team-log.md — delegation audit log
  • testing/[task-id]/[task-id]-test-report.md — test results
  • knowledge/ — accumulated knowledge base

Context window management

/continue command + handoffs/ directory: When an agent approaches context limits, it creates a handoff document summarizing:

  • Current phase status
  • Completed tasks
  • Next required actions
  • Open blockers

The user then starts a fresh agent session, loading the handoff document as context.

Persistence scope

project — all files are in the project directory, persisted between sessions.

Cross-agent communication

File-based — agents read task sheets and work logs written by other agents. The Conductor reads the Performer's work log to verify completion. Score reads the project map to update goal status.

Knowledge base

knowledge/ directory accumulates domain research and lessons learned across the project lifecycle. Researcher agent writes here; Performers can reference it.

No memory compaction

Context window management is entirely manual via /continue + handoff documents. No automated compaction.

07

Orchestration

Symphony (sincover) — Orchestration

Pattern

Hierarchical — Composer → Score → Conductor → Performer, with specialist agents (Security, DevOps, Researcher, UX, Version Controller) available as lateral delegates.

Subagent definition format

persona-md — each agent is defined by four markdown files per .roo/rules-* directory:

  • 01-role.md (single sentence)
  • 02-rules.md (numbered behavioral rules)
  • 03-user-commands.md (slash command definitions)
  • 04-coding-principles.md (code quality rules)

Plus groups.json for tool permissions. This is Roo Code's native agent format.

Spawn mechanism

new_task — Roo Code's built-in delegation tool. Conductors use new_task to assign tasks to Performers; Score uses new_task to assign goals to Conductors. All delegation is explicit via this tool.

Isolation mechanism

None — all agents operate on the same file system in the same workspace. Isolation is by convention (each agent writes to its designated directories).

Multi-model

No — single Roo Code session, single LLM. No multi-provider routing.

Execution mode

interactive-loop — user starts with Composer, issues commands, receives results, and drives the workflow by accepting/rejecting delegations based on automation level.

Sequential execution focus

The README explicitly notes sequential task execution as a known limitation:

"Symphony is designed around sequential task execution, which may not be optimal for highly parallel development workflows."

Within a goal, tasks are ordered by dependencies and executed one-at-a-time.

Crash recovery

/continue + handoffs/ — manual recovery when context limits are reached. No automated crash recovery.

08

Ui Cli Surface

Symphony (sincover) — UI & CLI Surface

Entry point

Roo Code IDE custom modes. User selects the appropriate Symphony mode from the mode picker and issues commands via natural language or slash commands.

No CLI binary

No standalone CLI. This is a pure Roo Code framework.

Installation

1. Drop the .roo folder into your workspace
2. Copy the contents of custom_modes.json to your global or project mode configuration
3. Start with the Composer mode

User command surface

All modes support /help, /continue, /escalate, /delegate-to, /request-review, /set-automation.

Score-specific: /status, /project-map, /goal-breakdown, /assign, /risk-analysis Conductor-specific: /task-list, /task-details, /sequence-plan, /blockers, /progress-report Performer-specific: /work-log, /implementation-plan, /self-test, /code-details, /documentation Checker-specific: /test-plan, /test-results, /issues, /run-test-case, /security-scan Security-specific: /threat-model, /security-requirements, /code-review, /vulnerability-scan Integrator-specific: /integration-map, /integration-status, /integration-details, /verify-flow Researcher-specific: /research, /search, /compare, /recommend, /literature-review

Project visualization

Score's /project-map generates Mermaid graph diagrams showing goal dependency and status. Conductor's task execution plan includes Mermaid flowcharts for task dependency visualization.

Observability

Team communication logs in communication/[goal-id]/[goal-id]-team-log.md — append-only audit trail of all agent delegations, assignments, and completions with timestamps.

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…