orchicon

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.

Quick start

  1. 1

    Install

    Run the one-liner above. Requires curl and tar (or PowerShell on Windows — the Windows path runs the stack inside WSL2).

  2. 2

    Start the stack

    $ scripts/container.sh up dev

    Boots Postgres, NATS, Grafana (Tempo + Loki + VictoriaMetrics), the OTel collector, runs migrations, and serves the control plane + embedded UI on localhost:8080. Requires Docker.

  3. 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 coordinates the moving parts — projects, workers, scheduling, policies, telemetry, recovery, governance — and talks to pluggable runtimes (OpenCode first) 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 their own short-lived container per workflow run (orchicon runtime-daemon on the host), armed with a baked toolchain and running as your user — no root, fully ephemeral, torn down at completion.

Orchicon orchestrates. Runtimes execute.

The control plane is a single Go binary. The runtime is a sidecar. Adapters never touch Postgres or NATS directly — they stream telemetry over gRPC. Swap OpenCode for something else by implementing orchicon.adapter.v1.

Installer options

Single container (Docker)

$ docker run --rm -p 8080:8080 -p 3002:3000 \
    -v orchicon-data:/var/lib/orchicon ghcr.io/beardedparrott/orchicon

macOS / Linux

$ curl -fsSL https://orchicon.dev/install | bash -s -- --version v0.2.0
$ curl -fsSL https://orchicon.dev/install | bash -s -- --install-dir /usr/local/bin
$ curl -fsSL https://orchicon.dev/install | bash -s -- --no-setup
$ curl -fsSL https://orchicon.dev/install | bash -s -- --uninstall
$ curl -fsSL https://orchicon.dev/install | bash -s -- --clean
$ curl -fsSL https://orchicon.dev/install | bash -s -- --force-clean

Windows (WSL2)

PS> & ([scriptblock]::Create((irm https://orchicon.dev/install.ps1))) -Version v0.2.0
PS> & ([scriptblock]::Create((irm https://orchicon.dev/install.ps1))) -InstallDir "/usr/local/bin"
PS> & ([scriptblock]::Create((irm https://orchicon.dev/install.ps1))) -NoSetup
PS> & ([scriptblock]::Create((irm https://orchicon.dev/install.ps1))) -Uninstall
PS> & ([scriptblock]::Create((irm https://orchicon.dev/install.ps1))) -Clean
PS> & ([scriptblock]::Create((irm https://orchicon.dev/install.ps1))) -ForceClean

On Windows the whole stack runs inside WSL2: the installer provisions/detects WSL2, installs the Linux binary inside the distro, and runs the one-command setup there. Requires Windows 10 21H2+ / Windows 11 and Docker Desktop with WSL integration.

FlagDescription
--version <tag>Install a specific version (e.g. v0.2.0). Default: latest.
--install-dir <dir>WSL directory to install the binary into (default: ~/.local/bin).
--no-setupInstall the binary only — skip pulling images / starting the daemon / launching the container.
--uninstallStop the container instances, remove the WSL-installed binary. The WSL distro is left intact.
--dry-runPrint what would happen without making changes.
--clean / -CleanStop dev containers, remove old binary, then install latest. All user data preserved.
--force-clean / -ForceCleanNuke Docker volumes, remove local data, then install latest. All data lost.

What gets installed

PathContents
<install-dir>/orchiconThe orchicon binary (control plane + embedded frontend)
~/.local/share/orchicon/Runtime state, PID files, logs, blob store

Quick start

$ scripts/container.sh up dev   # start the dev container instance
$ curl http://localhost:8080/healthz  # {"status":"ok"}
$ scripts/container.sh down dev  # stop the instance
$ orchicon version        # print installed version

Build from source

Pre-built binaries ship from GitHub Releases. Until the first release is cut, build from source:

$ 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.

Open the docs →

Latest release: v0.1.144 — release notes