Autonomous engineering infrastructure

Engineering.
Orchestrated.

Give your coding agents a shared direction.
AiOrch plans the work, runs agents in parallel, reviews their code and brings it together in one pull request.

Self-hostedYour models. Your keys.
aiorch / orchestration sessionfeat/payment-refactor
01 A clear task

Make payments resilient.

Add retry logic, cover the edge cases, and document the API.

Your repositoryplatform / payments
02 Parallel implementation
01
Payment core
Claude Code
✓
02
Retry & backoff
Codex
✓
03
Tests & coverage
Claude Code
✓
04
API documentation
Kimi
✓
Independent review · revised and approved
03 One reviewed result
Pull request #847

Resilient payment processing

feat/payment-refactor → main
Code reviewedBranches integrated38 / 38 configured tests passed
Ready for your team’s review
  1. 01Plan
  2. 02Implement
  3. 03Review
  4. 04Integrate
  5. 05Deliver

Illustrative workflows. User-triggered playback.

Your agents.
Your choice of models.
Claude CodeCLI PROVIDER
CodexCLI PROVIDER
OpenAIAPI PROVIDER
KimiCLI / API
OllamaLOCAL INFERENCE
Beyond code generation

For engineering teams already working with coding agents.

Getting agents to write code is the easy part. Getting their work reviewed and brought together is where AiOrch comes in.

Give the work a structure.

A scoped plan, separate worktrees and a review loop keep parallel agents moving toward the same outcome.

Review the result.

Spend your attention on one integrated pull request, with the review history and validation status alongside it.

The engineering pipeline

A task goes in.
A team goes to work.

Five connected stages. Each agent has a scope, each revision has a reason, and every branch has a place in the final result.

  1. AiOrch maps the codebase and proposes scoped agent tasks. Review the plan before execution, or enable automatic plan approval.

01 / PLANOne direction. Separate scopes.
One task branches into four scoped agent tasks and converges on a single pull request.01020304taskworktreesPR

The plan is the shared contract. Agents receive explicit tasks, dependencies and the project context they need.

You choose the level of autonomy: plan approval, model routing, independent audit and GitHub PR creation are configurable.

Review is part of the work

The first draft
isn’t the handoff.

An agent writes the code. A separate reviewer challenges it. Revisions happen inside the pipeline, before the work reaches your team.

  • Review against the task, not just the diff.
  • Send findings back for another round.
  • Enable an independent audit of the integrated result.
retry/backoff.tsReview round 1 → 2
R
ReviewerRevision requested

The retry delay can exceed the configured limit when jitter is added. Cap the final delay and test the boundary.

− return delay + jitter;+ return Math.min(delay + jitter, maxDelay);
02
Implementation agentRevised

Final delay is capped. Boundary tests cover maximum jitter and repeated retries.

Reviewer approved · ready for integration

Illustrative review exchange. Review rounds and audit behavior follow your session configuration.

Built while shipping real software

Less theatre.
More merged work.

Internal production runs from a Rust voice-orchestration codebase. Real tasks, revision rounds and integrated branches.

Phase 3 / Legacy router removal

Remove an entire routing engine.

Seven branches approved on their first review and merged cleanly. 3,990 net lines removed; two pre-existing, unrelated failures documented separately.

7parallel agents
~1.1helapsed time
2,466tests passed
Phase 0c / Flow orchestrator

Catch the defect before merge.

Adversarial review identified a double-counted metric. Fixed, reviewed again and integrated across all seven merge branches.

8parallel agents
10review rounds
1defect caught
Phase 6.1 / Speculative execution

Make overlapping changes work.

Five agents touched shared files. Four integration conflicts were resolved automatically, with every branch merged after review.

5parallel agents
70tests passing
4conflicts resolved

One architectural refactor.
11 phases. 61 agents.Sequential phases, parallel work within each phase.

0102030405060708091011
Dynamic orchestration redesignAll phases merged

AiOrch’s internal use, not a customer endorsement. Figures from the existing case-study records extracted from on-disk session state; they are individual runs, not a general performance guarantee. Inference cost was not recorded for these runs.

Local-first by design

Your infrastructure.
Your control.

The orchestrator, agents and git worktrees run on your machine, VM or build server. AiOrch never receives your source code.

  • Choose where inference happens.Use configured model providers, compatible gateways or local Ollama models.
  • Keep the working history.Session state and structured event logs remain on your file system.
  • Bring your own keys.Provider charges go directly to you. AiOrch adds no token markup.

Configured providers receive the context needed for inference. License activation and validation contact AiOrch’s license service.

YOUR INFRASTRUCTURE
aiorch
OrchestratorAgent worktreesReview loopSession state & logs
Configured inference traffic
Model providersOnly the endpoints you configure
With local models, inference stays on your infrastructure too.
An operator’s view

Autonomous work.
Visible progress.

Follow each agent, review round and merge from your own dashboard. When something stops, see where and why.

Durable session stateResume from saved state after a crash or interrupted run.
Local audit trailAgent actions, review events and integration outcomes on disk.
payment-refactor / session logILLUSTRATIVE
  1. [planner] task scoped into four agent assignments
  2. [agent-01] payment core implemented · branch ready
  3. [tests] 14 unit tests passed
  4. [review] revision requested · retry delay boundary
  5. [agent-02] jitter capped · boundary tests added
  6. [review] round 2 · agents approved
  7. [merge] overlapping changes resolved
  8. [integration] configured tests · 38 / 38 passed
  9. [github] PR #847 created · ready for review
events.jsonl · on your file systemSESSION COMPLETE

Configure the validation policy: block on environment failures, or deliver with an explicit unverified warning.

Pricing

Pay for orchestration.
Keep your model bill.

A self-hosted orchestrator for your team. Inference is billed separately by the providers you choose, directly to you.

14 days to run it on your own work.Full-feature trial · no card required · zero token markup

Solo / Developer

$69 / month

One operator.
Your machine, your workflow.

  • Self-hosted orchestration
  • Bring your own model keys
  • Parallel agents and review
  • Your local session history
Start free trial

Scale

$1,499 / month

Larger teams.
Discuss your deployment.

  • Everything in Team
  • Larger self-hosted installs
  • Priority support
  • Shared configuration (planned)
  • Central policy (planned)
Discuss Scale

Enterprise

Let’s talk.

Your organization.
Your deployment requirements.

  • Deployment support
  • Local-model configuration
  • Discuss support and SLA needs
  • SSO, RBAC and SCIM (planned)
  • Policy enforcement (planned)
Contact us

Published team plan pricing is shown here. Contact us to confirm your deployment and operator licensing. Shared team controls are on the roadmap.

The next chapters

Clear about what’s
still coming.

The orchestration engine is here. These additional trust and team controls are being developed or planned.

Signed event logs In progress

Tamper-evident event history. The current log is plain, structured JSONL on your file system.

Policy and model allowlists Planned

Declarative rules for permitted models, repositories and branches, alongside centralized session policy.

Team and enterprise controls Planned

SSO, role-based access, SCIM and shared history for deployments with multiple operators.

Your next branch

Give the work
a way forward.

Install AiOrch, connect your models and start with a real task.

INSTALL AIORCH · DOCKER REQUIRED
curl -fsSL https://aiorch.ai/install.sh | bash

Run in your terminal to begin.

14-day trial · bring your own keys · self-hosted