Roadmap¶
This is a direction, not a contract. Agent CLIs move fast, and an item can move forward, wait, or disappear when an upstream headless mode, license, or protocol changes. The order below is roughly the order we would like to ship.
How a new agent CLI gets in¶
A CLI is added only when all of these are true:
- it has a non-interactive mode with a stable exit code and machine-readable output (JSON is ideal, plain text is acceptable);
- it can authenticate from an environment variable or a config file — no browser-only login inside the container;
- it accepts a custom base URL for Anthropic-compatible, OpenAI-compatible, or its own protocol;
- its license allows redistribution in a public image (Apache-2.0, MIT, or similar; proprietary binaries only in an opt-in tag);
- it builds or ships for
linux/amd64andlinux/arm64; - it does not auto-update at runtime; the version is pinned in
versions.env; - the Multica daemon can register it as a runtime, or a small adapter can make it behave like one.
That last point is the real gate. Installing a CLI is easy; making it a first-class Multica runtime with correct task lifecycle, cancellation, and session history is the work.
Shipped¶
| CLI | Command | Notes |
|---|---|---|
| Claude Code | claude |
Anthropic-compatible endpoint, four model slots |
| OpenCode | opencode |
Anthropic- or OpenAI-compatible, generated config |
| Codex CLI | codex |
Responses API endpoint, generated config, CODEX_HOME on volume |
Wave 1 — the next three harnesses¶
These are the most likely next additions. They have headless modes, active upstream projects, and a plausible path to the Multica daemon.
Qwen Code¶
Qwen Code (qwen) is Alibaba's open-source terminal coding agent, derived from
Gemini CLI and tuned for Qwen-Coder models. It is Apache-2.0, has a headless
mode, and speaks OpenAI-compatible endpoints, so it fits the existing AI_*
surface better than Codex does.
What it needs:
- an adapter for
~/.qwensettings andOPENAI_*-style environment variables; - catalogue handling: Qwen Code is happiest when the model name exists in its provider list, so the entrypoint should generate a custom provider entry instead of assuming a built-in one;
- a
:base-qwentag first, because the CLI pulls a large Node dependency tree; - tests for both the Qwen endpoint and a generic OpenAI-compatible router.
Grok Build¶
Grok Build (grok, package @xai-official/grok) is xAI's terminal coding agent:
Apache-2.0, headless (grok -p), ACP support, MCP, subagents, and a documented
custom-model config at ~/.grok/config.toml with base_url and env_key.
That custom-model block makes it a strong fit: a router can be wired in without
pretending to be xAI. The blockers are auth (XAI_API_KEY for headless use) and
the fact that Grok Build is still young and its config format can move.
What it needs:
- an adapter that writes
~/.grok/config.tomland disables auto-update; - a protocol decision: Grok's native API, OpenAI-compatible, or an Anthropic-compatible router if the CLI supports it;
- a pinned binary installed with checksum verification, not a runtime
curl | bash; - a smoke test for
grok -pwith a non-xAI base URL.
DeepSeek Harness¶
DeepSeek Harness (dsh) is DeepSeek's MIT-licensed, plugin-based agent harness.
Everything is a plugin — models, tools, sessions, even other harnesses — and it
has a headless profile (dsh --profile headless "job"), a web profile, and an
ACP profile.
It is powerful and unusually large (the npm install is in the hundreds of megabytes before plugins), and it is still a developer preview. That makes it a good candidate for a dedicated tag rather than the base image.
What it needs:
- a
:harnessor:base-dshtag with its ownDSH_HOMEand plugin profile; - a stable, pinned profile that does not fetch plugins at container start;
- a headless smoke test that proves the profile boots without the web UI;
- a policy for plugin downloads: image build time only, never task time.
Wave 2 — the long tail¶
These are real projects with real headless modes. They are later because they either duplicate an existing runtime, need a different execution model, or carry security decisions we do not want to rush.
Pi¶
Pi (pi) is a deliberately minimal terminal coding harness: a small core, four
default tools, TypeScript extensions, print/JSON/RPC modes, and an SDK. It is
MIT-licensed and has a strong "make it yours" philosophy.
Pi is interesting precisely because it is small. The catch is that it intentionally ships without a permission system or many of the guardrails other agents bundle, so the container has to provide the boundary.
What it needs:
- a generated
~/.pi/agent/models.jsoncustom provider, because Pi does not readANTHROPIC_BASE_URL; - print mode (
pi -p) and JSON event mode for the daemon adapter; - an explicit permission story: the container is the sandbox, and the task image must not assume Pi will ask before running a command;
- a decision on whether Pi's RPC mode is a better integration than one-shot print mode.
Oh-My-Pi¶
Oh-My-Pi (omp, package @oh-my-pi/pi-coding-agent) is a batteries-included
fork of Pi with LSP, DAP debugging, subagents, a browser tool, and 60+ providers.
It is MIT-licensed, runs on Bun, and has one-shot (omp -p), RPC, and ACP modes.
It is the opposite trade-off from Pi: much more capability, much more surface
area. It also currently defaults its tool approval mode to yolo, which is not
acceptable for a shared runtime without an explicit override.
What it needs:
- Bun in the image, or a verified standalone binary;
~/.omp/config.ymlgenerated withtools.approvalModeset toalways-askorwrite— neveryoloby default;~/.omp/models.ymlfor the custom provider; Oh-My-Pi honoursANTHROPIC_BASE_URL, but a generated model entry is more predictable;- a clear warning that it is a fast-moving fork, and a pinned version;
- a test that the approval mode is actually enforced, not just written to disk.
Hermes Agent¶
Hermes Agent (hermes) from Nous Research is an MIT-licensed, always-on personal
agent runtime: terminal UI, gateway, persistent memory, scheduled jobs, and
channels such as Telegram, Slack, and WhatsApp. It can read files and run
commands, but it is a general-purpose assistant harness, not a dedicated coding
CLI.
That makes it a different integration. It may be more useful as an orchestrator runtime that calls a coding CLI as a tool than as a direct Multica runtime. Running the gateway can also expose messaging channels, which is a security surface we would not enable in a worker image without an explicit opt-in.
What it needs:
- a headless, single-turn mode suitable for the daemon (or a small bridge);
- a gateway-off profile, with no messaging channels unless the operator asks;
- a separate
:hermestag, not the base image; - a clear threat model for persistent memory and channel credentials.
OpenClaw¶
OpenClaw (openclaw) is an open-source agent gateway with a node/exec model. It
has a genuine headless path: openclaw agent exec runs one embedded turn, supports
--cwd, --json, --model, and timeouts, and is explicitly documented for CI
and coding automation.
It is not a drop-in replacement for a coding CLI. It expects a gateway, a state
directory, provider configuration, and a permission model. The headless exec
path avoids the gateway, which is the part worth exploring.
What it needs:
- an
openclaw agent execadapter with a minimal, isolated config; --auth-env-only(or an equivalent) so no host credentials are reused;- a sandbox policy for filesystem and shell tools;
- a separate image or an optional layer — the gateway is too large and too stateful for every variant.
Watchlist¶
Not scheduled, but worth evaluating when the adapter layer exists:
| CLI | Why it is interesting | Main question |
|---|---|---|
| Gemini CLI | Apache-2.0, headless, huge reach | Google auth vs API key; protocol fit |
| Aider | Mature, git-centric, very predictable | No agent runtime lifecycle; one-shot bridge |
| Cline | Strong coding UX, open source | Primarily an IDE extension; CLI story |
| Goose | Block-backed, extensible, local-first | Runtime lifecycle and headless maturity |
| Crush | Charm's terminal agent, polished TUI | Headless mode and provider config |
| Amp | Strong agentic coding product | Licence and headless/API access |
| Continue | IDE + CLI, configurable providers | Headless runtime and task lifecycle |
| Roo Code / Kilo Code | Popular VS Code agent forks | IDE-first; CLI/headless path |
| OpenHands | Full agent platform, sandboxing | Heavy; better as a platform integration |
| SWE-agent | Research-grade issue solving | Batch job, not a long-running runtime |
| Codebuff | Open-source coding agent | Headless mode and runtime integration |
| Zed Agent | Fast editor-native agent | Editor-bound; ACP/headless story |
This list will change. The criteria at the top matter more than the names.
Image strategy for many CLIs¶
Putting every CLI in every image would make :base enormous and would register a
dozen runtimes in the dashboard. The plan is an adapter layer, not a pile of
npm install -g lines:
images/base/agents/
claude/install.sh configure.sh
codex/install.sh configure.sh
qwen/install.sh configure.sh
...
:basekeeps Claude Code + OpenCode as the default pair.- A
:agentstag (or per-CLI tags such as:base-codex) carries the extra harnesses until the shared adapter is proven. MULTICA_AGENT_CLIS=claude,opencodeselects which runtimes the daemon should register. Installing a CLI should not force it to appear in every workspace.- Each adapter owns its native config and its own override prefix (
CODEX_*,QWEN_*,GROK_*,DSH_*,PI_*,OMP_*,HERMES_*,OPENCLAW_*). AI_*remains the shared default. A per-CLI override wins when both are set.- Versions stay in
versions.env; no CLI updates itself at runtime.
The hard part is not installation. It is mapping one set of AI_* values onto
CLIs that disagree about protocols, model catalogues, auth headers, and what
"headless" means.
Autoscaler¶
The current autoscaler supports ECS and Swarm. See Autoscaling for the design discussion. The short version:
- Metrics exporter first. Expose pending/running tasks and desired workers
at
/metrics. That unlocks KEDA on Kubernetes and Azure Container Apps without writing a platform adapter. - Webhook adapter second. A signed
POSTwith the desired count lets users drive Nomad, Cloud Run, Fly Machines, Coolify, or anything else with a tiny receiver. - Nomad adapter third, if there is demand. It is a natural fit for on-premises and self-hosted clusters.
- Native Kubernetes adapter only if KEDA is not acceptable. Patching
Deployment.spec.replicasduplicates reconciliation that Kubernetes already does; KEDA is the better default. - Docker Compose standalone is not a target. Compose has no desired-state API. Use single-node Swarm, or a webhook receiver that manages named containers.
Later, a warm-pool mode could keep expensive toolchains (Flutter, PHP, design) warm during business hours and scale to zero outside them. That is a cost feature, not a correctness feature, so it comes after the metrics and webhook work.
Platform and supply chain¶
- Signed images — cosign signatures and a verification snippet in the docs, on top of the existing provenance and SBOM attestations.
- Digest-pinned examples — every deployment example should show a digest, not only a tag, for production.
- More stacks — Rust, .NET, Ruby on Rails, Elixir, and a data/ML image with Jupyter and common Python data tools.
- A smaller base — a
:slimtag without Chromium andbuild-essential, for agents that only read and write. - Structured logs and metrics — JSON log option, OpenTelemetry traces, and a
health endpoint deeper than
pgrepbut still independent of the AI router. - Secret providers — Docker secrets, AWS Secrets Manager, and SOPS as alternatives to environment variables, without baking values into images.
- Per-variant PR builds — build only the variants a pull request changes, instead of always building the base.
- arm64 runtime tests — build arm64 today; exercise the entrypoints under emulation or on native arm64 runners.
- Localized docs — Bahasa Indonesia first, then other languages, if there is demand.
- A
multica-runtime doctorcommand — validate config, endpoint, auth style, and model names before the daemon starts.
Not planned¶
- Auto-updating agent CLIs at runtime. Reproducibility matters more than freshness; a new CLI is a new image.
- Running as root. The design and PHP variants prove it is unnecessary.
- A built-in reverse proxy. The runtime has no inbound traffic.
- Bundling secrets into images. Ever.
- One image with every CLI enabled by default. It would be slow to build, slow to pull, and confusing in the dashboard.