AI orchestration & operations
Coordinate autonomous AI work
like a control plane should.
Orchicon orchestrates. Runtimes execute. One binary, one command, and your local stack — Postgres, NATS, the Grafana telemetry plane, the SPA — is up. Or run the whole thing in a single container.
$ curl -fsSL https://orchicon.dev/install | bash
PS> irm https://orchicon.dev/install.ps1 | iex
One command, full setup: downloads the orchicon binary,
pulls the published images, starts the runtime daemon, launches the
single-container instance, and prints how to connect / start / stop.
Re-running updates to the latest release. On Windows the whole stack
runs inside WSL2 — the installer provisions it and
installs the Linux binary into the distro. See
options below.
Nothing else to install — the runtimes are built in. Orchicon ships its own runtime engine and runs sessions inside the control plane, so a fresh install is complete on its own: no adapter CLI, no binary probe, no separate serve. Want to run work on OpenCode (or a future adapter such as Claude Code / Codex) instead? Install it on the host and Orchicon mounts it into the containers — it is never bundled, which keeps Orchicon redistributable whatever an adapter's licence says.
Quick start
-
1
Install
Run the one-liner above. Requires
curlandtar(or PowerShell on Windows — the Windows path runs the stack inside WSL2). -
2
Start the stack
$ scripts/container.sh up devBoots Postgres, NATS, Grafana (Tempo + Loki + VictoriaMetrics), the OTel collector, runs migrations, and serves the control plane + embedded UI on localhost:8080. Requires Docker.
-
3
Log in & build
Open the URL, sign in with the built-in dev IdP, create a project, define a Worker, and dispatch a Task. The whole end-to-end flow is verifiable locally.
What Orchicon is
An orchestration platform for autonomous AI work. It owns the parts that make AI work dependable — projects, workers, scheduling, policy, telemetry, recovery, governance — and runs the work on a runtime you choose: a built-in native engine that needs nothing installed, plus pluggable external adapters over gRPC.
Projects & work
Tenants, projects, work items as a DAG (Epic → Feature → Task → Subtask), with cycle-detected dependencies.
Workers & dispatch
Versioned Worker definitions (system prompt, permissions, gated tools, budgets). Reconciler-driven dispatch to healthy adapters.
Workflows
Step-DAG workflows: task, decision, approval, parallel, recover. Visual React Flow editor. Real-time step transitions.
Recovery engine
Default 6-step recovery workflow (capture → summarize → preserve → review → plan → resume) with checkpoint replay and bounded auto-relax.
Rego policy
OPA v1 at the dispatch decision point. Narrowest-scope-first evaluation, full Rego trace per decision for explainability.
Telemetry & cost
OTel → Grafana stack (Tempo + Loki + VictoriaMetrics). Per-tenant cost roll-up (Tenant → Project → Task → Execution) with streamed usage events.
Single container + per-workflow runtime containers
The whole stack — Postgres, NATS, telemetry, control plane — runs in one container with orchicon container (PID-1 supervisor). Dev + prod as two containers, your data preserved.
Worker executions run in an isolated container per workflow run, drawn from a warm pool (orchicon runtime-daemon on the host) so dispatch never cold-starts — and reset to pristine after each run so no state crosses boundaries. Running as your user — no root, fully ephemeral, torn down at completion. A run mounts only the adapter it actually needs: a plane using the built-in engine mounts nothing at all, and the host's own adapter install is mounted when a run asks for one — never baked into an image.
What you get, in practice
The orchestration is the foundation. These are the surfaces you actually work in, and the behaviours that make autonomous work safe to leave running.
A complete terminal client
orch is not a companion viewer — it is the whole product in a terminal, with read and write parity across every domain. Create, edit, publish, approve, cancel, retry, run bulk operations and watch live streams without leaving the keyboard. Boxed multi-line composer with slash commands and a command palette, a slide-out diff sidebar, click-to-copy on your own messages, and 43 themes — including true transparency, where your terminal shows through and the text adapts to it so it stays readable.
Ask Orchicon — three modes that are actually enforced
Brainstorm designs with you, Iteration works alongside you, Quick Work hands a defined job to a worker. The boundary is enforced by the platform rather than requested in a prompt: a mode's disallowed tools are withheld from it and refused at the point of execution, so "Brainstorm will not edit your files" is not something a model can be talked out of. The policy is adapter-agnostic, so a new runtime inherits it automatically.
Automation that proposes work, and a place to judge it
Put Orchicon on a schedule and a research crew surveys the world on its own — planning, verifying against external evidence, and synthesizing what it finds into feature proposals. Proposals land in the Idea Cloud, a triage board separate from real work, each carrying its evidence and the run that produced it. Promote one to turn it into work items, or dismiss it and it is remembered as rejected so it never comes back.
Cost is a constraint, not a report
Every execution runs under configurable ceilings — tokens, dollars, wall-clock, tool calls — with defaults calibrated from real usage. When a session gets expensive, Orchicon trims its own context and keeps working instead of re-sending an ever-growing history, and genuinely hard limits stop a runaway worker outright. Cache re-sends no longer count as work, so a long task cannot trip its budget by re-reading what it already knows.
Work that cannot be silently stranded
Work items form a DAG (Epic → Feature → Task → Subtask) with cycle-detected dependencies, and every run is a workflow — so an item with no workflow bound cannot be scheduled, and the platform says so when you create it rather than failing later. When you do need to unblock a backlog, binding a workflow and a runtime image across a whole selection is one gesture, not a form per item.
Recovery, policy and telemetry around every run
Failures are recoverable by default: the recovery flow captures, summarises, preserves, reviews, plans and resumes, with bounded auto-relax and escalation. Policy is evaluated in Rego at the dispatch decision point, with a full trace per decision. Telemetry streams over OpenTelemetry into the Grafana stack, and cost rolls up Tenant → Project → Task → Execution.
Orchicon orchestrates. Runtimes execute.
The control plane is a single Go binary. A runtime is a sidecar or the
engine inside the plane itself, and neither ever touches Postgres or
NATS directly — everything streams over gRPC. Point work at a different
runtime by implementing
orchicon.adapter.v1
— the built-in engine is one implementation of it, not a special case.
Build from source
Pre-built binaries ship from GitHub Releases — or build from source if you are working on Orchicon itself:
$ git clone https://github.com/beardedparrott/Orchicon.git
$ cd Orchicon
$ make build # → bin/orchicon
$ make dev-start # full dev environment
Prereqs: Go 1.26+, Node 22+, Docker. The Makefile installs buf and atlas via make tools.
Read the documentation
Comprehensive architecture, development, and user guide.