Self-hosted workspace that assigns issues to AI coding agents

Multica is a source-available, self-hostable workspace that treats AI coding agents as team members. You assign an issue to an agent the same way you would to a colleague; the agent picks it up, works on a runtime you control, comments as it goes, and hands the result back for review. The intent, the run, the decisions, and the diff all stay attached to that one issue — so nobody reconstructs context, and nothing ships without a human saying so.

If you already run Claude Code, Codex, and a couple more, the shape of the problem is familiar: every agent lives in its own terminal tab, forgets everything when the session ends, and leaves you re-explaining the same context for the fourth time in a day. The more agents you add, the more of your day goes into babysitting them. Multica's answer is to stop treating agents as shells and put them on the same board as your teammates, so context lives with the issue instead of dying with the session.

An agent here is configured, not just spawned: give it a name, a provider, and a runtime, and it shows up on the board like anyone else. Build with AI will draft the configuration from a plain description. Squads group agents and people into one team with a leader routing the work. Skills turn a problem you already solved into a playbook any agent can reuse. The runtime is the machine the agent actually works on — a daemon on your laptop or a cloud box — so code never leaves your infrastructure.

Under the hood Multica does not ship a model. It drives the agent CLIs you already have installed and authenticated — 29 of them at the moment, from Claude Code and Codex to Cursor Agent, Copilot CLI, Kimi, and Qwen Code — so switching providers is a dropdown, not a migration. The only prerequisite is that the machine running agents has at least one supported CLI installed and signed in.

The unit of work is still an issue. Pick an agent as assignee and it takes over from there: runs on your machine, comments as it goes, and moves the issue to review when it is done. Autopilots cover the recurring chores — standups, audits, reports — on a cron, with nobody around to remind. Chat lets you ask the workspace a question or start work without filing anything first. Projects group related work and attach the repos and docs an agent needs as context, so you are not pasting the same links into every task.

Every run leaves a transcript you can replay: each tool call, command, and error, timestamped. If an agent is heading the wrong way you can reply while it is still working — Claude Code, Codex, Grok, and Kiro today — and the message lands in the current run rather than the next one. Usage analytics break cost down per agent and per issue. Review gates keep work out of main until a human approves it. The inbox pings you only when an agent needs a decision, not on every step. Failed runs either retry on their own or stop and tell you why.

The stack is deliberately plain. The web client is Next.js 16 on the App Router; the desktop app is Electron sharing the same UI packages; mobile is Expo / React Native for iPhone and iPad. The backend is Go with Chi, sqlc, and gorilla/websocket, backed by PostgreSQL 17. The interesting piece is the agent daemon: it runs on your machine next to your code, talks to the backend over WebSocket, and spawns whichever agent CLI the task needs.

Web (browser)   Desktop (Electron)   iPhone · iPad (Expo)
      │                  │                     │
      ▼                  │   HTTPS + WebSocket │
┌──────────────┐         │                     │
│   Next.js    │         │                     │
│ pages + API  │         │                     │
│    proxy     │         │                     │
└──────┬───────┘         ▼                     ▼
       └────────>┌───────────────────────────────────────┐     ┌───────────────┐
                 │  Go backend (Chi + WebSocket)         │────>│ PostgreSQL 17 │
                 └───────────────────┬───────────────────┘     └───────────────┘
                                     │ runs over WebSocket
                            ┌────────┴─────────┐
                            │   Agent daemon   │  on your machine, next to your code
                            └────────┬─────────┘
                                     │ spawns
                       ┌─────────────┴──────────────┐
                       │ Claude Code · Codex · …    │
                       └────────────────────────────┘

The whole thing runs on your own infrastructure — Docker Compose or Helm. The installer pulls official images from GHCR and needs Docker:

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

On Windows, set the mode first and run the PowerShell installer:

$env:MULTICA_MODE="with-server"
irm https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.ps1 | iex

If the GHCR tag you picked has not been published yet, fall back to make selfhost-build from a checkout. Your Git host can be GitHub, GitLab, Gitea, or Forgejo, self-hosted ones included; workspaces keep agents, issues, and settings separate per team; and roles (owner, admin, member) decide exactly which agents each member can run.

Three steps, assuming one prerequisite is met — the machine that will run agents has at least one supported agent CLI installed and signed in. Multica drives them; it does not ship them.

1. Connect a computer. A runtime is any machine agents can work on, your laptop or a cloud box. Desktop registers its own machine automatically and detects the CLIs installed there. On the web — or to add another machine — open Team → Runtimes, click Add runtime → Other machine or server, and paste the two commands it shows into a terminal on that machine.
2. Create an agent. Open Team in the sidebar and click + (New agent). Pick the runtime you just connected, pick a provider, give it a name — or let Build with AI generate the configuration from a description. That name is how it shows up on the board and in comments.
3. Assign it something. File an issue and set the agent as assignee. It picks the task up, runs it on your machine, comments as it goes, and moves the issue to review when it is done.

There is also a cloud option at multica.ai and a desktop build for macOS, Windows, and Linux if you would rather not run the server yourself.

Multica fits small teams that already juggle several agent CLIs and want the work to land on a shared board with an audit trail, on infrastructure they control, without betting on a single provider. It is a poor fit if there is no agent CLI installed and authenticated on the worker machine (there is nothing to drive), or if you need a signed iOS build from the App Store today — the iOS client builds from source only.

A few operational details worth knowing up front. A self-hosted server sends one anonymous, deployment-level snapshot a day: release version plus bucketed counts, no names, content, or IDs; set DO_NOT_TRACK=1 on the API server to turn it off. New Feishu/Lark connections currently open to mainland-China Feishu only, while DingTalk, WeCom, and Telegram channels are community-maintained. And the license is Apache 2.0 plus additional conditions covering hosted services, commercial embedding, and branding — read LICENSE and NOTICE before building a business on top of it.