Issue In, PR Out: maestro Orchestrates Claude Agents for GitHub & Linear

Coding agents are great at writing code.

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

That gap costs real time. Teams paste issues into a chat box, babysit with "please continue," and still get sprawling diffs that are painful to review.

maestro fills that gap.

Drop in a GitHub or Linear issue. Get a reviewable pull request.

It's an open-source multi-agent system on Claude Managed Agents that turns issues into shipped code — with orchestration, not another chatbot loop.

Why bother?

No chat babysitting. No "please continue."
Issue in → PR out — plus a receipt for how you got there.

What breaks with "just throw it at an agent"

1. Chat doesn't scale for tickets — threads drift, context dies, ownership vanishes.
2. One giant loop on a fat issue yields messy diffs and fuzzy review boundaries.
3. Trust needs receipts — which tools ran, what changed, and why.

maestro is built around those three failure modes.

Screenshots

Kick off a run

Pick a repo + issue. Hit run. No thread to babysit.

Follow the multi-agent pipeline

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

Connected repositories

GitHub App auth per installation — skip the shared-PAT mess.

MCP client settings

GitHub MCP is built in. Add Figma, Linear, or your own stdio servers through the MCP Gateway.

Prompt versioning

Edit system prompts from the UI without redeploying — and keep a diff of what changed.

Pipeline

1. Ingest from GitHub Issues or Linear (identifier or URL).
2. Orchestrator plans and decomposes into the smallest set of independent, implementable sub-issues — boundaries for parallel work and clean review, not arbitrary chunks.
3. Implementers (Claude Managed Agents) take each sub-issue and write real code via GitHub MCP.
4. Finalize folds the work into one pull request for human review.
5. Audit — structured logs and per-run event history (phases, tools, outcomes). OpenTelemetry optional.

Start from the WebUI, HTTP API, or a labeled-issue poller. Linear origins use the same path.

What you get

• GitHub Issues and Linear on one orchestrate → implement → PR path
• Optimal task decomposition instead of a mega-agent loop
• Durable audit / run history in the WebUI
• Multi-agent by design (coordinator + implementers)
• Real PRs — branches, commits, reviewable diffs on your GitHub
• GitHub App auth (installation tokens, not PAT sprawl)
• MCP-native (GitHub + gateway for Figma / Linear / custom stdio)
• Self-hosted sandboxes via ANTHROPIC_ENVIRONMENT_ID
• OpenTelemetry when you want it

Stack

• Runtime: Bun + TypeScript
• Agents: Anthropic Claude Managed Agents
• 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, hit run.

Docs: Installation · Architecture · Repo

Who this is for

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

TL;DR

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.

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