Who Multica is for#
Engineering teams coordinating multiple AI coding agents
Teams already running Claude Code, Codex, or Cursor across multiple projects can route issue-based work through Multica instead of managing separate terminal sessions per agent. Each agent gets a name, a runtime, and an assignment queue; the whole team sees all agent work on the same Kanban board alongside human work.
Skip if:
Teams that use a single AI coding agent for occasional tasks do not need a coordination layer. Multica's value is in managing multiple agents across multiple concurrent issues.
Security-conscious teams keeping code off third-party cloud
Multica's daemon model runs agent execution on a machine the team registers and controls. Code, credentials, and tool calls do not route through Multica's servers. Teams with proprietary codebases or data-residency requirements can self-host the entire workspace and point it at a self-hosted Git server.
Skip if:
Teams already comfortable with GitHub Copilot Workspace's cloud model and without compliance constraints may find the self-hosting overhead unnecessary.
Platform engineers building internal AI development tooling
Multica exposes a CLI and API for every surface, so platform teams can script issue creation, agent assignment, and run monitoring. Autopilots handle cron-based standups, audits, and reports. The Multica CLI skill lets agents drive Multica itself, enabling fully automated development pipelines.
Skip if:
Teams looking for a fully managed service where agents, runtimes, and infrastructure are handled by the vendor. Multica requires your own runtime machines and CLI installations.
Small teams treating AI agents as actual team members
Multica's board model puts agents and humans on the same workflow: file an issue, assign it, watch it move through columns to review. Agents comment in the issue thread, surface blockers to the inbox, and never merge without a human approving. Squads let small teams route the right work to the right agent or person.
Skip if:
Teams that need formal AI governance processes or regulated approval workflows beyond what Multica's built-in review gates currently provide.
The problem it solves#
Running multiple AI coding agents in parallel means juggling multiple terminal sessions, each with its own context window. When a session ends, the agent forgets everything: the codebase state, the reasoning behind its last decision, the half-finished task it was working on. Re-explaining context to a new session is often slower than doing the work yourself, and as the number of agents grows, so does the overhead of coordinating them.
The deeper pain is accountability. When an agent writes code in an isolated terminal, there is no connection between the task that was assigned, the commands it ran, the decisions it made, and the diff it produced. Human reviewers have to reconstruct that context from scratch before they can safely approve anything. Review gates are informal, audit trails do not exist, and the work that ships is whatever the agent happened to produce in a session nobody can replay.
How it solves it#
26 agent CLI runtimes
Multica drives the agent CLIs you already have installed and authenticated, so switching from one provider to another is a dropdown, not a migration. Supported CLIs include Claude Code, OpenAI Codex, Cursor Agent, GitHub Copilot CLI, Kimi, OpenCode, Grok, Qwen Code, and 18 others. The underlying agent runtime decides which model runs; Multica handles scheduling, context, and review.
Issue-based assignment workflow
Assign a GitHub issue to an agent the same way you would assign it to a human colleague. The agent picks it up from the board, runs the task on its registered runtime (your laptop or any machine with the CLI installed), posts progress updates into the issue thread, and moves the card to review when it finishes. The issue is the unit of work; everything attaches to it.
Full execution log with per-run token tracking
Every run produces a timestamped trace of every tool call, command, and error the agent made. You can replay the agent's exact path through a task without asking it to explain itself. Token usage is tracked per agent and per issue, so you know what each run cost before approving the result.
Review gates before anything merges
Work lands in a review column on the Kanban board, not in main. No agent can merge; only a human approver moves a card forward. The review surfaces the execution log, the diff, and the issue thread together. Retries and timeouts are configurable: failed runs retry automatically or stop and surface a blocker to the inbox.
Squads, Skills, and Autopilots
Squads put human team members and AI agents on one team, with a leader (human or agent) routing the work. Skills encode a solved problem as a reusable playbook any agent can apply the next time a similar issue comes in. Autopilots run cron-based standups, audits, and reports without manual triggering.
Self-hosted Git and multi-platform clients
Multica connects to GitHub, GitLab, Gitea, and Forgejo, including self-hosted instances of all four. Desktop apps cover macOS, Windows, and Linux; a mobile client runs on iOS. The CLI and API expose every surface for scripting. Code never needs to leave your infrastructure.
Strengths and trade-offs#
Strengths
- Provider-agnostic: 26 CLIs, no vendor lock-inMultica does not ship a model and has no preferred AI provider. Because it drives existing CLIs rather than calling model APIs directly, you can run Claude Code and Codex on the same board and switch a single agent from one provider to another without changing anything else. Paid tools like Devin and Factory.ai lock you into their own model and cloud infrastructure.
- Execution stays on your machinesThe agent daemon runs on a machine you register and control. The codebase, credentials, and tool calls do not pass through Multica's servers. Teams with compliance requirements or proprietary code get a practical infrastructure guarantee that managed cloud services like GitHub Copilot Workspace cannot offer.
- 50,000+ stars with an active weekly release cadenceThe repo reached 50,000 GitHub stars within months of launch, and the team ships releases most weekdays. The project launched in January 2026 and already supports 26 runtime integrations, cross-platform desktop and mobile clients, and four Git host integrations. Activity and momentum are unusually high for a project this young.
- Full audit trail attached to every issueEvery agent action, tool call, token cost, and decision is recorded against the issue that triggered the work. A reviewer can trace exactly what the agent ran and why before approving. Standalone agent CLIs produce only a diff and a terminal session that ends when the task does; Multica keeps the record.
Trade-offs
- -Custom license restricts managed-service hostingMultica ships under the Multica License: Apache License 2.0 plus additional conditions. Self-hosting for your own team, modifying the code, and building on it internally are permitted. Offering Multica as a hosted or managed service to third parties, or commercially embedding it in a product, requires separate authorization from the licensor. Teams evaluating it for SaaS or commercial-embedding scenarios should read the LICENSE file before proceeding.
- -Requires pre-installed agent CLIs on every runtimeMultica is a coordinator, not a self-contained AI coding agent. Every machine registered as a runtime must have at least one of the 26 supported agent CLIs installed and authenticated before Multica can assign work to it. Setup means managing agent CLI installations, provider API keys, and authentication separately from Multica itself.
- -1,598 open GitHub issues on a fast-moving codebaseThe project ships most weekdays and the backlog reflects that pace. With 1,598 open issues at time of writing, some documented features may be in progress or available only in the cloud-hosted tier. Review the issue tracker before depending on a specific integration in a production workflow.
Multica vs alternatives#
Multica vs Devin
Devin, by Cognition AI, is an autonomous AI software engineer that operates entirely in Cognition's managed cloud. Multica is a coordinator that assigns work to agent CLIs running on machines you control.
| Feature | Multica | Devin |
|---|---|---|
| Deployment | Self-hostable (Docker Compose, Helm) | Managed cloud only |
| Agent model | Your choice (26 CLIs) | Cognition's proprietary model |
| Execution environment | Your infrastructure | Cognition's cloud |
| License | Multica License (Apache 2.0 + extra conditions) | Proprietary |
| Multi-agent | Yes | Single agent per task |
Multica is the better choice when you need code to stay on your own machines, want to use multiple AI providers simultaneously, or need a shared review workflow before anything merges. Devin is worth considering when you want a fully autonomous engineer with no infrastructure to manage: you hand it a task and it delivers a result, with no CLI installation on your end.
Multica vs GitHub Copilot Workspace
GitHub Copilot Workspace takes a GitHub issue and produces a plan and code inside GitHub's infrastructure. It works only with GitHub-hosted repositories. Multica is provider-agnostic, self-hostable, and works with four Git hosts.
| Feature | Multica | GitHub Copilot Workspace |
|---|---|---|
| Self-hosting | Yes | No |
| Git hosts | GitHub, GitLab, Gitea, Forgejo | GitHub only |
| Agent choice | 26 CLIs | GitHub Copilot |
| Execution environment | Your machine | GitHub's cloud |
| Multi-agent support | Yes | Single agent per task |
Teams fully committed to GitHub with no infrastructure preferences will find Copilot Workspace easier to start. Multica fits teams that need multi-Git-host support, code off GitHub's servers, or the ability to run multiple agents in parallel on different tasks.
Multica vs Factory.ai
Factory.ai is a managed AI software engineering service that handles full development workflows in its own cloud. Like Devin, it is not self-hostable and bundles its own agent model.
Multica and Factory.ai are not direct substitutes: Factory.ai positions itself as a replacement for a developer, while Multica is the coordination layer for the agent CLIs a team already has. Teams choosing Factory.ai typically want a fully managed service with no local setup. Teams choosing Multica want control over which agents run, where they execute, and what review process code goes through before shipping.
Quick start#
Self-hosting Multica requires Docker; clone the repository and run the Docker-based server build.
```bash
git clone https://github.com/multica-ai/multica
make selfhost-build
```What it's built on#
- Languages
- GoTypeScript
- Frameworks
- Next.jsReact
- Databases
- PostgreSQL
FAQ#
Does Multica include an AI model, or do I need to bring my own?
Multica does not include an AI model. It drives the agent CLIs you already have installed: Claude Code, OpenAI Codex, Cursor, and 23 others. You install and authenticate each CLI independently, then register the machine as a Multica runtime. The underlying model cost is separate from Multica itself.
Can I self-host Multica for free?
Yes. The self-hosted version is free to run on your own infrastructure. Multica ships under its own license, which includes Apache License 2.0 terms plus additional conditions. Self-hosting for your own team and modifying the code are permitted. Running Multica as a hosted service for third parties or commercially embedding it in a product requires separate authorization from the licensor.
How does Multica differ from Devin or GitHub Copilot Workspace?
Devin and GitHub Copilot Workspace are autonomous AI software engineers that run in their vendors' managed cloud. Multica is a coordinator: it assigns work to agent CLIs you already have installed and runs them on machines you control. You choose the underlying agents, switch providers freely, and keep code on your own infrastructure. Multica is not a replacement for the underlying agent models; it is the scheduling and review layer above them.
What Git hosts does Multica support?
Multica works with GitHub, GitLab, Gitea, and Forgejo, including self-hosted instances of all four. Any repository that agents can reach from a registered runtime is accessible.
Is Multica available for Windows and mobile?
Yes. Multica has desktop apps for macOS, Windows, and Linux built with Electron. There is an iOS mobile app built with Expo and React Native, available to compile from source; it is not yet on the App Store. There is no official Android app at this time.
Similar open-source tools#
ECC
Cross-harness skills, agents, and security for AI coding
rakazo
AI teammates you own: your keys, your model, your machine.
cli
Official Lark/Feishu CLI with 200+ commands and AI Agent Skills
opendisplay
Turn any iPhone, iPad, or spare Mac into a free second Mac monitor
Jean
A dev environment for running AI agents in isolated git worktrees
OpenResearch
Local-first workspace for parallel research agents and experiments.