OPEN SOURCE DEEP DIVE
Multica: AI coding agents that show up on the board
An open-source, self-hostable workspace where you assign issues to AI coding agents the way you would to a teammate: they pick up the work, run on a runtime you control, comment as they go, and hand results back for review. Works with 26 agent CLIs and keeps intent, runs, decisions and diffs on one issue, with code never leaving your machine.
What it is
Multica's own line is "agents that show up on the board": an open-source workspace where you assign an issue to an AI coding agent the way you would assign it to a teammate. The agent picks the work up on its own, runs it on a runtime you control, comments as it goes, and hands the result back for review. It has more than 51,000 stars, is self-hostable, works with 26 agent CLIs, and does not lock you in.
The pain it names is concrete: you already run Claude Code, Codex and three other agents, each in its own terminal tab, each forgetting everything when the session ends, each leaving 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's answer is to put those agents and your human teammates in one workspace, so the intent, the run, the decisions and the diff all stay attached to the same issue - nobody reconstructs context, and nothing ships without a human saying so.
The design that actually matters: the runtime is your machine
The load-bearing claim is "their desk is your machine". Agents run inside a daemon on your laptop or cloud box, so code never leaves it. That single choice solves two problems at once: under self-hosting your source does not transit a third party, and the agent has direct access to the toolchain you already installed and authenticated locally.
The companion rule is that Multica ships no model. It drives the agent CLIs already installed and signed in on that machine, so switching providers is a dropdown, not a migration. The README table lists 26 of them: Claude Code (claude), OpenAI Codex (codex), Cursor Agent (cursor-agent), GitHub Copilot CLI (copilot), OpenCode, OpenClaw, Hermes (hermes), Pi (pi), Antigravity, CodeBuddy, DevEco Code, Grok, Kimi, Kiro CLI, Qoder, Qwen Code, Reasonix, Trae CLI, DeepSeek Harness (dsh), Oh-My-Pi, MiniMax Code (mcode), Dim and Huawei Cloud CodeArts. Read as a list rather than as a feature, that table is a current census of the agent-CLI ecosystem.
Above the board: squads, skills, autopilots
Three concepts lift "assign work to an agent" into team territory. Squads put agents and people on one team with a leader who routes the work, so dispatch stops being a manual act. Skills turn a solved problem into a playbook every agent reuses - the same problem Hermes solves by growing skills autonomously, answered here by having humans write them down and share them. Autopilots run standups, audits and reports on a cron, with nobody to remind anyone.
The supervision layer is built out rather than nominal: the execution log replays every tool call, command and error with timestamps; token usage is visible per agent and per issue; work lands in review rather than in main, so a human decides what ships; the inbox pings you when an agent needs a decision instead of at every step; and failed runs retry on their own or stop and explain why.
Architecture and governance
The stack is a Next.js 16 (App Router) frontend, a Go backend (Chi, sqlc, gorilla/websocket) and PostgreSQL 17 with pgcrypto and pg_trgm. Desktop is Electron sharing the web UI packages; mobile is Expo / React Native, and iOS builds from source today rather than shipping on the App Store. Tasks travel over WebSocket to the agent daemon on your machine, which spawns the concrete agent CLI. Every surface is scriptable, and agents drive Multica through the same CLI you do.
Governance covers three roles (owner, admin, member) plus per-member access scopes that decide exactly which agents each member may run. On the Git side it supports GitHub, GitLab, Gitea and Forgejo including self-hosted instances; on the messaging side Slack, Lark, DingTalk, WeCom and Telegram, with the last three community-maintained. Self-hosting is Docker Compose or Helm with images pulled from GHCR.
Its own position, and ours
The name comes from Multics, the 1960s operating system that introduced time-sharing so several people could use one machine as if each had it alone. The project's argument is that software teams have been single-threaded ever since - one engineer, one task, one context switch at a time - and that agents make time-sharing relevant again, except the users multiplexing the system are now both humans and machines. "Your next 10 hires won't be human" is the attitude; the longer case is in VISION.md.
The licence deserves a separate note: it is the complete Apache License 2.0 text plus additional conditions covering hosted services, commercial embedding and branding. That differs from a plain MIT or Apache-2.0 project - self-hosting, modification and building on it are fine, but read LICENSE and NOTICE before offering it as a service.
We have not benchmarked or reproduced Multica. It sits on the same layer as herdr, Orca and Paperclip but at a different cut: herdr takes over terminal processes, Orca takes over working directories and branches, Multica turns the workflow into issues on a board, and Paperclip goes one level higher and turns a team of agents into a company. Its star count and its position in that ecosystem mean it has to be carried. Capability level is graded as needing reproduction.