Noureddine RAMDI / Symphony: orchestrating autonomous coding agents with work-level management

Created Sun, 03 May 2026 11:08:03 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
867 Words
github-stars elixir autonomous-agents agent-orchestration harness-engineering spec-driven

openai/symphony

Symphony takes a different approach to AI-assisted software development. Instead of supervising individual coding agents directly, it manages the work that needs to be done at a higher level of abstraction. This means monitoring tasks on a work board, spawning autonomous agents to tackle those tasks, and validating their outputs through multiple proof-of-work signals before merging any changes.

Symphony’s approach to autonomous agent orchestration

Symphony is an experimental framework developed by OpenAI, written in Elixir, designed to transform project work into isolated, autonomous implementation runs. Unlike traditional AI coding assistants that focus on individual code generation or completion, Symphony operates at the level of work management. It integrates with work boards such as Linear to monitor ongoing tasks and automatically spawns agents to address these tasks.

Its architecture revolves around a spec-driven approach detailed in a SPEC.md file, enabling teams to implement Symphony in any language by following this specification. The reference implementation in Elixir is tailored for codebases that have already embraced harness engineering — a methodology for managing agent work in isolated environments.

Symphony’s core concept is an “agent-of-agents” pattern. It orchestrates multiple autonomous agents, each responsible for discrete tasks, while overseeing the overall workflow. The system validates outputs using diverse signals: continuous integration (CI) status, pull request (PR) reviews, code complexity analysis, and walkthrough videos. Only when these quality gates are passed does Symphony allow merging of changes, ensuring a higher level of trust and stability.

What distinguishes Symphony technically

What sets Symphony apart is its high-level orchestration of agents rather than direct interaction with individual coding assistants. This abstraction introduces several tradeoffs:

  • Higher trust and quality control: By validating agent outputs through CI, PR reviews, and other signals, Symphony enforces quality gates that reduce the risk of faulty code being merged.

  • Dependency on harness engineering: Symphony assumes a codebase and team already using harness engineering. This prerequisite focuses the tool on environments prepared for isolated, autonomous implementation runs.

  • Spec-driven design: The framework defines a language-agnostic specification (SPEC.md) that allows flexible implementation across different languages, although the current production-ready implementation is Elixir-based.

  • Complexity in orchestration: Managing agents as work units and coordinating validations requires a sophisticated control plane, increasing system complexity compared to simpler agent frameworks.

Under the hood, the codebase is clean and modular, making use of Elixir’s strengths in concurrency and fault tolerance. The choice of Elixir aligns well with the need to manage multiple autonomous agents concurrently and reliably.

The tradeoff is clear: Symphony is not a plug-and-play AI coding assistant but a framework intended for teams ready to adopt a higher-level approach to agent orchestration with robust quality assurance.

Explore the project

The Symphony repo includes a SPEC.md file which is central to understanding its architecture and how to implement it. This spec-driven approach means that even if you don’t use the Elixir reference implementation, you can adapt Symphony principles to your language or stack.

The README highlights that Symphony is designed for codebases adopting harness engineering, which is a prerequisite for effective use.

Key documentation to review:

  • SPEC.md: details the specification driving Symphony’s architecture and agent orchestration logic.
  • README.md: provides the conceptual overview and context around Symphony’s goals and design.

Since there is no explicit installation or quickstart guide, the best way to explore Symphony is to start by reading the SPEC.md to understand the contract agents and orchestrators must follow. From there, reviewing the Elixir implementation can provide practical insights into how the spec manifests in code.

The repo’s modular structure and clear separation of concerns make it approachable for experienced Elixir developers or teams interested in spec-driven autonomous agent orchestration.

Verdict

Symphony represents a thoughtful shift in AI-assisted coding workflows from supervising individual agents to managing work units with quality validation. Its spec-driven, harness engineering-based approach offers a path to more reliable autonomous coding in complex projects.

However, it is currently an experimental, low-key engineering preview intended for trusted environments with teams already familiar with harness engineering. It’s not suited for quick adoption or casual experimentation.

If your team is exploring agent orchestration at a project level and is comfortable with Elixir or spec-driven frameworks, Symphony offers a valuable reference implementation and architectural blueprint. Otherwise, this repo serves as an interesting example of the direction agent orchestration can take rather than a ready-to-use tool out of the box.

→ GitHub Repo: openai/symphony ⭐ 20,853 · Elixir