aiorch decomposes a single task across multiple coding agents, makes them review each other's work in rounds, resolves conflicts, and delivers a single GitHub PR ready for human review. Runs entirely on your infrastructure. Your model keys. Your code. Zero markup.
The gap between "AI wrote this" and "a human should merge this" is where senior engineering time disappears. aiorch closes it — by making agents review each other before you ever see the diff.
You still need to read it, run it, reason about edge cases, reject half of it, ask for revisions, and open the PR yourself. The review burden stays with the human.
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.
Claude Code can only orchestrate Claude models. Codex can only orchestrate OpenAI models. By design, neither can give you cross-brand routing. This isn't a feature gap they'll close — it's a commercial conflict. Anthropic will never natively support GPT-5. OpenAI will never natively support Claude. We will.
All in a single session. Automatic. Per-agent.
aiorch delivers team-style multi-agent orchestration — parallel coding, adversarial review, automatic merge — at the inference cost of individual sessions. No inflated team pricing.
Earlier autonomous coding tools failed because one agent's mistakes went unchecked until the user saw a broken PR. aiorch replaces human-in-the-loop intervention with adversarial agents at three independent layers — the same problem, a different solution.
A separate agent evaluates each coder's output against the original task specification, requests revisions, and only approves once the work passes. Coders never merge their own code. Most issues are caught and corrected before they leave the agent's branch.
A second-pass reviewer with no shared context audits the merged result, identifies issues the in-loop reviewer missed, and performs final cleanup. Independent context is what makes the audit adversarial rather than confirmatory.
Tests run across all merged branches. Conflicts are detected and resolved automatically. The PR only opens if every check passes. If anything fails, the session does not produce a PR — it surfaces the failure for review.
Three checkpoints between the prompt and the merge button. The user sees only the final result.
Real engineering work isn't one prompt. It's a sequence of dependent phases — refactor the schema, migrate the callers, update the tests, deprecate the old API. aiorch chains sessions into pipelines that execute sequentially, with each phase handing off cleanly to the next.
The pipeline above is 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.
The session view below shows a real orchestration run. Four agents working in parallel, a reviewer requesting revisions, and the final PR — all streamed token-by-token in your browser.
Every running session exposes the full agent fleet, live logs, model spend, and a complete event timeline. Built for engineers who merge the PR — not for demos.
| Agent | Model | State | Spend |
|---|---|---|---|
| a01 payment-core | claude-sonnet-4 | Reviewing | $0.24 |
| a02 retry-backoff | gpt-5.5 | Approved | $0.18 |
| a03 tests | claude-sonnet-4 | Running | $0.21 |
| a04 api-docs | kimi-k2 | Approved | $0.08 |
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. The only traffic that ever leaves the container is the model API call — to the provider whose key you configured.
No aiorch server ever sees your prompts, diffs, code, or metrics. The only outbound call beyond your configured model APIs is a one-time license check.
Configure which provider endpoints the container can reach. Point at self-hosted inference, OpenAI-compatible gateways, or local Ollama — the orchestrator doesn't care.
Laptop, bastion host, CI runner, on-prem cluster. Same image, same behavior. No SaaS dependency to audit, no data-processing agreement to sign.
We don't resell tokens. We don't inflate margins on inference. Plug in the enterprise agreements you already have — or route agents to your own self-hosted models. Every session ends with an itemized cost report, agent by agent.
aiorch runs a deterministic orchestration pipeline. Each stage is logged and replayable — so you can walk back through any session end-to-end.
Your task is parsed into isolated subtasks with explicit scope and acceptance criteria.
Each subtask gets its own agent, git worktree, and model. Agents run in parallel, in isolation.
A dedicated reviewer agent critiques each output, demanding revisions until the work meets spec.
Branches are merged into an integration branch. Conflicts are resolved programmatically or escalated.
A single GitHub PR lands with summary, diff stats, agent breakdown, and complete event log.
Based on internal benchmarks across 100+ sessions at TravelCalls.ai — refactors, test backfill, and feature scaffolding compared to manual workflows. Your numbers will vary by codebase shape and task mix.
Based on internal benchmarks across 100+ aiorch sessions on a production Rust + React codebase. Inference billed at provider list price; aiorch licence purchased separately.
Routine refactors, test backfill, and scaffolding stop consuming your hours. You go back to architecture, design, and review.
Kick off a session before you log off. By standup, the PR is open, reviewed, and waiting on your approval — not your authorship.
Every session has a hard budget cap and an itemized cost ledger. Real provider costs, no markup, no vendor surprise invoices.
Every session writes a structured event log to your local file system. Know exactly which agent wrote which line, which model was called, and what it cost — replayable from your own machine.
Every agent spawn, review round, merge, and completion is appended to an append-only JSONL log on disk. One line per event, grep-friendly. One-click diagnostic export bundles the full session into a single archive.
Cost is captured from the provider's API response where available, or calculated from published pricing for CLI-based providers. Roll up by agent, by session, or by pipeline.
The session detail page renders the full agent timeline: who started when, what they touched, when the reviewer signed off. Same data as the JSONL — just rendered.
Export a complete bundle for any session or pipeline — events, prompts, diffs, model responses, costs — as a single archive. Drop it in a bug report or keep it for post-mortem.
Tools overlap, but they solve different problems. aiorch isn't competing for your IDE — it's competing for the review-and-merge loop.
aiorch was built while shipping a Rust + React production AI platform.
We needed an orchestration tool that could deliver multi-phase refactors without supervision while we focused on customer-facing work. Nothing on the market did that the way we needed, so we built aiorch. Every feature on this page exists because we used it ourselves first.
— internal use case, not a paid endorsement
aiorch is a Docker container that runs on your infrastructure. You pay per seat for the orchestrator. All inference is billed by your model provider at their list price, directly to you.
Named-user licenses. Each seat is bound to one email and can be installed on unlimited devices by that user. No device limits, no concurrent session restrictions. See what gets logged →
We list everything below — including what's not yet built. aiorch is local-first by design; if a feature would need a hosted service, we say so.
Hash-chained, sha-256-signed events.jsonl for tamper-evident replay and post-mortem. Today the log is plain JSONL on your file system.
Declarative YAML to constrain which models, repos, and branches a session may touch — plus per-session spend caps enforced at the orchestrator. Useful even for a solo user; not yet shipped.
target · Q3SSO, role-based access, and a shared session history would require a hosted backend. aiorch is single-user by design today; we'd only build this if there's clear demand for a team edition.
no commitmentInstall in 5 minutes. Run it against a real branch tonight. Free for 14 days. No card, no phone-home, no tokens to pre-buy.