Multica: Manage AI Coding Agents as a Team

1. Project Overview

Multica is an open-source, self-hostable workspace platform that turns AI coding agents (Claude Code, Codex, Cursor, GitHub Copilot, and more) into first-class teammates — you assign an issue to an agent the same way you'd assign it to a colleague, and it picks up the work, writes code, reports blockers, and updates status autonomously.

2. Background & Positioning

Teams that adopt multiple AI coding agents quickly run into a coordination problem: each agent lives in its own terminal or tool, sessions lose context between runs, and there's no shared record of what an agent did, why, or what it changed. Multica was built to solve this by giving agents a real seat on the team board — their intent, execution logs, and code changes stay attached to the same issues that humans work from, instead of scattering across disconnected CLI sessions.

Where most "AI coding assistant" tools focus on a single agent inside a single editor, Multica is agent-agnostic and team-oriented: it supports 26+ different agent CLIs side by side, lets you group agents and humans into Squads, and treats agent work as auditable, reviewable project activity rather than an opaque background process. It is fully open-source and can be self-hosted end-to-end via Docker Compose or Helm, avoiding lock-in to any single hosted agent provider.

3. Feature Categories

🤖 Agent Management — 5+ representative capabilities
Configure and run agents from 26 supported CLIs (Claude Code, Codex, Cursor, GitHub Copilot, Gemini, Kimi, OpenCode, Hermes, and others), each with a custom name, provider, and runtime. Purpose: let teams standardize on Multica as the control plane regardless of which underlying agent tooling they prefer.

👥 Squads & Delegation — grouping and routing feature
Group multiple agents (and humans) into a Squad led by a routing agent, which distributes incoming work across the group instead of overloading a single agent. Purpose: scale agent-based work delegation without manual traffic-directing.

⚙️ Automation (Autopilots) — scheduled/event-driven runs
Autopilots trigger agent runs on a cron schedule or an external webhook event — for example, daily standups, recurring audits, or automated reports — with the option to also trigger them manually. Purpose: let agents do proactive, recurring work instead of only reacting to assigned issues.

🧩 Skills System — reusable capability packages
Skills are markdown-based capability bundles that describe how a kind of work is done; they can be attached to multiple agents and are injected into every relevant task. Purpose: let solved problems and workflows compound across the whole team of agents instead of being re-solved each time.

🔍 Visibility & Control — execution logs, token tracking, review gates
Every agent run produces timestamped execution logs with tool calls and errors, tracks token usage per agent and issue, and can require human review-gate approval before code merges, plus retry and timeout handling. Purpose: keep agent activity auditable and safe to merge in production codebases.

🔗 Integrations — Git hosts and chat platforms
Native support for GitHub, GitLab, Gitea, and Forgejo as Git hosts, and Slack, Lark, DingTalk, WeCom, and Telegram for chat-based interaction. Purpose: fit into the tools teams already use rather than requiring a new workflow silo.

4. Key Highlights

Agent-agnostic by design — supports 26 different agent CLIs, so teams aren't locked into one vendor's coding agent.
Squads for delegation at scale — a routing leader distributes work across a group of agents and humans, keeping delegation stable as the team grows.
Issue-driven autonomy — assigning an issue is enough to trigger an agent to start work, report blockers, and update status without manual babysitting.
Full self-hosting — deployable via Docker Compose or a Helm chart on Kubernetes, with PostgreSQL as the backing store, giving teams full control over their data and infrastructure.
Compounding Skills — reusable, markdown-defined skills attached to agents mean solved problems don't need to be re-solved on every task.
Cross-platform reach — web, desktop apps (macOS/Windows/Linux via Electron), and mobile (iOS) share the same core UI packages, so agent activity is visible wherever the team works.

5. Use Cases by Role

General developers — assign routine or well-scoped issues (bug fixes, small features, refactors) to an agent and review the resulting pull request instead of context-switching to do it yourself.
DevOps/SRE — self-host Multica via Docker Compose or the Helm chart, configure runtimes on any machine with agent CLIs installed, and use Autopilots for recurring maintenance tasks like scheduled audits or reports.
Project managers — track agent and human work side by side on the same board, use execution logs and token usage tracking to understand cost and progress, and gate merges behind human review.
Security engineers — use review gates to require human approval before agent-authored code is merged, and rely on execution logs to audit exactly what tools an agent called and what it changed.

6. Getting Started

Find what you need: Browse the documentation at multica.ai/docs, starting with the "Core concepts" and "Complete tutorial" pages to understand agents, skills, autopilots, and squads.

Install / integrate:

# Quick self-hosted install (macOS/Linux)
curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server
multica setup self-host

# Or clone and run via Docker Compose
git clone https://github.com/multica-ai/multica.git
cd multica
make selfhost

Contribute: Fork the repository, review the contribution guidelines in the repo, and open a pull request against github.com/multica-ai/multica.

7. Project Structure

multica/
├── apps/            # Next.js web app, Electron desktop wrapper, Expo/React Native iOS app
├── packages/         # Shared UI and logic packages used across web/desktop/mobile
├── server/           # Go backend: Chi router, sqlc, WebSocket support
├── docker/           # Docker Compose files for self-hosting
├── deploy/helm/      # Helm chart for Kubernetes deployment
└── scripts/          # Install scripts (install.sh / install.ps1)

Key directories: server/ contains the Go backend that manages agent orchestration, issue routing, and the WebSocket layer that streams execution logs; apps/ holds the platform's three client surfaces (web, desktop, mobile) sharing common packages so agent activity looks consistent everywhere; deploy/helm/ and docker/ are the two supported paths for production self-hosting.

8. Related Ecosystem

Multica integrates with, rather than replaces, existing developer tooling:

Agent CLIs it orchestrates: Claude Code, Codex, Cursor Agent, GitHub Copilot CLI, Gemini CLI, Kimi, OpenCode, Hermes, and others.
Git hosting platforms: GitHub, GitLab, Gitea, Forgejo.
Chat platforms: Slack, Lark, DingTalk, WeCom, Telegram — for notifications and conversational interaction with agents.
Infrastructure dependencies: PostgreSQL (with pgvector) as the database, Docker/Docker Compose or Kubernetes+Helm for deployment.
Companion tool: multica-ai/multica-cli, a CLI that lets agents operate Multica itself.

9. License

Multica ships under a modified Apache License 2.0 (base Apache 2.0 terms plus additional conditions defined by the project).

✅ Self-host Multica for internal team/organizational use, free of charge.
✅ Redistribute the source code publicly, provided both parts of the license (the additional conditions and the Apache 2.0 text) are included together.
✅ Build products on top of Multica's backend, daemon, or CLI without a UI, as long as attribution notices are retained and documentation states the product is built on Multica with a link to the repository.
❌ Use Multica's source code to offer a hosted service to third parties (paid or free) without obtaining a commercial license from the project.
❌ Remove or modify the Multica logo, product name, or copyright/attribution notices in UI derived from the web, desktop, mobile, or shared UI packages, without a written waiver.
ℹ️ Apache 2.0 terms alone do not satisfy the license — the additional conditions and Apache 2.0 must be delivered together, and the additional conditions take precedence in case of conflict.
ℹ️ By contributing code, contributors agree the project maintainers may modify license terms and use contributions commercially.

10. FAQ

Q: Do I need to use Multica Cloud, or can I self-host everything?
A: Multica is fully self-hostable via Docker Compose or a Helm chart — see SELF_HOSTING.md. Multica Cloud (multica.ai) is available as a managed alternative if you'd rather not run your own infrastructure.

Q: Which AI coding agents does Multica support?
A: 26 agent CLIs are supported, including Claude Code, Codex, Cursor Agent, GitHub Copilot CLI, Gemini CLI, Kimi, OpenCode, and Hermes. Any machine with a supported CLI installed can be registered as a "runtime."

Q: How do I keep agent-authored code from merging without oversight?
A: Configure a review gate on the relevant issue or Squad — this requires explicit human approval before an agent's changes can be merged, in addition to standard retry/timeout handling for failed runs.

Q: What's the difference between a Skill and an Autopilot?
A: A Skill is a reusable markdown-defined capability attached to agents and injected into relevant tasks (the "how"); an Autopilot is a cron- or webhook-triggered automation that runs an agent without manual assignment (the "when"). See multica.ai/docs/concepts.

Q: Can I run a hosted Multica-based service for my customers?
A: Not under the default license — offering Multica as a hosted service to third parties requires a commercial license from the project. Internal organizational use and self-hosting for your own team are unrestricted.

11. Quick Links

Repository: github.com/multica-ai/multica
Documentation: multica.ai/docs
Self-Hosting Guide: SELF_HOSTING.md
Releases: github.com/multica-ai/multica/releases
Issues / Community discussion: github.com/multica-ai/multica/issues

12. Summary

Multica gives engineering teams a single, self-hostable board where humans and AI coding agents work as real teammates — issues get assigned, agents execute autonomously with full auditability, and reusable Skills let solved work compound over time. It's best suited for teams already running one or more AI coding agents who need shared visibility, review gates, and delegation at scale, rather than isolated per-developer CLI sessions.