AI-Native Workspace
Symphony Workspace
Autonomous Issue Orchestration
An AI-native orchestration workspace that turns tracker issues into isolated implementation runs. Symphony lets teams manage work at the queue level while agents produce code, proof-of-work, and safe review handoffs.
Linear
Tracker entry point
Per-Issue
Workspace isolation
Live
Operator observability
Run Preview
Linear issue to safe handoff
Stage 1
Queue Intake
Linear issues are claimed on a bounded cadence, not by ad hoc chasing.
Stage 2
Scoped Workspace
Each issue gets its own runtime, files, hooks, and state contract.
Stage 3
Agent Execution
An LLM-powered agent runs inside the workspace until it reaches a defined handoff state.
Stage 4
Reviewable Handoff
Proof-of-work packages make review visible, fast, and grounded.
Issue state, retry state, and agent state stay visible together
Proof-of-work artifacts travel with the run instead of being reconstructed later
Human review happens at the policy edge, not every turn of execution
Operators manage queue health instead of babysitting individual sessions
Design thesis
Move project management closer to runtime reality.
Symphony replaces status theater with observable execution: queue state, workspace state, run state, and review state all stay in one operational frame.
01
Problem
Most engineering overhead is still coordination: planning, status updates, handoffs, and reviews exist because humans have to translate intent across roles. Agent tools can write code, but teams still need a reliable way to dispatch issues, isolate execution, track progress, collect evidence, and land changes without supervising every turn.
Coordination Tax
PRDs, planning, status updates, and handoffs consume too much of the engineering loop before code ever ships.
Ticket Tools Stop Too Early
Traditional trackers know the issue state, but not the real execution state of the agent, workspace, run, and evidence trail.
Supervision Does Not Scale
If every coding agent still needs a human sitting next to it, the bottleneck only moves instead of disappearing.
02
Orchestration Flow
The core product bet is that when execution can be delegated to agents, the workspace should stop optimizing for handoffs and start optimizing for observable runs.
Legacy loop
Coordination-heavy delivery
Step 1
Write PRD
Step 2
Sprint planning
Step 3
Status sync
Step 4
Human handoff
Step 5
Review chase
with operational state
Symphony
Execution-native workspace
Step 1
Poll Linear
Step 2
Create issue workspace
Step 3
Launch model run
Step 4
Collect proof of work
Step 5
Route to Human Review
Step 6
Land safely
What changes
The visible unit of work becomes the run itself, not the meeting cadence around it.
Why it matters
Reviewers inherit evidence and state, so judgment scales better than supervision.
Operations dashboard preview
Inspired by the real observability surfaces in Symphony: running sessions, retry queue, runtime, and token usage.
Running
8
active issue sessions
Retrying
2
backoff queue
Tokens
148K
in/out across runs
Runtime
6h 12m
aggregate active time
| Issue | State | Runtime | Last update |
|---|---|---|---|
| SYM-143 | Human Review | 42m · 7 turns | Validation green, walkthrough uploaded |
| SYM-146 | In Progress | 17m · 3 turns | Reviewing failing CI and retry schedule |
| SYM-151 | Merging | 8m · 1 turn | Approved by human, land workflow active |
03
Workspace Model
Built Symphony as a long-running orchestration service. It polls Linear for eligible work, creates a workspace per issue, launches an LLM-powered agent runner inside that workspace, feeds a repository-owned WORKFLOW.md contract, and keeps the run moving until it reaches a workflow-defined handoff such as Human Review or Merging. Observability surfaces active sessions, retry pressure, runtime, and token usage so operators can manage the queue with confidence.
Tracker Intake
Symphony continuously reads eligible Linear issues on a bounded cadence and decides what can run now.
Per-Issue Workspace
Every issue gets an isolated working directory so runs stay scoped and deterministic.
Workflow Contract
A repository-owned WORKFLOW.md defines runtime settings, prompts, states, hooks, and quality gates.
Agent Runner
The model runner executes inside the workspace until the issue reaches a defined handoff state.
Observability Surface
Operators see active sessions, retries, runtime, token usage, and issue-level status without inspecting each agent manually.
04
Proof of Work
What the agent hands back
Symphony is designed to make runs reviewable, not mysterious.
CI status and validation output
PR review sweep and reviewer feedback
Complexity analysis for the changed work
Walkthrough videos for human reviewers
Explicit Human Review and Merging handoffs
What remains distinctly human
The value shifts upward: less translation work, more judgment and system design.
Vision: deciding what work matters and why
Architecture: shaping the system so agents can execute safely
Care: defining the quality bar, review bar, and handoff bar
Systems design: reducing coordination overhead by moving intent closer to execution
05
Outcomes
Outcome 1
Turned issue execution into repeatable autonomous runs instead of one-off agent sessions
Outcome 2
Kept execution policy in-repo through a versioned WORKFLOW.md contract
Outcome 3
Produced proof-of-work artifacts including CI status, PR feedback, complexity analysis, and walkthroughs
Outcome 4
Used per-issue workspaces and bounded concurrency to operate multiple runs safely
Outcome 5
Gave operators a live dashboard for active sessions, retries, runtime, and token usage
06