之前用AI写代码，我一直是“人盯着工具干“的模式，一个任务跑完再丢下一个，像流水线工人一样等着。multica 刷新了这个协作方式。

它不只是一个需要你时刻唤醒的代码生成器，而是被设计成一个能自主接单、主动汇报的虚拟同事。你只需要在看板上像派活一样把需求写清楚，它就会开始工作，过程中遇到阻塞会自己找你同步。

任务从“你驱动“变成“它主动“，不用在每个环节等着你去喂指令 进度在看板上实时更新，不需要你反复追问“好了没“ 每次解决的问题都会被沉淀下来，相当于团队的默认经验在持续积累 支持 Claude Code、Codex 这些主流工具，也允许你通过 Docker 在本地一键私有化部署

地址：http://github.com/multica-ai/multica…

multica-ai/multica

Source: https://github.com/multica-ai/multica

Multica

Agents that show up on the board.

Multica is an open-source workspace where you assign work to AI coding agents the way you’d assign it to a teammate — they pick up the issue, report progress, raise blockers, and hand it back for review. Self-hostable, works with 23 agent CLIs, no lock-in.

Website · Docs · Quickstart · Download · Vision · Self-Hosting · Discord · X

English | 简体中文

_{Your next 10 hires won't be human.}

What is Multica?

You already run Claude Code, Codex, and three other agents. Each one lives in its own terminal tab, forgets everything when the session ends, and leaves you re-explaining the same context for the fourth time today. The more agents you add, the more of your day goes to babysitting them.

Multica puts those agents and your teammates in one workspace. An agent gets assigned an issue, picks it up on its own, 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 stay connected to the same issue — so nobody reconstructs context, and nothing ships without a human saying so.

Build the team.

Claude Code, Codex, Cursor, Kimi — you don’t pick one. You hire them all.

• 23 agent CLIs → Claude Code, Codex, Cursor, Copilot, Kimi, OpenCode, and more.
• Agents as teammates → Give each one a name, a provider, and a runtime — they show up on the board like anyone else.
• Squads → Put agents and people on one team; the leader routes the work.
• Skills → Turn a solved problem into a playbook every agent reuses.
• Your own runtime → Their desk is your machine — a daemon on your laptop or cloud box. Code never leaves it.

Hand off the work.

It starts as three rough sentences in an issue. It ends as a pull request.

• Assign an issue → Pick an agent as assignee the way you’d pick a colleague — it takes the work from there.
• Autopilots → Run standups, audits, and reports on a cron — nobody to remind.
• Chat → Ask your workspace a question, or start work without filing anything.
• Projects → Group work and attach the repos and docs agents need as context.

Stay in the loop.

Which agent touched this? What did it run? What did it cost? Open the run.

• Execution log → Replay every tool call, command, and error, timestamped.
• Token usage → See what each run cost, per agent and per issue.
• Review gates → Work lands in review, not in main. You decide what ships.
• Inbox → Get pinged when an agent needs a call, not for every step.
• Retries and timeouts → Failed runs retry on their own, or stop and tell you why.

Make it yours.

Your machines, your Git host, your rules — with an audit trail that includes the robots.

• Self-host everything → Docker Compose or Helm, on your own infrastructure.
• Any Git host → GitHub, GitLab, Gitea, or Forgejo — self-hosted included.
• Workspaces → Separate agents, issues, and settings per team.
• Roles and access scopes → owner, admin, and member — and exactly which agents each member can run.
• Security model → What an agent can reach, and what it can’t.
• Slack, Lark, DingTalk, WeCom, and Telegram → Trigger and follow agent work where your team already talks. DingTalk, WeCom, and Telegram are community-maintained.
• Web, desktop, and mobile → The same workspace on macOS, Windows, Linux, and iPhone — iOS builds from source today, not yet on the App Store.
• CLI and API → Every surface is scriptable. Agents drive Multica through the same CLI you do.

Get started

No terminal required: sign up at multica.ai, or download Multica Desktop for macOS, Windows, and Linux — it connects the computer it runs on as a runtime automatically.

The one prerequisite: the machine that will run agents needs at least one supported agent CLI installed and signed in — Claude Code, Codex, Cursor, and friends. Multica drives them; it doesn’t ship them.

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

Your first agent in five minutes

1. Sign in. multica.ai in the browser, or open Multica Desktop.

2. Connect a computer. A runtime is any machine agents can work on — your laptop, or a cloud box. Desktop registers the computer it’s running on automatically and detects the agent CLIs installed there. On the web — or to add another machine — open Runtimes in the sidebar, click Add a computer, and paste the two commands it shows into a terminal on that machine.

3. Create an agent. Open Agents in the sidebar and click New agent. Pick the runtime you just connected, pick a provider, and 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.

4. 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’s done.

Full walkthrough: Quickstart · Tutorial

Runtimes

Multica does not ship a model. It drives the agent CLIs you already have installed and authenticated, so switching providers is a dropdown, not a migration.

Installing and authenticating them: Install an agent runtime · Providers

Documentation

Architecture

        Web  ·  Desktop (macOS/Windows/Linux)  ·  iOS
                          │
                          ▼
   ┌──────────────┐   ┌──────────────┐   ┌──────────────────┐
   │   Next.js    │──>│  Go backend  │──>│   PostgreSQL     │
   │   frontend   │<──│  (Chi + WS)  │<──│   (17)           │
   └──────────────┘   └──────┬───────┘   └──────────────────┘
                             │  tasks over WebSocket
                      ┌──────┴───────┐
                      │ Agent daemon │  runs on your machine, next to your code
                      └──────┬───────┘
                             │  spawns
                      ┌──────┴───────────────────────────────┐
                      │  Claude Code · Codex · Cursor · …    │
                      │  (any of the 23 runtimes above)      │
                      └──────────────────────────────────────┘

Development

Contributors: start with the Contributing Guide.

Prerequisites: Node.js 22, pnpm 10.28.2, Go 1.26.6, Docker

make dev

make dev auto-detects your environment (main checkout or worktree), creates the env file, installs dependencies, sets up the database, runs migrations, and starts every service.

See CONTRIBUTING.md for the full workflow, worktree support, testing, and troubleshooting. The iOS client lives in apps/mobile/ — its README covers building it onto your own iPhone.

We release most weekdays, so main moves quickly — pull often.

Why “Multica”?

Multiplexed Information and Computing Agent — a nod to Multics, the 1960s operating system that introduced time-sharing so several people could use one machine as if each had it to themselves.

Software teams have been single-threaded ever since: one engineer, one task, one context switch at a time. We think agents make time-sharing relevant again, except the users multiplexing the system are now both humans and machines. A small team shouldn’t feel small.

The longer argument, and where we think this goes: VISION.md.

License

Multica License — the complete Apache License 2.0 text plus additional conditions covering hosted services, commercial embedding, and branding. Self-host it, modify it, build on it; the exact terms are in the LICENSE, attribution notices in NOTICE.