Orchestra

A desktop app for running coding agents side by side in workspace-based terminal sessions.
Download · Website

• Any agent: Claude Code, Codex, OpenCode, Pi, Mistral Vibe, Antigravity CLI, Grok Build, Cline, omp, Kilo, Muse Code, Cursor CLI, GitHub Copilot CLI, Aider, Goose, Qwen Code, Kiro CLI, Factory Droid, Kimi Code CLI, Amp, or a plain shell, each in its own session. See agent support for CLI requirements and limitations.
• Workspaces: group the repositories you work on together, such as an app, its website and its docs. Each session works in one of them.
• Worktrees: every session can run in its own Git worktree and branch, so agents don't step on each other.
• Sessions talk to each other: agents send requests between sessions and share a workspace Scratchpad through the orchestra CLI. Nothing is typed into a terminal unless you choose to.
• Work Items, Reviews and diffs: browse the issues (Work Items) and pull requests (Reviews) of every GitHub repository in a workspace, start a session from one, and review each session's branch changes, including uncommitted edits.
• Page layout: Settings, Work Items, Reviews, Automations and Scratchpad use a centered column with Settings-style spacing. Turn on Settings → Appearance → Full Width Pages to use the wider layout.
• Automations: schedule an agent and prompt once or on selected weekdays from the global Automations menu. Choose a workspace, repository and time; Orchestra must be open. Missed occurrences run once when the app reopens. Every run creates a normal session. Create or open an automation on its own page, with a breadcrumb back to Automations. Switch between Configuration and Runs to edit its settings, view persistent run history, open a linked session, inspect the original prompt or clear the records without deleting sessions. History records launch results, not agent task completion; deleted sessions leave their run records intact. Earlier versions contribute only the last known run, with its original configuration unavailable.
• Files: switch the right sidebar between Changes and Files, browse the session's repository or worktree, and open files in the sidebar to read syntax-highlighted code in the central view.

Install

Download the latest release:

• macOS 13 or later: Orchestra-macos-universal.dmg (Apple silicon and Intel), or with Homebrew: brew install --cask theorchestradev/tap/orchestra.
• Linux x86_64: Orchestra-…-linux-x86_64.tar.gz. Needs GTK 3 and WebKitGTK 4.1 (libgtk-3-0 libwebkit2gtk-4.1-0 on Ubuntu 22.04 or later). The optional attention sound also needs GStreamer's good plugins (gstreamer1.0-plugins-good).

Orchestra updates itself from GitHub Releases when you ask it to.

Install the CLI of each agent you want to use and make sure it is on your shell's PATH. For the GitHub views, install the GitHub CLI and run gh auth login.

Use

1. Add a workspace from an existing folder. Add more repositories from the workspace's Add Repository… menu item or in Edit Workspace.
2. Add a session, choose its repository and an agent. Create a new worktree is on by default and puts the session on a new branch under ~/.orchestra/worktrees/.
3. When you close the session, Remove the worktree deletes a clean checkout and keeps any branch with unmerged commits.

To use more than one Claude Code, Codex or Cursor account, add a profile in Settings → Profiles and choose Log In for each agent. Orchestra keeps a separate config folder for each profile under ~/.orchestra/profiles/ (through the CLI's config-folder variables), so a profile starts without your usual CLI settings, MCP servers and skills; Settings → Profiles offers to install the Orchestra Skill when a profile is missing it. A workspace chooses the profile its new sessions use, and the New Session dialog can choose another.

The Orchestra Skill lets agents in different sessions talk to each other: they send requests and share the workspace Scratchpad through the orchestra CLI. Install it from Settings → Agents → Orchestra Skill, or run:

npx skills add https://github.com/theorchestradev/orchestra --skill orchestra -g

Build from source

Requires Go, Node.js and the Wails CLI v2.16.0 or later (go install github.com/wailsapp/wails/v2/cmd/[email protected]), plus the Xcode command line tools on macOS or these packages on Ubuntu:

sudo apt install build-essential pkg-config libgtk-3-dev libwebkit2gtk-4.1-dev

npm --prefix frontend ci
wails dev                # on Linux: wails dev -tags webkit2_41
make build               # build/bin/Orchestra.app, or build/bin/orchestra on Linux
make demo                # build and open an isolated demo of this worktree
make demo DEMO_LAUNCH=0   # build and package the demo without opening it

make demo also requires Python 3. It builds the current worktree, including uncommitted changes, with development build information and no release telemetry or updater. On macOS it creates build/bin/demo/Orchestra Demo - <worktree>.app with its own bundle identifier; on Linux it creates build/bin/demo/orchestra-demo. Open that bundle or launcher to reopen the demo: its launcher always selects the isolated environment.

Each worktree keeps its own demo state under /tmp/orchestra-demo-<uid>-<worktree-hash>. Preferences, themes, logs, session hosts, CLI configuration, caches and sample Git repositories stay there. Rebuilding preserves that state; the operating system may clear it with other temporary files. Run python3 scripts/DemoSmoke.py to verify the launcher isolation and fixture persistence. Quit the demo and stop its background sessions before rebuilding. To start fresh, remove only the printed demo data directory after closing the demo.

The demo uses the real app and native bridge with simulated agent CLIs, GitHub data and skill installs. It starts with a clean environment and a separate home directory; it does not copy your workspaces, settings, themes or credentials. Subscription usage and model queries may show unavailable because no account is connected. This is data isolation, not an OS sandbox: opening real folders or external applications still accesses those resources. Use the sample repositories for disposable validation.

Pushing a SemVer tag such as v0.2.0 runs the release workflow, which publishes signed builds.

Contributors

Made with contrib.rocks.

Contributing

Read AGENTS.md for the conventions and the checks to run before opening a pull request. Tests never send prompts to agent services or touch your agent settings.

Privacy

Usage sharing is off until you opt in. Privacy & usage data lists every event and how to disable it.

License

MIT

Manage sessions from the CLI

From an Orchestra terminal session, create, rename or close a session:

orchestra session create --agent codex --model gpt-6.1-sol --name "Review" --prompt "Review the repository"
orchestra session rename SESSION_ID --name "Code review" [--workspace ID_OR_NAME]
orchestra session close SESSION_ID [--workspace ID_OR_NAME]

--workspace ID_OR_NAME selects another workspace by ID or exact, case-sensitive name. Ambiguous names require an ID; unknown workspaces fail. This option applies to session creation, renaming and closing; inbox, requests, session list and Scratchpad keep their original scope. session close stops the process and removes the session, preserving its worktree. Without --repository, the same workspace inherits the calling session's repository; another workspace uses the last New Session repository, or the first available.

--model and --effort choose how the agent launches, and --prompt-file PATH or --stdin can supply the prompt instead. --repository ID chooses another repository in that workspace, and --worktree, with optional --branch and --base, gives the session its own branch and folder. A repeated --request-id returns the same session. The command returns session JSON and saves the prompt without starting an agent. Open the session to start it, or turn on Let Agents Start Sessions in Settings so --start can start it, with up to 5 such sessions running per workspace. Automations use the same Store session creation flow and start the scheduled session through TerminalSession while the app is open.

Manage automations from the CLI

From an Orchestra terminal session with the app open:

orchestra automation create --name "Monday review" --agent codex --prompt "Review this repository" --days mon --time 09:00 --timezone America/Sao_Paulo
orchestra automation list
orchestra automation show AUTOMATION_ID
orchestra automation update AUTOMATION_ID --prompt-file ./review.txt --model gpt-6.1-sol
orchestra automation enable AUTOMATION_ID
orchestra automation disable AUTOMATION_ID
orchestra automation run AUTOMATION_ID
orchestra automation delete AUTOMATION_ID

Automations are global and shared with the app UI. Creation is disabled by default; add --enabled only when scheduling is requested. Agents should create, activate or run automations only at the user's request. All commands return JSON through the existing authenticated app connection; the CLI never launches an agent directly.

Creation inherits the calling session's workspace and repository. --workspace ID_OR_NAME selects a workspace by ID or exact, unambiguous name; a different workspace uses its default repository. --repository ID selects a repository in that workspace. list returns all automations, optionally filtered by --workspace. Other commands target stable automation IDs globally. Updates preserve omitted fields, including model/effort, and can change the repository within the saved workspace.

Schedules use --time HH:MM with --days daily or comma-separated weekdays (sun,mon,tue,wed,thu,fri,sat). One-time schedules use --date YYYY-MM-DD; when updating a recurring automation, also pass --days once. The timezone defaults to UTC; use --timezone with an IANA name to select another zone. Invalid zones, times and dates are rejected. Enabling a one-time schedule requires a future time. Prompts accept exactly one of --prompt TEXT, --prompt-file PATH or --stdin. update also accepts --enabled or --disabled. run executes once through the app's normal automation path without changing its enabled state or next scheduled run. The app owns scheduling, persistence and session processes; it must remain open.