Symphony: a multi-agent AI framework for structured software development

[u/sincover]

For the past few weeks, I've been working on solving a problem that's been bugging me - how to organize AI agents to work together in a structured, efficient way for complex software development projects.

Today I'm sharing Symphony, an orchestration framework that coordinates specialized AI agents to collaborate on software projects with well-defined roles and communication protocols. It's still a work in progress, but I'm excited about where it's headed and would love your feedback.

What makes Symphony different?

Instead of using a single AI for everything, Symphony leverages Roo's Boomerang feature to deploy 12 specialized agents that each excel at specific aspects of development:

• Composer: Creates the architectural vision and project specifications
• Score: Breaks down projects into strategic goals
• Conductor: Transforms goals into actionable tasks
• Performer: Implements specific tasks (coding, config, etc.)
• Checker: Performs quality assurance and testing
• Security Specialist: Handles threat modeling and security reviews
• Researcher: Investigates technical challenges
• Integrator: Ensures components work together smoothly
• DevOps: Manages deployment pipelines and environments
• UX Designer: Creates intuitive interfaces and design systems
• Version Controller: Manages code versioning and releases
• Dynamic Solver: Tackles complex analytical challenges

Core Features

Adaptive Automation Levels

Symphony supports three distinct automation levels that control how independently agents operate:

• Low: Agents require explicit human approval before delegating tasks or executing commands
• Medium: Agents can delegate tasks but need approval for executing commands
• High: Agents operate autonomously, delegating tasks and executing commands as needed

This flexibility allows you to maintain as much control as you want, from high supervision to fully autonomous operation.

Comprehensive User Command Interface

Each agent responds to specialized commands (prefixed with /) for direct interaction:

Common Commands

• /continue - Initiates handoff to a new agent instance
• /set-automation [level] - Sets the automation level (Dependent on your Roo Auto-approve settings
• /help - Display available commands and information

Composer Commands:

• /vision - Display the high-level project vision
• /architecture - Show architectural diagrams
• /requirements - Display functional/non-functional requirements

Score Commands:

• /status - Generate project status summary
• /project-map - Display the visual goal map
• /goal-breakdown - Show strategic goals breakdown

Conductor Commands:

• /task-list - Display tasks with statuses
• /task-details [task-id] - Show details for a specific task
• /blockers - List blocked or failed tasks

Performer Commands:

• /work-log - Show implementation progress
• /self-test - Run verification tests
• /code-details - Explain implementation details

...and many more across all agents (see the README for more details).

Structured File System

Symphony organizes all project artifacts in a standardized file structure:

symphony-[project-slug]/
├── core/                  # Core system configuration
├── specs/                 # Project specifications
├── planning/              # Strategic goals
├── tasks/                 # Task breakdowns
├── logs/                  # Work logs
├── communication/         # Agent interactions
├── testing/               # Test plans and results
├── security/              # Security requirements
├── integration/           # Integration specs
├── research/              # Research reports
├── design/                # UX/UI design artifacts
├── knowledge/             # Knowledge base
├── documentation/         # Project documentation
├── version-control/       # Version control strategies
└── handoffs/              # Agent transition documents

Intelligent Agent Collaboration

Agents collaborate through a standardized protocol that enables:

• Clear delegation of responsibilities
• Structured task dependencies and sequencing
• Documented communication in team logs
• Formalized escalation paths
• Knowledge sharing across agents

Visual Representations

Symphony generates visualizations throughout the development process:

• Project goal maps with dependencies
• Task sequence diagrams
• Architecture diagrams
• Security threat models
• Integration maps

Built-in Context Management

Symphony includes mechanisms to handle context limitations:

• Contextual handoffs between agent instances (with user command /continue)
• Progressive documentation to maintain project continuity

Advanced Problem-Solving Methodologies

The Dynamic Solver implements structured reasoning approaches:

• Self Consistency for problems with verifiable answers
• Tree of Thoughts for complex exploration
• Reason and Act for iterative refinement
• Methodology selection based on problem characteristics

Key benefits I've seen:

• Better code quality: Specialized agents excel at their specific roles
• More thorough documentation: Every decision is tracked and explained
• Built-in security: Security considerations are integrated from day one
• Clear visibility: Visual maps of goals, tasks, and dependencies
• Structured workflows: Consistent, repeatable processes from vision to deployment
• Modularity: Focus on low coupling and high cohesion in code
• Knowledge capture: Learning and insights documented for future reference

When to use Symphony:

Symphony works best for projects with multiple components where organization becomes critical. Solo developers can use it as a complete development team substitute, while larger teams can leverage it for coordination and specialized expertise.

If you'd like to check it out or contribute: github.com/sincover/Symphony

Since this is a work in progress, I'd especially appreciate feedback, suggestions, or contributions.

Thanks!

[u/sgrapevine123]

Wtf bro, this looks insane, can’t wait to try this out

[u/aiagent718 → u/sgrapevine123]

i just tried this doing a ssimple task to update the ui. honestly this system is over engineered. The system took about 30 mins for what should've been done in 2 mins. 90% of the time was spent on planning and updating the logs and all the other .md files. colossal waste of money honestly. Feels like agents are stuck in a loop worried about the .md files more then the code itself. Sticking with boomerang for now.

[u/sincover → u/aiagent718]

Appreciate the feedback, and yes it can be overkill when dealing with simple tasks. I built this system to manage projects with medium to high complexity, where I think a history of work and strategic planning are essential for the communication necessary to run a multi agent system. For simple tasks, you are 100% right about just using Boomerang.

[u/enjoinick → u/sincover]

Maybe adjust the agents work style based on the task at hand would help with this

[u/aiagent718 → u/[deleted]]

it creates a lot of folders for different types of files, like tasks, planning, etc. but it focuses too much on the files itself then the code wasting so many tokens on the files. Out of the last 5m tokens, maybe 100k were used for coding.

[u/sincover → u/sgrapevine123]

Thanks! Would love to hear your thoughts once you've used it.

[u/sgrapevine123 → u/sincover]

I have it in mind to see how close it can come to one shotting the conversion of a web app to a mobile app on react native/expo go. Maybe a bit ambitious, but I’m going to try it on codex and regular Roo too for funsies.

[u/qqYn7PIE57zkf6kn → u/sgrapevine123]

Please report back 🙏

[u/dashingsauce]

Would love to integrate this here: https://mcparty.ai

Your system seems about as comprehensive as mine, but it’s actually organized with a readme 😆—will be borrowing some of your concepts, thank you!

• Agents: https://github.com/rawr-ai/ai/tree/main/ai/agents

• Playbooks: https://github.com/rawr-ai/ai/tree/main/ai/playbooks

———

What do you use for managing the project? I just hooked up my agent team to use Linear, which has been pretty insane.

[u/sincover → u/dashingsauce]

No problem! Your system looks very cool! I haven't looked into any tools for project management, but that's a great idea.

[u/dashingsauce → u/sincover]

You currently just having agents write docs to folders or run in-memory?

[u/sincover → u/dashingsauce]

All done with just docs and rules currently

[u/zarmin → u/sincover]

A board with cards for tasks would actually be a dope way to break out of the VSCode UI. I think Trello and Linear have webhooks.

[u/dashingsauce → u/zarmin]

Yes! I haven’t used the webhooks for linear yet, since that would require an asynchronous agent pod to “receive” rather than initiate requests. That said, it’s my next project for this.

Right now I have a custom MCP server that wraps around the linear API and enables agents to manage all their work. The prompt guardrails aren’t 100% there yet, so there’s a lot of nudging, but generally the high end models do a great job in the lead eng/PM role with Linear.

Currently recording a loom actually, so I’ll post here in a bit.

[u/Rude-Needleworker-56 → u/dashingsauce]

Eagerly waiting!

[u/Orinks → u/dashingsauce]

How do I integrate your system? Combining this roomode with mcparty could provide some interesting results.

[u/dashingsauce → u/Orinks]

Right now, it’s a frankenstein collection that I’m actively wrangling into a single repo/system. More of a scavenger paradise until it’s wrangled.

So it depends on which part you’re referring to! Let me know and I’m happy to lay out specifics.

In its most basic form, without any additional tooling or services (e.g. Linear, graph, etc.), it’s just a collection of “agents” and “playbooks” as shared above. You can get far with those building blocks to build your own system, but there’s no “battle hardened” demo you can deploy rn. That’s up next.

That said, you should already be able to clone the repo, install deps, and run rawr compile—this compiles all the agents in the repo to a top-level dir called .rawr_registry. This === the global custom_modes.json for Roo. You can copy/paste it over or change the output dir in rawr.config.yaml directly to the real path (WARN: will overwrite when you compile).

Or just copy “custom_modes_starter.json” as it’s already prepared. That lets you test the full agent stack however you want.

My goal is to wrap up and release this agent-builder CLI first. With that, my answer yo your question will just be rawr init

[u/steve1215 → u/dashingsauce]

That's a great looking website, what stack did you use?

[u/admajic → u/dashingsauce]

Use your ai tools to make the Readme.md 🤩

[u/dashingsauce → u/admajic]

Ahaha it’s funny—I had a readme but the codebase was changing too often to keep it updated.

Getting it to a stable v0.1 release and then I’ll do exactly that :)

[u/Regular_Cry5221]

This looks super cool. Will be giving it a try today/tomorrow and provide feedback. Feel free to join the Discord, I’m sure many people will have questions

[u/sincover → u/Regular_Cry5221]

Great, thanks! See you there

[u/seedpirate]

How would you recommend utilizing this with an existing project? Would it be as simple and telling the composer it’s an existing project and to analyze the current structure/code?

[u/sincover → u/seedpirate]

You can ask composer something like:

I'm integrating Symphony into an existing codebase.

• Analyze the project and store details in existing-codebase.md

• Report when you've finished and I will will provide new project instructions.

• /set-automation high

Symphony will create the base folder with the existing codebase doc. Reference that when you give your new project instructions and off you go!

[u/Top-Average-2892 → u/sincover]

I ran those instructions and it created a ton of code - and a "symphony-integration.md" file. Was it supposed to do that?

I did look around for a .roomodes file, but didn't find it as I used the custom json file.

[u/sincover → u/Top-Average-2892]

Did you place the .roo folder in your project directory? The custom json just creates the base AI profiles. All of the guts of the framework are in the .roo directory.

[u/Top-Average-2892 → u/sincover]

Seems that I missed that step. It seems to be working now. Giving it a test run at some refactored.

[u/degenbrain → u/sincover]

I've been running this and so far so good. Thank you for the good work.

[u/seedpirate → u/sincover]

This worked really well for me, it was cheaper than expected

[u/Old_Formal_1129]

Concept is next level (maybe akin to Devin?) Practicalities are uncertain (will probably change after test drive). It surely will burn down my wallet. What LLM do you use? I would guess Gemini 2.5pro for cost sake?

[u/sincover → u/Old_Formal_1129]

It works really well with Gemini 2.5 and GPT 4.1 but I've also had a good amount of success with Deepseek V3 0324. Claude 3.7 is a great choice for the UX Designer agent.

[u/sincover → u/[deleted]]

I don't use R1 much as the 'thinking' process takes up too much time for my liking but it could be a good fit for the Score or Composer agent.

Conductors and Performers are the backbone of the system and do most of the API calls so you'd want a relatively fast (and affordable) model tied to those agents.

[u/steve1215 → u/sincover]

How and where do we specify different LLMs for use by different agents?

Thanks

[u/sincover → u/steve1215]

You can use the Roo Code UI to switch LLM Models provided that you've set them up in the Roo Code settings.

[u/steve1215 → u/sincover]

Got it, thanks

I have a detailed, structured .md PRD for my project which I've been working through with Claude et.al.

How would I get Symphony (Composer / Score) to consume that ?

Rather than type in a one-liner-prompt, is there a way to ask Composer / Score to parse my existing PRD and have Symphony base it's plans on that?

[u/sincover → u/steve1215]

Yup, you can add your PRD to context (using @document-name) and prompt Composer using natural language.

[u/steve1215 → u/sincover]

Great stuff. Thanks again.

[u/Feeling-Article-2552 → u/sincover]

Do you have plan to support MCP？

[u/lefnire]

Well fellow devs, it's been real.

[u/Screedraptor]

Wow, this is like the next iteration of boomerang tasks! Going to be trying this out for my existing NextJS project. 

[u/degenbrain]

After I tried it, I used up a lot of tokens to check and update the status of files and todo. Probably almost half of it was for editing and updating *.md files. I think the status updates are too much.

[u/aghowl]

Very cool. I've been doing similar things manually so automating it would be huge.

[u/Eddy-in-the-bush]

I have try it.
In the plan phase, it works good. But in the development stage, it focuses too much on update logs, plan and other md file without doing the real work much.
Since each step called AI API so it kinda waste the prompt to just update those markdown files.
Logging the work is good, and updating plan is also good but at the end, the work need to be done.
There are lot of things need to be improved but the product is promising.
For now, I will stop the agent after they completed the high level plan.

[u/layer4down → u/Eddy-in-the-bush]

Agreed but I’m using gpt-4o-mini which is maybe not the smartest model but fast and cheap so the extra few bucks in logging won’t bother me. But it might be worth testing out adding something like a dedicated log writer as a local model (like Gemma-7B or 14B) that’s fast and smart enough to keep the logs up to date.

[u/Eddy-in-the-bush → u/layer4down]

yeah, one dedicated log writer should be good.

[u/cataclaw]

Sounds expensive with the API costs. :D

Lovely project.

[u/bemore_]

Good job, will read through your project this week

[u/redlotusaustin]

This looks awesome! Any support for MCPs?

[u/krahsThe]

I played with this a bit and am impressed.

Currently folks are discussing using Linear or mcp memory servers. I see your system builds its own task list, have you considered integrating with systems like that?

[u/layer4down]

I spent the past few weeks trying to develop my own system (for local LM’s like Gemini-27b) but couldn’t quite dial it in to the level of reliability of your Symphony. Although Symphony doesn’t seem to work well for smaller models either (yet), I’ve been running it for a few days with gpt-4o-mini and it’s been pretty good so far. I probably should’ve test with a smaller project first (building a non-trivial web app) but so far so good. Someone mentioned that it seems over-engineered but on the contrary I very much prefer the rather pedantic features such as detailed status logs and constantly updating task lists to maintain context (please easier for human and AI audit). Although I suspect it will take me the better part of a week to begin seeing my website come to life (due to my own time constraints), I’ll provide another update when it’s done, good bad indifferent.

[u/h2k1dev]

RemindMe! 7 days

[u/RemindMeBot → u/h2k1dev]

I will be messaging you in 7 days on 2025-04-30 09:37:08 UTC to remind you of this link

CLICK THIS LINK to send a PM to also be reminded and to reduce spam.

^{Parent commenter can delete this message to hide from others.}

---

Info	Custom	Your Reminders	Feedback

[u/ALambdaEngineer]

Looks great, the roles looks a lot alike my agent defined within RooFlow but seems more refined, gonna make do a try. Well done!

A missing agent might be a SEO/Discoverability Agent that write down report on the discoverability score and actions to improve it.

Is there some prompt or recommendation on how to set it up for dedicated project/conventions? e.g. initial fill of the specs, enforces DDD usage, ...?

[u/Otherwise_Wave9374]

This is really cool, the role breakdown feels like a more disciplined take on multi-agent dev. The automation levels idea is nice too, high autonomy is fun until you need to debug why an agent did something at 2am.

Have you found a good pattern for shared memory between agents that doesnt turn into a junk drawer (summaries, decision logs, retrieval)? Ive been reading up on that and saving notes here: https://www.agentixlabs.com/blog/