Dissecting Multica: An Open-Source Platform That Turns AI Agents Into Real Teammates

Forum topic · 小凯 · 2026-04-24

Summary

Multica is an open-source (Apache 2.0) managed agents platform, authored by Forrest Chang (Jiayuan Zhang), that treats coding agents like Claude Code, Codex, Cursor Agent, and Gemini CLI as first-class team members. This technical deep-dive dissects its Go backend (~30,000+ lines), Next.js frontend monorepo, PostgreSQL/pgvector storage, and local Daemon. Key architectural findings include: a single Backend interface with ten agent implementations; local execution so code and API keys never leave the user's machine; a sandboxed execenv directory per task; a synchronous in-process event bus driving a decoupled, event-driven design; an Autopilot engine for scheduled and trigger-based automation; and a two-layer Skill system (cloud + local) that injects knowledge into agent workspaces. The frontend enforces strict package boundaries (core/ui/views), pairs React Query for server state with Zustand for client state, and uses WebSocket events purely for cache invalidation. Notable design decisions include polymorphic assignees making humans and agents equal, prompt-level prevention of agent-to-agent reply loops, session resume for long-running tasks, and workspace-level multi-tenancy enforced at the query layer. Compared with Paperclip, Vibe Kanban, and Claude Code Dispatch, Multica uniquely combines open source, multi-agent support, local execution, and a skill system.

This post is a line-by-line architectural teardown of Multica, an open-source managed agents platform by Forrest Chang (Jiayuan Zhang). Its README opens with a bold claim: *"Your next 10 hires won't be human."* Multica's mission is to turn coding agents (Claude Code, Codex, Cursor Agent, OpenClaw, etc.) into genuine teammates that take tasks, write code, open PRs, and comment — managed like Linear, with agents as first-class citizens.

Repo: github.com/multica-ai/multica
License: Apache 2.0

Key points

1. Four-layer architecture

Next.js frontend → Go backend (Chi + WebSocket) → PostgreSQL 17 + pgvector
A local Agent Daemon runs on the user's machine and executes agent CLIs
Core decision: "Agents run locally, management lives in the cloud." Code never leaves the machine, API keys never touch Multica's servers, and any agent CLI is supported.

2. Backend design

One Backend interface, ten implementations: a unified Execute(ctx, prompt, opts) interface with per-agent adapters (claude.go, codex.go, cursor.go, openclaw.go, opencode.go, gemini.go, hermes.go, kimi.go, pi.go, copilot.go). Multica is a dispatcher, not a model host — like a taxi dispatch center that doesn't drive.
Daemon as sandbox: receives task:dispatch over WebSocket, creates an isolated execenv directory per task (workdir/, output/, logs/), injects skills, streams output back. Philosophy: isolation > shared state, avoiding ghost bugs from leftover state.
Synchronous in-process event bus: issue:*, task:*, agent:*, autopilot:*, chat:* events decouple handlers from services (publish instead of direct calls).
Autopilot: declarative scheduled/trigger-based automation (create_issue or direct_task modes) that feeds into the same issue lifecycle as manual work.
Two-layer Skill system: cloud skills (importable from ClawHub / skills.sh) plus auto-discovered local skills (e.g., ~/.claude/skills/), injected per-provider into the task environment — skills are the agent's onboarding SOP.

3. Frontend design

Strict pnpm + Turborepo monorepo: core/ (stores, React Query, API client — no react-dom/localStorage/env), ui/ (zero business logic), views/ (no next/* or react-router; routing via NavigationAdapter). Internal packages ship raw .ts for zero-config HMR.
State dual-track: React Query owns server state; Zustand owns client state. WebSocket events only *invalidate* React Query caches — never write Zustand directly. On reconnect, all caches are fully invalidated for consistency.

4. Standout design decisions

Polymorphic assignees (assignee_type + assignee_id): humans and agents are fully equal — any issue can go to either or both, sharing the same state machine.
Agent-to-agent loop prevention: prompts explicitly instruct agents to *not reply* to acknowledgments from other agents and never @mention as a sign-off — preventive rather than caps-based design.
Session resume: failed tasks can resume via ResumeSessionID, with fallback to a fresh session.
Multi-tenancy as an architectural constraint: every query filters by workspace_id; routing via X-Workspace-ID.

5. Pragmatic tech choices

Go over Node/Python (WebSocket + process management), sqlc over ORMs, Chi over Gin/Echo, React Query + Zustand over Redux, pnpm/Turborepo over Nx/Lerna. No microservices, no GraphQL, no gRPC — "just enough" stack.

6. Comparison

Unlike Paperclip, Vibe Kanban, and Claude Code Dispatch, Multica is the only project combining open source (Apache 2.0), 10+ agent backends, local execution, a skill system, Autopilot, and true human-agent parity.

Bottom line: Multica isn't an "AI tool" — it's an AI employee management system: a deliberate infrastructure play for AI-native teams.

📎 GitHub: multica-ai/multica · Website: multica.ai · Author: forrestchang