One Workspace for Your Team’s Coding Agents

AI agents made every engineer faster. Orchestra makes the whole team faster.

Run Claude Code, Codex and more on your machine or in the cloud, all in one place. Shared memory, so every session starts with what your team knows. Coordination, so people and agents stay aligned.

curl -fsSL https://get.orchestrahq.ai | sh
macOS 13 or newer.

Free for individuals. Teams $15 a seat, 14 days free. See pricing

Cloud agents $0.12 an hour while they run, nothing while idle. How cloud agents work

The Orchestra app with demo data: a live Claude Code session on W-226, Rate-limit cloud VM provisioning, running for Arnav Rajashekara with Eashan Vagish in the session. Claude Code has moved the cap check ahead of the VM start, shown as a diff, and the side panel shows the linked issue and a connected decision.

The app, with demo data

Works with the agents you already runClaude CodeCodexGemini CLICursorOpenCode

See It Working in Three Minutes

Recorded on the real product: a team and its agents fixing one bug together.

Hand Work to Agents in the Cloud

Start an agent from any issue. It runs in its own cloud sandbox, opens a pull request when it is done, and your team can watch or steer it live.

Choosing where the agent runs, on a demo repository
  • Back in Under a Second

    A suspended session picks up where it left off in under a second.

  • Its Own Sandbox

    Each session runs in an isolated microVM with Docker inside, and reaches only the hosts on its allowlist.

  • $0.12 an Hour While It Runs

    Idle sessions suspend after five minutes and cost nothing while they wait.

  • Your Own Model Keys

    Bring your own keys, and your provider bills you directly.

See how cloud agents work

AI Is Building a New Silo, One Private Conversation at a Time

Code used to be the shared object. Now the real work happens in a terminal nobody else can open.

  • Invisible while it runs. Nobody else can see the session, so two people chase the same bug.
  • Gone when it ends. What was tried and ruled out leaves with the terminal.
  • Stuck with whoever ran it. Your best engineer’s judgment never reaches anyone else’s session.
  • Claude Code

    Arnav’s terminal

    why does the ingest test flake?

    the clock is frozen in setup

    Only you can see this

  • Codex

    Eashan’s terminal

    retry the webhook handler

    tried it, the race is still there

    Only you can see this

  • Cursor

    Maya’s terminal

    where do we redact keys?

    looking at session context

    Only you can see this

  • Gemini CLI

    Arnav’s terminal

    why did staging run out of VMs?

    nothing caps how many one team can start

    Only you can see this

An illustration: four agent sessions, each in a terminal only one person can see

Orchestra keeps what your agents learn, and hands it to the next session.

Decisions, dead ends and open questions come out of every session, each one linked to the moment it came from. Your agents start with that context instead of starting from zero.

Share the Session, Hand Off the Work, Keep the Reasons

The agent session is where the work happens now. Orchestra opens it to your team.

How it works: every session makes the next one start smarter

Orchestrate Every Agent Across Your Team

Run as many agents as you need, side by side, across every engineer on the team. Every running session is in one list: whose it is, what it is on and how long it has been going.

The Sessions list with demo data: three running, one left open and two finished, across Claude Code, OpenCode, Codex, Gemini and Cursor, each with its issue, repository and people.

The app, with demo data: every engineer's running agents in one list

Join a Teammate’s Agent Session

Open any running session in your workspace from your own machine, follow along, and step in mid-task, or fork it to try another way. Everyone sees who said what.

  • Only your workspace can see it, nobody outside your team
  • Shared only from the repos you turn Orchestra on for
  • Keys and tokens are stripped out before a session leaves your laptop
A running Claude Code session on the flaky ingest test. Eashan's message, inject the clock, do not freeze it, was delivered at the end of a turn, and Claude Code answers by injecting the clock at the policy boundary.

The app, with demo data: Eashan’s message in a session Claude Code is running for Arnav

Give Work to a Person or an Agent

People and agents share one assignee list. Give an issue to an agent and it starts with what the team already knows: earlier attempts, dead ends and decisions.

The assignee menu on issue W-226: one list with Arnav, Eashan and Maya, then Claude Code marked Agent.

The app, with demo data, and what the agent starts with

Keep What Every Session Learned

Every session ends with a written record of what it learned: what worked, what is still open and what failed. It stays on the issue, linked to the moment it happened.

A finished session's conclusion: what came of it, the decision to inject the clock at the policy boundary, what is still open, and the dead end, retries hide the race.

The app, with demo data: a finished session’s conclusion

Your Best Engineer’s Work, in Every New Session

Orchestra hands each new session what earlier ones learned, tried and ruled out. Your agents stop starting from zero, and your newest engineer works with what your best one learned.

An illustration: two finished sessions, and what Maya’s new one starts with
  • Every Agent, Every Session

    Whoever starts the next session, person or agent, starts with what the team knows

  • Only What Fits the Work

    Matched to the repo, the branch and the issue, so the agent is not buried in history

  • Every Line Cites Its Source

    Each item points at the moment it was learned, so nothing is taken on faith

Every Learning Traces Back to Something That Actually Happened

Orchestra keeps a record of the work that is never edited: who did what, and for whom. Everything it learned links back to it, so you can check instead of trust.

W-214's decision log in Knowledge: a decision, a commitment and a process, each with its session and citation.

The app, with demo data

  • See Who Did It

    A person, or an agent and the person it worked for

  • Written Once, Never Edited

    Nothing in the record is rewritten after the fact, so what you check is what happened

  • Drop In Any File

    Specs and docs join the record, linked like everything else

What Changes for Your Team

  • Before: Agent sessions live in one person’s terminal

    With Orchestra: Every session is open to your team, live

  • Before: Getting help means re-explaining in Slack

    With Orchestra: A teammate opens your session and steps in

  • Before: A handoff is a branch and a summary from memory

    With Orchestra: Give the issue to a person or an agent, and they start with everything

  • Before: What was tried leaves when the terminal closes

    With Orchestra: Decisions, open questions and dead ends stay on the issue

  • Before: Every agent starts from zero

    With Orchestra: Every session starts with what your team already knows

  • Before: Newer engineers learn by asking around

    With Orchestra: They start where your best engineer finished

Orchestra

Start on Your Machine Today

Download the app or install the CLI. Local by default, with no account.