# Multica

> Assign issues to coding agents on a shared board and review what they hand back

- Category: AI Coding / AI SDLC Automation
- Language: Go
- Licence: Multica License (Apache-2.0 with additional conditions)
- Repository: https://github.com/multica-ai/multica
- Website: https://multica.ai
- Canonical page: https://ai-tldr.dev/tools/multica/
- Updated: 2026-01-13

## In short

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 sits in the AI SDLC Automation category of the AI Coding tools and is open-source, written in Go and licensed Multica License (Apache-2.0 with additional conditions).

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

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

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

```bash
curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server
multica setup self-host
```

3. Hire 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.

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

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

## 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

## Version history

- 2026-01-13: Covered by AI/TLDR: a vendor-neutral, self-hosted platform that turns coding agents into teammates on a project board, letting you assign issues to Claude Code, Codex and other agent CLIs and watch them report progress and blockers.