Multica — Summary

Multica is an open-source managed agents platform (NOASSERTION license, self-hostable) that turns coding agents into "real teammates" with profiles, board presence, task assignment, and autonomous execution. The architecture is a Go backend (Chi router + PostgreSQL + pgvector), a Next.js frontend, an iOS mobile client, and a desktop app — connected to a local daemon that auto-detects agent CLIs (Claude Code, Codex, GitHub Copilot CLI, OpenClaw, OpenCode, Hermes, Gemini, Pi, Cursor Agent, Kimi, Kiro CLI) and executes tasks autonomously. "Squads" group agents under a leader for stable routing; "Autopilots" schedule recurring work via cron/webhook triggers.

Multica is the most vendor-neutral framework in this batch: it works with 11 different agent CLIs and provides CLI, web app, and iOS mobile surfaces simultaneously. Compared to claude-flow (closest seed in architecture), Multica replaces the MCP toolserver with a PostgreSQL + pgvector backend, adds an org chart / issue tracker / squad routing layer, and makes the system accessible from a phone. Its explicit positioning ("your next 10 hires won't be human") frames agents as organizational team members rather than tools.

Multica — Overview

Origin

Created by multica-ai organization. 33,320 stars (rapidly growing), 30 contributors. License: NOASSERTION (custom). Active as of 2026-05-26.

Philosophy

The name is a nod to Multics (1960s OS that introduced time-sharing): "We think the same inflection is happening again. For decades, software teams have been single-threaded — one engineer, one task, one context switch at a time. AI agents change that equation. Multica brings time-sharing back, but for an era where the 'users' multiplexing the system are both humans and autonomous agents."

Key framing: "Your next 10 hires won't be human."

Agents in Multica are first-class organizational entities: they get assigned issues, report progress, raise blockers, and ship code like their human colleagues. The assignee picker, activity timeline, task lifecycle, and runtime infrastructure are all built around this from day one.

Vendor-Neutral Stance

Unlike all other frameworks in this batch, Multica explicitly supports 11 agent CLIs simultaneously: claude, codex, copilot, openclaw, opencode, hermes, gemini, pi, cursor-agent, kimi, kiro-cli. The daemon auto-detects whichever are on PATH.

Squads

Squads are a routing abstraction: assign work to a squad, the squad's leader agent decides who picks it up. @FrontendTeam instead of @alice-or-bob-or-carol. Provides stable routing as teams scale.

Multica — Architecture

Distribution

• CLI: multica (Go binary, Homebrew or install script)
• Web app: Next.js (cloud: multica.ai; self-hosted: Docker)
• Desktop app: Electron (apps/desktop)
• Mobile: iOS/Android (apps/mobile, React Native)
• Self-hosting: Docker Compose or Kubernetes

Architecture Layers

┌──────────────────────────────────────────┐
│   Next.js Frontend (web + desktop)        │
└─────────────────┬────────────────────────┘
                  │
┌─────────────────▼────────────────────────┐
│   Go Backend (Chi + gorilla/websocket)    │
│   PostgreSQL 17 + pgvector               │
└─────────────────┬────────────────────────┘
                  │
┌─────────────────▼────────────────────────┐
│   Agent Daemon (runs on your machine)     │
│   (auto-detects claude, codex, copilot,  │
│    openclaw, opencode, hermes, gemini,   │
│    pi, cursor-agent, kimi, kiro-cli)     │
└──────────────────────────────────────────┘

Monorepo Structure

multica/
├── apps/
│   ├── web/         # Next.js web app
│   ├── desktop/     # Electron desktop
│   └── mobile/      # React Native iOS/Android
├── packages/
│   └── ui/          # Shared Shadcn UI components
├── server/          # Go backend
│   ├── cmd/
│   ├── migrations/
│   └── pkg/
├── skills-lock.json # Skills version lock
└── CLAUDE.md, AGENTS.md

Required Runtime

• Node.js v20+, pnpm 10.28+, Go 1.26+ (development)
• Docker (self-hosting)
• For end users: just the multica CLI binary + agent CLIs on PATH

Config Files

• settings.json (via multica setup)
• CLAUDE.md, AGENTS.md (project context)
• skills-lock.json (skill versioning)

Multica — Components

CLI Commands (multica binary)

Web App Features (Next.js)

Mobile App

iOS (React Native with Expo) — monitor and manage agents from phone.

Skills System

skills-lock.json — skill version locking. Skills are reusable agent capabilities that accumulate over time and are shared across the team.

Supported Agent CLIs

claude, codex, copilot, openclaw, opencode, hermes, gemini, pi, cursor-agent, kimi, kiro-cli

Multica — Uniqueness & Positioning

differs_from_seeds

Multica is architecturally closest to claude-flow (both have a backend service coordinating multiple agents with persistent state) but diverges in three structural ways: (1) Multica uses a full-stack PostgreSQL + pgvector backend with a Go API server, while claude-flow uses an npm-bundled MCP server with SQLite; (2) Multica is vendor-neutral (11 supported agent CLIs) while claude-flow targets Claude Code; (3) Multica's primary interface is a multi-surface web app + desktop + mobile + CLI, while claude-flow's interface is terminal slash-commands. No seed in the corpus ships 4 simultaneous UI surfaces (web, desktop, mobile, CLI). The "Squads" routing tier (leader agent delegates to workers) maps to claude-flow's queen+workers pattern but implemented as a database-backed org chart rather than a code-class hierarchy. The skills compounding mechanism (every solution becomes a reusable skill) is unique in the corpus.

Positioning

• Most vendor-neutral platform in the batch: 11 agent CLIs supported.
• Only platform with iOS mobile app for agent management.
• Squad routing for stable team-scale assignment.
• Self-hostable via Docker/Kubernetes — no vendor lock-in.
• Autopilots enable fully automated recurring work without human kick-off.

Observable Failure Modes

1. License ambiguity: NOASSERTION license — legal status for enterprise use unclear.
2. Cloud dependency for quick start: multica setup connects to multica.ai by default; self-hosted requires Docker.
3. Agent CLI detection: Daemon auto-detects CLIs on PATH — if a required CLI isn't installed, the runtime silently reports no available agent.
4. Squad leader quality: The leader agent's routing decision quality determines Squad efficiency — a poorly prompted leader routes work to the wrong member.
5. pgvector dependency: Requires PostgreSQL 17 with pgvector extension for self-hosting — more complex than SQLite.