Quick Start · How It Works · Comparison · Features · Website · Changelog
Orchestra is an AI agent orchestration platform where you manage a team of agents the way a CEO manages a company — not the way a programmer writes a pipeline.
You describe the goal. The orchestrator (Claude) breaks it down, assigns workers (Claude), reviews their output through a different model (GPT), and deploys the result. Each worker runs in an isolated git worktree. They communicate via messages, not function calls. They persist for hours or days, not the length of one API request.
The AI agent market is moving from SDKs to products. 2024: "here's an SDK, build it yourself." 2025: "here's an agent, give it a task." 2026: "here's a TEAM, give it a goal." Orchestra is the third thing.
Real-time dashboard: 6 agents working in parallel on a client project
Prerequisites: Python 3.12+, uv, Node.js 18+, Claude Code CLI (requires Claude Max subscription)
# Clone and install
git clone https://github.com/DrSeedon/orchestra.git
cd orchestra
cp .env.example .env
uv sync
# Run
uv run uvicorn app.main:app --host 127.0.0.1 --port 8888
# Open http://localhost:8888
# Create an orchestrator, point it at a project, start chattingNo graph definitions, no YAML workflows, no node configurations. You talk to the orchestrator like you'd talk to a tech lead.
You (Telegram / Dashboard)
│
▼
Orchestrator (Claude) ─── thinks like a manager
│ Decomposes task, assigns workers, reviews results
│
├─► Worker A (Sonnet) ── git worktree: feature/auth
├─► Worker B (Sonnet) ── git worktree: feature/api
├─► Worker C (Sonnet) ── git worktree: fix/bug-123
│
▼
Reviewer (GPT) ── cross-model review
│ Different model = different blind spots
│
▼
Merge ── squash to main
Each worker is a full Claude Code session in its own git worktree. They don't share context, don't step on each other's code, and merge through squash PRs. The orchestrator coordinates. Not a graph engine. An actual AI deciding what to do next.
Workers can talk to each other via send_message. The backend worker finishes an API endpoint and messages the frontend worker: "endpoint ready at /api/users, here's the schema." No human relay needed.
| LangGraph | CrewAI | AutoGen | Claude Code | Orchestra | |
|---|---|---|---|---|---|
| Mental model | Wire a graph | Assemble a crew | Chat between agents | Talk to one agent | Manage a team |
| Who it's for | Engineers | Developers | Researchers | Developers | Teams with AI-native devs |
| Agents | Nodes in a graph | Agents with roles | Conversable agents | One agent | Persistent fleet |
| Isolation | Shared state | Shared state | Shared state | Single context | Git worktree per worker |
| Duration | One pipeline run | One task run | One conversation | One session | Hours to days |
| Cross-model review | Manual | No | No | No | Built-in (Claude→GPT) |
| Telegram control | No | No | No | No | Voice, text, media |
| Task management | No | No | No | No | Built-in (priorities, payments) |
| Self-building | No | No | No | No | Yes |
The analogy:
- LangGraph = build a car from parts (for mechanics)
- CrewAI = LEGO kit (for hobbyists)
- AutoGen = group chat between bots (for researchers)
- Claude Code = hire one contractor (for developers)
- Orchestra = hire a team (for builders)
Agents live for hours or days. They maintain context across tasks, remember past decisions, accumulate project knowledge. Not one-shot functions.
Every worker gets its own git worktree — a full copy of the repo on its own branch. Two workers editing the same project never touch the same files. Merge conflicts are structurally minimized. owned_dirs per worker + check_conflict() before merge = safe parallel work.
Manage your AI team from your phone. Voice messages, photos, documents — the orchestrator transcribes voice (Deepgram Nova-3), understands images, processes files. Real-time status updates in topic threads.
Code written by one model (Claude) is reviewed by another (GPT). Different models have different blind spots. Two perspectives catch bugs that one model misses.
One orchestrator per project. Sub-orchestrators manage sub-teams. Workers do the work. Cross-project messaging lets orchestrators coordinate across repos.
Orchestra-orchestrator is the agent that builds Orchestra. 8 workers write the code for the platform they run on. No other framework can say: "our product was built by our product."
Orchestrators run on stronger models (deep thinking). Workers run on faster models (quick execution). Full-cycle research agents get the most capable model available. Each role gets the right model for the job, not one-size-fits-all.
Built-in task management with priorities, assignments, and payment tracking. Agents create, update, and close tasks. No external project management tool needed.
Agents survive restarts. Sessions are stored in SQLite, auto-resumed on boot. Context is compacted automatically when it fills up. Workers pick up where they left off.
HTMX + SSE dashboard shows every agent, their status, context usage, cache hit rate, current task, and live logs. No polling, no refresh.
These aren't demos. They run in production right now, on one server.
| Project | What it does | Scale |
|---|---|---|
| Parsing (client, Kamchatka) | Data import, dedup, genealogy search | 166M records in MySQL |
| Seedon (our company) | Registration, accounting, legal, site, marketing, first client | Full business ops |
| Kesha | Personal Telegram bot on Claude Agent SDK | 24/7 on VPS |
| VPN Service | Marzban VLESS+Reality management | Self-hosted |
| RimWorld Mods | 70+ mod translations, C# DLL | 2000+ text keys |
| Sensar (medtech) | Software validation protocol for video laryngoscope | 36 test items, 20 pages |
| University | MSc thesis, lecture notes, ML dashboards | 45 pages, 29 DOI sources |
| Orchestra itself | Self-development: 8 workers build the platform | Recursive self-improvement |
Dashboard (HTMX + SSE) ◄──► FastAPI :8888 ◄──► Session Manager
│
┌──────────────────┼──────────────────┐
▼ ▼ ▼
Orchestrator A Orchestrator B Orchestrator C
(Project: site) (Project: bot) (Project: data)
│ │ │
┌────┼────┐ ┌───┼───┐ ┌──┼──┐
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
W1 W2 W3 W4 W5 W6 W7 W8 W9
(fe) (be) (seo) (tg)(api)(db) (import)(dedup)(search)
TG Bridge (aiogram) ◄──► Orchestra API ◄──► Telegram group (topics per agent)
SQLite (WAL) ── sessions, logs, tasks, payments, jobs
Git Worktrees ── one per worker, squash merge to main
Mirror everything to a Telegram group with topic threads. Write in TG, agents receive. Send voice — transcribed via Deepgram. Send screenshots — agents see them.
# Add to .env
TG_BRIDGE_TOKEN=your_bot_token
TG_BRIDGE_GROUP=your_group_id
# Optional: voice transcription
DEEPGRAM_API_KEY=your_key- Python 3.12+, FastAPI, Jinja2, SSE
claude-agent-sdk— Claude Code SDK (persistent client per session)- SQLite (WAL mode), git worktrees
- Tailwind CSS, highlight.js, marked.js (bundled offline)
- aiogram 3.x (Telegram bridge)
- Deepgram Nova-3 (voice transcription)
We welcome contributions. See CONTRIBUTING.md for guidelines.
Good first issues are labeled good-first-issue.
AGPL-3.0 for open source use. Commercial license available for businesses that need it.
See LICENSE for details. Contact @DrSeedon for commercial licensing.
Orchestra — stop building pipelines, start managing teams
seedon.ru · Telegram · GitHub