fa5d470ae4
* feat(wecom): every notice reads the language of whoever will read it
The adapter's user-visible strings were Chinese literals scattered across
replier.go, inbox_message.go and outbound_media.go, so an English-reading member
got Chinese notices whatever their profile said. copyPack already existed for
the bubble's five stream strings; this moves the rest into it and resolves the
locale from the destination rather than the deployment.
Who decides, per surface:
- a 1:1 reply, the binding prompt, the inbox card: the reader's own profile
- a group notice: the room, which reads the deployment's language
- an attachment-failure notice: resolved on the request path and carried on
attachmentTarget, because the failure happens on a detached goroutine with
no context left to read a profile with
TestOnlyStringsGoHoldsUserVisibleCopy walks the package's AST and fails on any
Han literal outside strings.go. Two files are listed as pending with an exact
count: wecom_channel.go's unsupported-kind receipt and media_ingest.go's two
media notices, each moved by its own follow-up. The count is asserted both ways,
so the allowance cannot outlive the follow-up that consumes it.
* feat(wecom): every notice reads the language of whoever will read it
The adapter's user-visible strings were Chinese literals scattered across
replier.go, inbox_message.go and outbound_media.go, so an English-reading member
got Chinese notices whatever their profile said. copyPack already existed for
the bubble's stream strings; this moves the rest into it and resolves the locale
from the destination.
Who decides, per surface:
- a 1:1 reply, the binding prompt, the inbox card: the reader's own profile
- a group notice: the room, which reads the deployment's language
- an attachment-failure notice: resolved on the request path and carried on
attachmentTarget, because the failure runs on a detached goroutine with no
context left to read a profile with
The wiring is the part that has to hold: router.go passes Languages, and
NewOutboundReplier warns when it is nil, because a missing lookup has no other
symptom — nothing errors, nothing is empty, every notice simply comes out in one
language. TestWecomReplierGetsItsLanguageLookupOnTheRealBootPath asserts it off
NewRouter itself, with the anti-vacuity check read as a delta between two
routers rather than a count, since chat:done has listeners of its own.
TestOnlyStringsGoHoldsUserVisibleCopy walks the package AST and fails on any Han
literal outside strings.go, naming the two files whose copy has not moved yet
with an exact count, asserted both ways.
* MUL-7706 docs(wecom): drop the duplicated stream-field docs, refresh the lint header
The restored StreamNoReply block carried its opening paragraph twice, and the
lint file's header still described two rules and a greeting after the second
rule was dropped.
Co-authored-by: multica-agent <github@multica.ai>
* MUL-7706 test(wecom): compare two routers in the replier wiring guard
A bare chat:done count is non-zero whenever Slack or DingTalk is configured, so
the guard passed with the WeCom block never entered. Build one router without
the WeCom key and one with it, as wecom_bubble_wiring_test.go does, and require
the difference.
Co-authored-by: multica-agent <github@multica.ai>
* fix(wecom): a relayed reply's attachment notice reads the reader's language too
deliverRelayed builds its own attachmentTarget and never set Locale, so
copyFor("") fell back to the deployment pack. On a multi-replica deployment
that is the common path, not the exception: chat:done lands wherever the run
finished, and only the lease holder can write to the socket — so an English
reader whose file fails to upload got the Chinese notice, while the same
failure on the direct path was already answered in English.
Nothing else differs when this is wrong. The file still fails, the notice still
goes out, and no existing test covered the relayed case.
Also two wording fixes against the product glossary: /issue creates an issue,
not a task, so IssueUsage now reads like Slack's; and the task_failed inbox
label is 'Run failed', matching what the web inbox shows for the same
notification.
* MUL-7706 test(wecom): keep each attachment-notice test under its own doc comment
The relayed test was inserted between the direct test's doc comment and its
function, so the direct test lost its comment to the relayed one. Put the
direct test back under its comment, follow it with the relayed test, and move
the util import out of the standard-library group.
Co-authored-by: multica-agent <github@multica.ai>
* MUL-7706 test(wecom): the invoke-denied notice reads its one reader's language
A 1:1 refusal joins the per-outcome locale table; a group trigger's refusal,
sent to the sender's own 1:1, must read the sender's profile rather than the
room's deployment default.
Co-authored-by: multica-agent <github@multica.ai>
---------
Co-authored-by: Bohan-J <bhjiang@outlook.com>
Co-authored-by: multica-agent <github@multica.ai>
Multica
Agents that show up on the board.
Multica is a source-available 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 the agent CLIs you already use, 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.
- The agent CLIs you already use → 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.
- Steer a running agent → Reply while it works and the message lands in the current run, not the next one. Claude Code, Codex, and Grok today.
- Usage analytics → 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.
- Your Git host → GitHub, GitLab, Gitea, or Forgejo — self-hosted included.
- Workspaces → Separate agents, issues, and settings per team.
- Roles and access scopes →
owner,admin, andmember— and exactly which agents each member can run. - Security model → What an agent can reach, and what it can't.
- Slack, Feishu/Lark, DingTalk, WeCom, and Telegram → Trigger and follow agent work where your team already talks. New Feishu/Lark connections are open to mainland-China Feishu only for now; DingTalk, WeCom, and Telegram are community-maintained.
- Web, desktop, and mobile → The same workspace on macOS, Windows, Linux, iPhone, and iPad — the iOS app 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
- Cloud — sign up at multica.ai. No terminal required.
- Desktop — download Multica Desktop for macOS, Windows, or Linux. It connects the computer it runs on as a runtime automatically.
- Self-host — run the whole stack on your own infrastructure; see below.
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.
Self-hosting the whole thing
curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server
multica setup self-host
On Windows, set $env:MULTICA_MODE="with-server", then run the PowerShell installer:
irm https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.ps1 | iex.
This pulls the official images from GHCR and requires Docker. See the
Self-Hosting Guide; if the selected GHCR tag has not been published yet,
fall back to make selfhost-build from a checkout.
A self-hosted server sends one anonymous, deployment-level snapshot a day: the release version
plus bucketed counts, with no names, content, or IDs. Set DO_NOT_TRACK=1 on the API server to
turn it off — what's collected.
Your first agent in five minutes
1. 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.
2. 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.
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's done.
Full walkthrough: Quickstart · Tutorial
Runtimes
Multica does not ship a model. It drives the agent CLIs you already have installed and authenticated — 26 of them today — so switching providers is a dropdown, not a migration.
| Provider | CLI | Provider | CLI |
|---|---|---|---|
| Claude Code | claude |
OpenAI Codex | codex |
| Cursor Agent | cursor-agent |
GitHub Copilot CLI | copilot |
| OpenCode | opencode |
OpenClaw | openclaw |
| Hermes | hermes |
Pi | pi |
| Antigravity | agy |
CodeBuddy | codebuddy |
| DevEco Code | deveco |
Grok | grok |
| Kimi | kimi |
Kiro CLI | kiro-cli |
| Qoder CLI | qodercli |
Qoder CN | qoderclicn |
| Qwen Code | qwen |
QwenPaw | qwenpaw |
| Reasonix | reasonix |
Trae CLI | traecli |
| DeepSeek Harness | dsh |
Oh-My-Pi | omp |
| MiniMax Code | mcode |
Dim | dim |
| Huawei Cloud CodeArts | codearts |
ZeroClaw | zeroclaw |
Installing and authenticating them: Install an agent runtime · Providers
Documentation
| I want to… | Start here |
|---|---|
| Get an agent doing something today | Quickstart · Tutorial |
| Understand how the pieces fit | Core concepts · How Multica works |
| Create and configure agents | Agents · Create an agent · Skills |
| Get work to an agent | Triggering agents · Assigning issues · Mentions |
| Connect my machines | Daemon and runtimes · Install an agent runtime |
| Connect Git and chat tools | GitHub · Self-hosted Git · Channels |
| Run it on my own infrastructure | Self-hosting · Security model · Environment variables |
| Script it | CLI reference · CLI and daemon guide · Auth tokens |
| Drive Multica from Codex, Claude Code, or Cursor | Multica CLI skill |
| Work out why an agent is stuck | Runs · Troubleshooting |
The docs are also available in 简体中文, 日本語, 한국어, and Français.
Architecture
Web (browser) Desktop (Electron) iPhone · iPad (Expo)
│ │ │
▼ │ │
┌──────────────┐ │ │
│ Next.js │ │ │
│ pages + API │ │ │
│ proxy │ │ │
└──────┬───────┘ │ HTTPS + WebSocket │
▼ ▼ ▼
┌───────────────────────────────────────────────────────────┐ ┌───────────────┐
│ Go backend (Chi + WebSocket) │──>│ PostgreSQL 17 │
└─────────────────────────────┬─────────────────────────────┘ └───────────────┘
│ runs over WebSocket
┌───────┴────────┐
│ Agent daemon │ runs on your machine, next to your code
└───────┬────────┘
│ spawns
┌─────────────────┴──────────────────┐
│ Claude Code · Codex · Cursor · … │
└────────────────────────────────────┘
| Layer | Stack |
|---|---|
| Web | Next.js 16 (App Router) |
| Desktop | Electron, sharing the web UI packages |
| Mobile | Expo / React Native (iPhone and iPad) |
| Backend | Go (Chi router, sqlc, gorilla/websocket) |
| Database | PostgreSQL 17 (pgcrypto + pg_trgm) |
| Agent runtime | Local daemon executing any supported agent CLI |
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 device.
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.