Multica — Multi-Agent Task Collaboration Platform
Assign issues to AI coding agents like teammates — they pick up, report, and hand off for review. Works with 20 agent CLIs, self-hostable.
Evidence shows permission model (roles, access scopes) and review gates, but implementation details are not provided; user confirmation mechanisms (e.g., review gates) exist but not detailed; data flow transparency has architecture diagram but not deep; sensitive data handling not explicit; dependency security has overrides but no audit; external effects have execution logs but no control details; rollback not mentioned; source attribution has NOTICE file but not verified. Deductions due to lack of concrete implementation evidence.
Self-consistency: README and CI config align, but code not verified; dependency availability: has pnpm-lock and CI, but not verified; failure messages: has retry and timeout docs, but not verified. Deductions because static review cannot confirm execution.
Audience and scenarios: clearly targets teams and multiple agents; capability boundaries: has security model docs but no details; trigger precision: has triggering docs but not verified; environment fit: supports multiple platforms and self-hosting, but not verified. Deductions because docs claim but no code evidence.
Information architecture: clear documentation structure; install notes: has quickstart and self-hosting guide; naming stability: version 0.2.0, no stability promise; examples and FAQ: has tutorials and docs; known limitations: not explicitly listed; license: custom license but non-standard; versioning changelog: not provided; maintenance responsibility: has contributing guide but not explicit. Deductions for missing changelog and explicit limitations.
Output usability: has CLI and API, but not verified; marginal value: clearly addresses multi-agent management problem; cost-benefit: has token usage tracking, but not verified. Deductions because static review cannot confirm actual effectiveness.
Claim traceability: docs link to specific pages, but not verified; cross-source corroboration: has CI and tests, but not independently verified; fact-inference separation: docs distinguish feature descriptions and vision, but not explicit. Deductions for lack of independent verification.
- Custom license may restrict commercial use; review carefully.
- No changelog provided; version evolution is opaque.
- Security model docs lack implementation details; verify further.
What does this agent do, and when should you use it?
Multica is an open-source workspace that brings 20 coding agent CLIs (Claude Code, Codex, Cursor, etc.) onto a single board, letting you assign issues as if they were teammates. Agents autonomously claim tasks, execute them on a runtime you control, comment as they go, and deliver results as pull requests for human review. The platform offers web, desktop (macOS/Windows/Linux), and iOS clients, with a Go backend and PostgreSQL (pgvector) database, deployable via Docker Compose or Helm for self-hosting. The agent daemon runs locally next to your code, managing the CLI processes. It integrates with any Git host (GitHub, GitLab, Gitea, Forgejo) and chat platforms like Slack, Lark, DingTalk, and WeCom. While it requires you to install and authenticate each agent CLI, it remains provider-agnostic and avoids vendor lock-in.
Multica lets you create named agents tied to a specific runtime (your laptop or a cloud machine) and provider, then assign them issues. The agent daemon spawns the underlying CLI (e.g., claude or codex), executes commands, records every tool call with timestamps, and comments on the issue with progress. Users can trigger work via Autopilots (cron-like schedules), Chat, or direct issue assignment. The system tracks token usage, applies review gates, and sends inbox notifications when a human decision is needed. It provides a CLI and API for scripting, and agents can even drive Multica through the same CLI interface. Failed tasks retry automatically or stop with an explanation. The desktop app auto-registers the machine as a runtime and detects installed CLIs.
- A development team wants to offload bug fixing and code review to AI agents while keeping human approval gates — they set up a Multica board and assign issues.
- A company with strict data residency requirements self-hosts Multica on their own infrastructure using Docker Compose, keeping code and credentials on-premises.
- A developer juggling Claude Code, Codex, and Cursor wants a unified view of all agent work, shared context, and a single place to review diffs and execution logs.
- A team wants automated standups, periodic security audits, or report generation without manual triggers, using Autopilots on a cron schedule.
- An organization uses Slack or DingTalk for communication and wants to trigger and monitor agent tasks directly from those channels.
What are this agent's strengths and limitations?
- Provider-agnostic support for 20 agent CLIs; switching providers is a dropdown, not a migration.
- Self-hosting with Docker Compose or Helm gives full control over data and infrastructure.
- Deep chat integrations (Slack, Lark, DingTalk, WeCom) allow triggering and tracking work from team communication tools.
- Granular RBAC roles (owner/admin/member) and per-agent access scopes, with a full audit trail including token usage.
- Automatic retries for failures and clear timeout handling reduce babysitting overhead.
- Requires installing and authenticating each agent CLI manually; the runtime machine must have them pre-configured.
- Operational overhead: needs Node, Go, pnpm, PostgreSQL, and Docker for self-hosting; non-trivial for non-technical users.
- iOS app is not yet on the App Store; must build from source for that platform.
- License adds conditions to Apache 2.0 (covering hosted services, commercial embedding, and branding), which may restrict some commercial uses.
- Main branch moves fast (releases most weekdays), which may introduce instability for conservative adopters.
How do you install or deploy this agent?
For cloud, sign up at multica.ai or download the desktop app. For self-hosting: run curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server (Linux/macOS) and then multica setup self-host. On Windows, set $env:MULTICA_MODE="with-server" and run the PowerShell installer. Docker is required. You also need at least one supported agent CLI installed and authenticated (e.g., claude, codex).
How do you use this agent?
After signing in, the desktop app automatically connects your computer as a runtime and detects installed agent CLIs. To create an agent, go to 'Agents' in the sidebar, click 'New agent', select the runtime and provider, and give it a name (or use 'Build with AI' to generate configuration from a description). Then file an issue and set the agent as assignee — the agent will pick it up, execute it on your machine, comment on progress, and move it to review when done. You can monitor everything via the board and execution logs.