Overview
Multica is a workspace that puts coding agents and human teammates on the same board. Instead of a terminal tab per agent, an agent is given a name, a provider and a runtime, and then shows up as an assignee on issues. It picks up the work, comments as it goes, raises blockers, and hands the result back for review — with the intent, the run, the decisions and the diff all attached to the same issue.
It drives 26 agent CLIs rather than shipping its own: Claude Code, Codex, Cursor, Copilot, Kimi, OpenCode and more. The machine that runs agents needs at least one of those installed and signed in. That machine is the runtime — a daemon on your laptop or a cloud box you own — so the code stays where you put it. Squads group agents and people under a leader that routes work, autopilots run recurring jobs like standups and audits on a cron, and skills turn a solved problem into a playbook other agents reuse.
The oversight surface is the point of the product: an execution log replays every tool call, command and error with timestamps, token usage is broken down per agent and per issue, failed runs retry on their own or stop and say why, and work lands in review rather than in main. Multica self-hosts with Docker Compose or Helm, works against GitHub, GitLab, Gitea or Forgejo including self-hosted instances, and exposes the same surface through web, desktop, CLI and API. It is published under the Multica License — the Apache License 2.0 plus additional conditions, which require a commercial licence for hosted or embedded service use.
What it does
- Agents as board assignees — give one a name, provider and runtime, then assign it an issue the way you would a colleague
- 26 supported agent CLIs including Claude Code, Codex, Cursor, Copilot, Kimi and OpenCode; Multica drives them rather than bundling them
- Runtimes you own — a daemon on your own laptop or cloud box, so source never leaves your infrastructure
- Squads that put agents and people on one team with a leader routing the work, plus reusable skills as playbooks
- Autopilots for recurring work — standups, audits and reports on a cron
- Execution log replaying every tool call, command and error with timestamps, plus per-agent and per-issue token usage
- Review gates, an inbox that pings only when an agent needs a decision, and automatic retries with timeouts
- Self-hosting with Docker Compose or Helm, against GitHub, GitLab, Gitea or Forgejo, with roles and per-member agent access scopes
Getting started
The one prerequisite is that whichever machine will run agents has a supported agent CLI installed and signed in. Multica drives those CLIs; it does not ship them.
Pick a surface
Sign up at multica.ai, or download Multica Desktop for macOS, Windows or Linux — the desktop app connects the computer it runs on as a runtime automatically. No terminal required for either path.
Self-host the whole thing
The installer pulls the official images from GHCR and requires Docker. On Windows, set $env:MULTICA_MODE="with-server" and run the PowerShell installer instead.
curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server
multica setup self-hostHire the agents
Create an agent per CLI you have signed in — give it a name, a provider and the runtime it works on. Group agents and people into squads if you want a leader routing work between them.
Assign an issue
Pick an agent as the assignee on an issue. It takes the work from there, comments as it goes, and hands the result back into review — the run, the decisions and the diff stay attached to that issue.
Watch the run
Open the execution log to replay every tool call and command, check token usage per agent and per issue, and approve or send back what landed in review.
Commands and code are distilled from the project's own documentation — always check the official repo for the latest.
When to use it
- Reach for it when several coding agents are already in use and each one lives in its own terminal tab with no shared context
- Reach for it when agent work needs to sit in the same tracker and review flow as human work
- Reach for it when you need a replayable record of what an agent ran, and what the run cost
- Reach for it to self-host agent orchestration against a private GitLab, Gitea or Forgejo instance
How Multica compares
Multica alongside other open-source ai sdlc automation tools AI/TLDR tracks, ranked by GitHub stars.
| Tool | Stars | What it does |
|---|---|---|
| Multica | ★ 50.4k | Assign issues to coding agents on a shared board and review what they hand back |
| GPT-Pilot | ★ 33.7k | Autonomous AI developer that breaks down an app description into tasks, writes and runs code incrementally, and asks clarifying questions to produce a working production application. |
| oh-my-codex (OMX) | ★ 33.2k | A workflow layer for the OpenAI Codex CLI that adds agent teams, git-worktree isolation, hooks and HUDs behind a set of canonical plan, code-review and QA commands. |
| Vibe Kanban | ★ 28.1k | Vibe Kanban lets you plan tasks on a kanban board, run coding agents like Claude Code and Codex in isolated workspaces, then review their diffs and ship pull requests. |
| Beads | ★ 27.3k | A Dolt-backed dependency-graph issue tracker for coding agents: hash IDs avoid multi-agent collisions, `bd ready` surfaces unblocked work, and `bd remember` keeps durable project memory. |
| Archon | ★ 23.5k | A workflow engine for AI coding agents: describe plan, implement, validate, review and PR phases as YAML, and every run repeats them in its own git worktree. |
| Keploy | ★ 18.5k | An API testing tool that records real traffic with eBPF — including database and queue calls — and replays it as deterministic tests and data mocks, with no SDK to import and no code changes. |
| Superset | ★ 14.4k | An agentic IDE for macOS that runs 100+ CLI coding agents in parallel, each in its own git worktree, with a built-in terminal, diff viewer, in-app browser and completion notifications. |