What is Symphony
Symphony is an open-source agent orchestration system by OpenAI that supports turning project work into isolated autonomous tasks. Symphony can monitor boards such as Linear and automatically schedule agents to complete the entire process from coding and testing to merging PRs, providing work evidence such as CI status, code review, and demo videos. Engineers do not need to supervise coding details, only manage task acceptance at a higher level. Symphony is currently an experimental engineering preview, built on Elixir, and licensed under Apache-2.0.
Symphony's Main Features
- Board Monitoring: Listens in real time to task changes in project management tools such as Linear, automatically capturing requirements and triggering workflows.
- Intelligent Scheduling: Dynamically generates dedicated Agents based on task type, assigning end-to-end code implementation work.
- Automated Testing: After the Agent completes development, it automatically runs the test suite and generates CI status reports to ensure code quality.
- Code Review: Supports automatic static analysis and complexity assessment, producing review feedback and improvement suggestions.
- Deliverable Outcomes: Supports generating complete work evidence including feature demo videos, test reports, and build artifacts.
- Safe Merging: After engineer review and approval, the system automatically merges code changes safely into the main branch.
Symphony's Technical Principles
- Task Isolation Architecture: Symphony uses sandboxed runtime environments, with each task executed in an independent container, ensuring that different Agents do not interfere with each other while preventing accidental damage to the main codebase. The isolation mechanism provides a secure foundation for automated workflows.
- Event-Driven Orchestration: The system triggers workflows by listening to webhook events from platforms such as Linear, using a state machine to manage the task lifecycle, forming a closed loop from creation, assignment, execution, review, to merging, achieving truly unattended automation.
- Multi-Agent Collaboration Mechanism: Symphony does not rely on a single Agent, but dynamically assigns specialized agents based on task type (frontend, backend, testing, etc.). Each Agent exchanges context information through standardized interfaces, forming a collaboration chain to complete complex requirements.
- Verifiable Delivery System: Each task output must include executable objective evidence, including passing test cases, static analysis reports, build artifacts, and demo recordings. The "proof-first" design ensures that automation does not sacrifice code quality.
Symphony's Project Address
- GitHub Repository：https://github.com/openai/symphony
Symphony's Application Scenarios
- Agile Development Teams: Suitable for teams using modern project management tools such as Linear, automatically converting board tasks into deliverable code, reducing manual assignment and follow-up costs.
- Standardized Code Maintenance: Supports handling repetitive engineering tasks such as dependency upgrades, refactoring, and documentation completion, maintaining codebase health through automation.
- Rapid Prototype Validation: Directly converts product requirements into runnable demo versions, accelerating the iteration cycle from idea to prototype.
- Multi-Project Parallel Management: Simultaneously monitors task flows across multiple code repositories, coordinating the development pace of different projects and avoiding resource conflicts.
- Overnight Automated Operations: Execute batch tasks during non-working hours, such as test fixes and security patch applications, and provide a complete report the next day for review.