Multica

What It Does

Multica is a self-hosted orchestration layer that sits above AI coding agent CLIs (Claude Code, Codex, OpenClaw, OpenCode) and wraps them in a team workflow surface. Rather than replacing agents, it provides the coordination infrastructure around them: a Kanban board where issues are assigned to agents or humans, a local daemon that detects installed agent CLIs and executes tasks, real-time WebSocket progress streaming back to the web UI, and a reusable skills library where solutions are stored as capability bundles.

The architecture is a three-tier Go backend (Chi router, sqlc, gorilla/websocket) + Next.js 16 App Router frontend + PostgreSQL 17 with pgvector. The local daemon auto-detects available agent CLIs on PATH, registers them with the server, and on task assignment creates an isolated workspace directory, spawns the agent subprocess, and streams output back via WebSocket. PostgreSQL 17 with pgvector enables semantic search over stored skill descriptions for skill discovery. The platform self-describes as targeting “small, AI-native teams (2–10 persons).”

Key Features

• Kanban task board: Issues assigned to agents or humans with visual status tracking; agents appear with profiles and post progress comments like team members
• Task lifecycle state machine: Explicit enqueue → claim → start → complete/fail progression with real-time WebSocket updates to connected clients
• Local daemon with CLI auto-detection: Detects Claude Code, Codex, OpenClaw, and OpenCode on PATH; no adapter code required; creates isolated workspace directory per task
• pgvector skills library: Solutions stored as reusable skill bundles with semantic search via PostgreSQL 17 pgvector; cross-team skill discovery within a workspace
• Multi-workspace isolation: Team-level workspace separation with independent agents, issues, and settings
• WebSocket progress streaming: Hub-based gorilla/websocket implementation broadcasting state changes to all subscribed UI clients in real time
• Self-hosting via Docker Compose: Single-command deployment; code and agent interactions remain on-premises; Go backend is operationally lightweight (single binary)
• Cloud offering: multica.ai/app for teams who do not want to self-host

Use Cases

• AI-native team task management: Greenfield teams building with AI agents as primary contributors who want a purpose-built project management surface rather than adapting GitHub Issues or Linear
• Parallel agent queuing: Teams who want to queue overnight tasks across multiple agents and review results in a unified activity timeline the next morning
• Skill accumulation across projects: Organizations with repeated patterns (database migrations, API scaffolding, test generation) who want a searchable library of past agent solutions
• Multi-agent coordination without infrastructure overhead: Small teams who want to coordinate Claude Code + Codex in parallel without managing sandbox VMs or Kubernetes workloads

Adoption Level Analysis

Small teams (<20 engineers): Fits for AI-native greenfield teams willing to use Multica as their primary project management surface and accept early-adopter friction. Docker Compose self-hosting is accessible. However: GitHub integration is an open issue (no PR status sync as of April 2026), the license restricts commercial embedding without written authorization, and the agent execution model has no filesystem sandboxing — agents run as subprocesses on developer machines. The open issue count (89 as of April 2026) relative to release velocity (v0.1.35 in 5 months) signals rapid development with rough edges.

Medium orgs (20–200 engineers): Does not fit today. No RBAC, no audit logging, no enterprise SSO, no GitHub integration for PR lifecycle tracking, and no demonstrated production case studies from named organizations. The skill-compounding value proposition requires long-term skill library curation discipline that is unproven at team scale. Parallel tracking across Multica (agent tasks) and existing tooling (GitHub Issues, Linear) creates coordination overhead that undermines the productivity argument.

Enterprise (200+ engineers): Does not fit. No compliance tooling, no SOC 2, no enterprise contracts, no sandbox isolation for agent execution, and opaque team identity with no disclosed funding or organizational backing. The license commercial rider requires legal review before any commercial product embedding.

Alternatives

Evidence & Sources

• GitHub repository — multica-ai/multica — primary source; 12.3k stars, 1.5k forks, 89 open issues, 36 releases (v0.1.35, April 2026)
• DeepWiki technical architecture — third-party architecture analysis
• Arun Baby independent review — promotional but independently written; notes absence of production benchmarks
• Python Libraries Substack review — descriptive community coverage
• Multica Self-Hosting Guide — official deployment documentation

Notes & Caveats

• License misrepresentation is a significant red flag. The repository and marketing materials describe Multica as “Apache 2.0.” The actual license adds a commercial rider prohibiting use in hosted services sold to third parties and embedding in commercially distributed products without written Multica authorization. This is functionally a BSL-style source-available license, not OSI-approved open source. The contributor agreement gives Multica unilateral right to relicense contributions. Legal review is required before any commercial embedding.
• No filesystem sandboxing. Agent CLIs execute as subprocesses on developer machines, creating workspace directories in the local filesystem. There is no network isolation, container boundary, or resource limiting. An agent task can read and write arbitrary files on the host machine within its process permissions. This is acceptable for trusted solo developer use; it is a security gap in team or multi-tenant contexts.
• GitHub integration is absent. As of April 2026, there is no PR status tracking, no webhook integration with GitHub Issues, and no bidirectional sync with existing code hosting workflows. Issue #666 in the GitHub tracker requests this. Teams whose code lives on GitHub will run parallel project management surfaces, which erodes the “unified team workflow” value proposition.
• Team identity is opaque. No named individuals, no disclosed funding, no prior project track record is publicly associated with the multica-ai organization. This creates dependency risk: if the project is abandoned or acquired, self-hosted teams must maintain a fork of a Go + Next.js + PostgreSQL system.
• pgvector skill search is unvalidated. The semantic skill discovery feature requires PostgreSQL 17 + pgvector extension. No independent evidence exists that the skill compounding mechanism reduces time-to-completion or error rates in practice. The claim rests on the assumption that past agent solutions are semantically reusable — which depends heavily on solution quality and project-specificity.
• Architecture scale ceiling is acknowledged. The platform’s own documentation targets 2–10 person teams. This is appropriate honesty, but it conflicts with marketing language about “your next 10 hires won’t be human” and enterprise-scale workflow transformation.
• 36 releases in ~5 months signals rapid iteration. Version v0.1.35 in April 2026 means ~7 releases per month. This is high churn for a platform that manages team task workflows — organizations should expect breaking changes between minor versions.