Coding agents are excellent at writing code.

They're much worse at owning a ticket end-to-end: scoping it, splitting it into the right units of work, implementing in parallel, opening one clean PR, and leaving a trail you can audit later.

That gap is expensive. Teams paste issues into a chat box, babysit with "please continue," and still get messy diffs that are hard to review.

maestro is the missing layer.

Paste a GitHub or Linear issue. Get a pull request.

It's an open-source multi-agent system built on Claude Managed Agents that turns issues into shipped, reviewable code — autonomously.

Why maestro exists

No chat babysitting. No "please continue." Issue in → PR out — and a record of how you got there.

The real problems with "just use an agent"

1. Chat doesn't scale for tickets — long threads drift; context dies; nobody owns the outcome.
2. One giant agent loop on a fat issue produces sprawling diffs and weak review boundaries.
3. Trust requires receipts — teams need to know which tools ran, what changed, and why.

maestro is designed around those three pain points.

See it in action

Start a run from the WebUI

Pick a repo and issue, then hit run. No chat thread to babysit.

Watch progress across the multi-agent pipeline

Orchestrator decomposes work; implementers ship in parallel; everything consolidates into one PR.

Manage connected repositories

GitHub App auth per installation — no shared PAT sprawl.

MCP client settings

GitHub MCP built in; plug in Figma, Linear, or your own stdio servers via the MCP Gateway.

Prompt versioning & diffs

Tune system prompts from the UI without redeploying — and keep a trail of what changed.

How it works

1. Ingest a parent task from GitHub Issues or Linear (identifier or URL).
2. Orchestrator plans and decomposes into the smallest set of independent, implementable sub-issues — boundaries chosen for parallel work and clean review, not arbitrary chunking.
3. Implementers (Claude Managed Agents) pick up each sub-issue and write real code against your repo via GitHub MCP.
4. Finalize merges the work into one pull request ready for human review.
5. Audit — structured audit logs and per-run event history capture phases, agent/tool activity, and outcomes (WebUI + logs; OpenTelemetry optional).

Trigger from the WebUI, the HTTP API, or a GitHub repo poller that watches labeled issues. Same pipeline for Linear origins.

What you get

• GitHub Issues and Linear — same orchestrate → implement → PR path
• Optimal task decomposition — focused, parallelizable sub-issues instead of one mega-loop
• Audit log retention — HTTP / session / tools events + durable run history in the WebUI
• Multi-agent by design — coordinator + implementer roster
• Real PRs, not sidebar diffs — branches, commits, reviewable pull requests on your GitHub
• GitHub App auth — installation tokens per repo (no shared PAT sprawl)
• MCP-native — GitHub MCP built in; Figma, Linear, or custom stdio servers via MCP Gateway
• Self-hosted sandboxes — keep execution on your infra with ANTHROPIC_ENVIRONMENT_ID
• OpenTelemetry-ready — traces and metrics when you want them

Stack

• Runtime: Bun + TypeScript
• Agents: Anthropic Claude Managed Agents (multi-agent coordinator)
• HTTP / UI: Hono SSR dashboard
• GitHub: GitHub App + official GitHub MCP
• Extensibility: MCP Gateway (stdio → remote MCP)

Quick start

mise install
bun install
export ANTHROPIC_API_KEY=...
export GITHUB_APP_ID=...
export GITHUB_APP_PRIVATE_KEY_PATH=/path/to/github-app.pem
bun run start
# → http://127.0.0.1:3000

Open the dashboard, pick a repo + issue number, hit run.

Full setup (GitHub App, containers, MCP Gateway, self-hosted workers, GCP Terraform): Installation wiki · Architecture · Repo

Who should try this

• Teams drowning in backlog tickets that are "agentable" but not chat-friendly
• Orgs that want Issue → PR with human review still in the loop
• Anyone who needs auditability for autonomous coding agents
• Builders already on Claude / MCP who want orchestration, not another chatbot

Bottom line

Stop pasting tickets into a chat box.

Point maestro at a GitHub or Linear issue. Get an optimally decomposed plan, a real PR, and an audit trail of every step.

🔗 https://github.com/ca-srg/maestro