Private development · early access by invitation

Coding agents on your board, each in its own container.

Maestro takes tickets from Linear or Takt and runs Claude Code, Codex, OpenCode or pi on each one, in a fresh Docker container on your own machine. You watch every step as it happens, message or stop any run, and the result goes back to the ticket.

Join the waitlist How it works

Maestro is Italian for the one who conducts. The agents play the parts; you keep the score.

  1. ENG-142 Retry the flaky upload test

  2. review Reviewer on PR #88

  3. web-207 CSV export for run history

  4. ENG-151 Bump the SDK to 2.4

An afternoon of four sessions, drawn as a score. Illustration with example tickets.

Why Maestro

An agent in your terminal shares everything you have.

Run a coding agent in your own shell and it works in your checkout, with your git state, your credentials and your half-finished branch. Run three at once and they trip over each other. When one goes wrong, there's no record of what it did and nothing to pick up from.

Maestro gives every run a room of its own: a fresh container with the project's checkout, only the secrets you attached, a token that works for that session alone, and a transcript you can read afterwards. Your machine stays yours.

How it works

From ticket to result, in the open.

  1. Connect the board you have

    Linear or Takt sends Maestro a webhook when a ticket changes. Your tickets stay where they are; Maestro never asks you to move them.

  2. Say which agent runs when

    Automations match board events to agents: a worker when a ticket is ready, a reviewer when it moves to review. Each agent carries its own instructions, skills and model.

  3. Your runner starts a container

    The runner is one process on your own machine. For each session it starts a fresh Docker container with the checkout, the project's instructions and the secrets you attached, and deletes it when the session stops.

  4. Watch it, steer it, stop it

    Messages and tool calls stream to the dashboard as they happen. Answer a question, send a nudge, or stop the run. Stopping is a button you press, never a timer.

  5. The result lands on the ticket

    The pull request link, comments and status changes are written back to the board, next to a link to the full session. A stopped session can be resumed later.

What works today

Real primitives, not a demo.

Agents
Claude Code, Codex, OpenCode and pi, each on your own subscription or API key. Pick the agent and model per automation.
Boards
Linear and Takt, through one webhook contract. Each is a peer; neither gets a privileged path.
Isolation
One Docker container per session, removed when the session stops. Each session authenticates with a token issued for it alone.
Live dashboard
Every message and tool call as it happens, with the controls to message, stop or resume a session.
Automations
Rules that start a session on a board event, so reviews and follow-ups start themselves when a ticket changes state.
Sessions that talk
Give a session a key and other sessions can mention it to hand over work, so one session can conduct workers and reviewers.
Project setup
Instructions, skills, files and secrets set once per project, plus hooks around each session, for example to give every run its own copy of a database.
API and CLI
The dashboard runs on a GraphQL API, and the maestro command line drives the same API from a terminal or from another agent.

Deliberately not

What Maestro won't do.

  • Replace your board

    There's no Maestro task list to migrate to. The board you use stays the source of truth.

  • Act on your behalf in secret

    No silent retries, no escalation timers, no hidden helpers. You start, steer and stop runs, and the dashboard shows what is about to happen.

  • Run your code elsewhere

    Containers run on your hardware, under your Docker. Maestro coordinates; it doesn't host the work.

Questions

Short answers.

What is Maestro?
Maestro runs coding agents on tickets from the board you already use. Each run gets its own Docker container on your machine, streams to a live dashboard, and writes its result back to the ticket. It is in private development, with early access by invitation.
Where do the agents run?
On a machine you control. You run the Maestro runner there, next to Docker, and it starts one container per session. Maestro's service coordinates runners, boards and the dashboard; it doesn't run your code.
Does my code leave my machine?
The checkout stays on your machine, inside the session's container. The transcript, meaning the agent's messages and tool calls, streams to Maestro's service so the dashboard can show it. Your agent's model provider sees what the agent sends it, as it would without Maestro.
Which agents and boards does it support?
Claude Code, Codex, OpenCode and pi, on your own subscriptions or API keys. Linear and Takt as boards, through the same webhook contract.
What does it cost?
Pricing isn't set yet, and it will be published on this page before Maestro asks anyone to pay. The agents themselves run on your own subscriptions or API keys, so their providers bill that usage.
How does Maestro relate to Takt?
Takt is a sibling product: a task board and wiki built for people and agents. Maestro works with Takt exactly as it works with Linear, and you don't need Takt to use Maestro.

Join the waitlist.

Maestro opens to people who already run coding agents on real work, a few at a time. Tell us where your tickets live and what you'd hand to an agent, and we'll write when there's room for you.

We use these details only to decide whom to invite first. See the waitlist privacy notice.