Give AiOrch a task.
Wake up to a reviewed PR.
aiorch turns Claude Code, Codex and other coding agents into an autonomous engineering pipeline — it plans, implements in parallel, has the agents review each other, runs your tests, and delivers one verified pull request.
Your engineers review the result — not babysit the agents.Most coding tools give you code. We give you a reviewed PR.
The gap between “an agent wrote this” and “a human should merge this” is where senior engineering time disappears. aiorch closes it — the agents review each other before you ever open the diff.
Generate a diff. Hand it to you.
You still read it, run it, reason about edge cases, reject half, ask for revisions, and open the PR yourself. The review burden stays with the human.
Generate, review, revise, merge — then open the PR.
A dedicated reviewer agent critiques each agent’s output, sends work back for revision, and only approves once the code passes. You review reviewed code, not draft code.
The code was already reviewed before you saw it. That is the product.
aiorch was built while shipping a production voice-orchestration platform. Every run below is real — figures read straight from on-disk session state.
Real merges, not a demo.
Delete legacy routing engine
All 7 agent branches approved on the first review round and merged clean (2 pre-existing, unrelated failures documented off-scope).
Flow orchestrator + tool executor
Adversarial review caught a double-counted metric before merge — the bug a tired human reviewer skims past. Fixed, re-reviewed, merged (7/7 branches).
Speculative LLM + grammar
Five agents touched overlapping files; aiorch resolved all four conflicts during integration and merged (5/5 branches) after multi-round review.
Figures read directly from on-disk session state (agent counts, timings, review rounds, merge results). Inference cost is capped per session and billed by your provider — not shown here because it isn’t recorded in session state.
Five stages. Three review layers.
One pull request.
Autonomous coding failed before because one agent’s mistakes went unchecked until you saw a broken PR. aiorch’s answer isn’t one agent reviewing itself — independent agents with separate context review and challenge the implementation at three checkpoints before it can merge.
01 Reviewer in-loop
A separate agent evaluates each coder’s output against the task spec, requests revisions, and only approves once it passes. Coders never merge their own code.
02 Independent auditor
A second-pass reviewer with no shared context audits the merged result and catches what the in-loop reviewer missed. Independent context is what makes it adversarial, not confirmatory.
03 Integration check
Tests run across all merged branches; conflicts resolve automatically. The PR opens only if every check passes — otherwise the session surfaces the failure instead of a broken PR.
A real architectural refactor delivered by aiorch — 11 sequential phases, 61 agents, all merged without manual intervention. Pipelines are how aiorch handles work that would normally span multiple sprints.
An operator console,
not a chat box.
A real orchestration run: four agents in parallel, a reviewer requesting a revision, conflicts resolved, and the PR — streamed to your browser from your own machine.
A dashboard of running sessions — which agent touched which file, which model it used, which review round it’s in — streamed token-by-token. You supervise; you don’t author.
State lives on disk. Sessions and pipelines survive crashes, stuck agents, and restarts — resume from the last durable checkpoint, with a clear terminal state either way.
AiOrch never receives your code.
aiorch is a Docker image you run on your own machine, VM, or build server. The orchestrator, agents, git worktrees, and review loop all execute locally.
No telemetry on your code
No aiorch server sees your prompts, diffs, or metrics. Model traffic goes only to the providers you configure — or stays fully local with Ollama.
You control the egress
Point agents at self-hosted inference, OpenAI-compatible gateways, or local models. The orchestrator doesn’t care where the tokens come from.
Use the best model for each job — even within the same session. Implementation, review and boilerplate route to different providers or local models, automatically per agent.
Parallel coding, adversarial review, and automatic merge — billed by your provider at list price, no inflated seat pricing.
Every agent action, on disk.
Each session writes a structured event log to your local file system: which agent wrote which line, which model was called, what it cost — replayable from your own machine.
Structured event log
Every spawn, review round, merge and completion appended to append-only JSONL — one line per event, grep-friendly.
Real per-agent cost
Cost captured from the provider response where available, or computed from published pricing for CLI providers. Roll up by agent, session, or pipeline.
One-click diagnostic export
Bundle a full session or pipeline — events, prompts, diffs, responses, costs — into a single archive for a bug report or post-mortem.
Priced per team. Tokens billed by your provider.
A Docker container on your own infrastructure. You pay per team for the orchestrator; all inference is billed by your model provider at list price, directly to you — zero markup.
- Local / self-hosted
- BYOK, all providers
- Full orchestration
- Unlimited agents per task
- Everything in Solo
- Pipelines with audit phases
- GitHub integration
- Audit logs & diagnostic export
- Email support
- Everything in Team
- Central policy
- Shared config
- Cost controls
- Priority support
- SSO, RBAC & SCIM — on the enterprise roadmap
- Policy enforcement
- Air-gapped / local models
- Audit & SLA
- Deployment support
Inference is billed by your model provider at list price, directly to you; the aiorch license is purchased separately. See what gets logged →
What’s coming — and what isn’t yet.
aiorch is local-first by design. We list what’s built, in progress, and planned — including the parts that aren’t shipped.
Signed event log
Hash-chained, SHA-256-signed events.jsonl for tamper-evident replay. Today the log is plain JSONL on your file system.
target · next minorPolicy & model allowlists
Declarative rules to constrain which models, repos and branches a session may touch — plus per-session spend caps enforced at the orchestrator.
target · this yearTeam & enterprise controls
SSO, role-based access, SCIM and shared session history for multi-operator installs — the next major track behind the Team, Scale and Enterprise tiers.
target · Enterprise trackRun it against a real branch tonight.
$ curl -fsSL aiorch.ai/install.sh | sh
Free for 14 days · no card · no phone-home · bring your own model keys