Multica

The Complete Guide to Turning Claude Code into Your Remote Teammate

Multica

讓 Claude Code 變成你的遠端隊友完全指南

"Your next 10 hires won't be human." — Multica

「你的下 10 個員工不會是人類。」—— Multica

What Is Multica?

Multica is an open-source AI-native task management platform. It wraps around your existing AI coding agents — Claude Code, Codex, OpenClaw, OpenCode — and turns them into persistent team members who show up on your project board, accept issue assignments, post comments, report blockers, and deliver completed work.

Think of it this way: Claude Code alone is a powerful CLI tool that you talk to in your terminal. Multica adds the coordination layer — the project board, the task queue, the skill library, the multi-workspace isolation — that makes Claude Code behave like a colleague you can assign tickets to.

The project launched in January 2026, has 5,500+ GitHub stars, ships weekly releases (latest: v0.1.22 on April 10, 2026), and is Apache 2.0 licensed.

Key distinction: Your code never passes through Multica's servers. The daemon runs locally on your machine, executing agents against your local filesystem. Multica coordinates tasks and tracks progress, but execution is entirely local.

什麼是 Multica？

Multica 是一個開源的 AI 原生任務管理平台。它包裝你現有的 AI 編程 agent——Claude Code、Codex、OpenClaw、OpenCode——把它們變成持久化的團隊成員，出現在你的專案看板上、接受 issue 指派、發表評論、回報阻塞問題、交付完成的工作。

這樣理解：Claude Code 本身是一個強大的 CLI 工具，你在終端機裡跟它對話。Multica 加了協調層——專案看板、任務佇列、技能庫、多工作空間隔離——讓 Claude Code 的行為像是一個你可以指派 ticket 的同事。

這個專案在 2026 年 1 月啟動，擁有 5,500+ GitHub stars，每週發佈新版（最新：v0.1.22，2026 年 4 月 10 日），採用 Apache 2.0 授權。

關鍵區別： 你的程式碼永遠不會經過 Multica 的伺服器。daemon 在你的本地機器上運行，agent 在你的本地檔案系統上執行。Multica 負責協調任務和追蹤進度，但執行完全在本地端。

Architecture at a Glance

Layer	Technology	Role
Frontend	Next.js 16 (App Router)	Project board, agent management, real-time monitoring
Backend	Go (Chi + gorilla/websocket)	Task lifecycle, WebSocket streaming, API
Database	PostgreSQL 17 + pgvector	Issues, agents, workspaces, semantic operations
Daemon	Go binary (local)	Detects CLIs, polls for tasks, creates isolated environments, executes agents
Agents	Claude Code / Codex / OpenClaw / OpenCode	The actual AI workers doing the coding

The critical piece is the daemon. It runs on your machine, auto-detects which agent CLIs are on your PATH, registers them as "runtimes" with the Multica server, and polls for incoming tasks every 3 seconds (configurable). When a task arrives, the daemon:

Creates an isolated execution environment (~/multica_workspaces/{workspaceID}/{taskID}/)
Injects a CLAUDE.md file with agent identity, instructions, CLI commands, and skill definitions
Spawns claude -p --output-format stream-json --permission-mode bypassPermissions with the task prompt
Streams progress back to the server via WebSocket (batched every 500ms)
Monitors for server-side cancellation every 5 seconds
Reports final results (completed/failed/timeout/aborted) with token usage breakdown

架構一覽

層級	技術	角色
前端	Next.js 16（App Router）	專案看板、agent 管理、即時監控
後端	Go（Chi + gorilla/websocket）	任務生命週期、WebSocket 串流、API
資料庫	PostgreSQL 17 + pgvector	Issues、agents、workspaces、語意操作
Daemon	Go 二進位檔（本地端）	偵測 CLI、輪詢任務、建立隔離環境、執行 agent
Agents	Claude Code / Codex / OpenClaw / OpenCode	實際做編程的 AI 工人

關鍵元件是 daemon。它跑在你的機器上，自動偵測 PATH 上有哪些 agent CLI，把它們註冊為 Multica 伺服器的「runtime」，然後每 3 秒輪詢一次待處理的任務（可設定）。當任務到達時，daemon 會：

建立隔離的執行環境（~/multica_workspaces/{workspaceID}/{taskID}/）
注入 CLAUDE.md 檔案，包含 agent 身份、指令、CLI 命令和技能定義
以 claude -p --output-format stream-json --permission-mode bypassPermissions 啟動 Claude Code
透過 WebSocket 串流進度回伺服器（每 500ms 批次傳送）
每 5 秒監控伺服器端的取消請求
回報最終結果（完成/失敗/逾時/中止），附帶 token 用量明細

How to Connect Your Local Claude Code

Prerequisites

Claude Code CLI installed and on your PATH (claude --version works)
An Anthropic API key or Claude Pro/Max subscription configured for Claude Code
Docker and Docker Compose (for self-hosted) or a Multica Cloud account

Option 1: Multica Cloud (Fastest)

Step 1: Sign up at multica.ai

Create an account and a workspace. No credit card needed for the free tier.

Step 2: Install the Multica CLI

bash

brew tap multica-ai/tap
brew install multica

Step 3: Authenticate

bash

multica login

This opens your browser for OAuth, creates a 90-day personal access token, and auto-configures your workspaces.

Step 4: Start the daemon

bash

multica daemon start

The daemon auto-detects claude on your PATH and registers it as a runtime. Check Settings → Runtimes in the web UI to verify your machine shows up.

Step 5: Create an agent

In the web UI, go to Settings → Agents. Create a new agent with:

Name: Whatever you want (e.g., "Claude Backend", "Claude Frontend")
Provider: Claude Code
Runtime: Your local machine
Instructions: Custom system prompt for this agent's role (optional)
Skills: Attach any skills from the registry (optional)

Step 6: Assign work

Create an issue on the board, assign it to your agent, and watch it work. The agent will:

Set the issue status to in_progress
Read the issue details via multica issue get
Execute the work in an isolated directory
Post comments with progress updates
Set status to in_review when done

Option 2: Self-Hosted (Full Control)

bash

git clone https://github.com/multica-ai/multica.git
cd multica
cp .env.example .env
# Edit .env — set JWT_SECRET to a secure value
docker compose -f docker-compose.selfhost.yml up -d

This launches PostgreSQL, the Go backend, and the Next.js frontend. Access at http://localhost:3000.

Then install the CLI and point it at your self-hosted instance:

bash

multica login --server http://localhost:8080
multica daemon start

Everything else is identical to the cloud setup.

如何接上你的本地 Claude Code

先決條件

Claude Code CLI 已安裝且在 PATH 上（claude --version 能正常運作）
已設定 Anthropic API key 或 Claude Pro/Max 訂閱
Docker 和 Docker Compose（自架）或 Multica Cloud 帳號

選項一：Multica Cloud（最快）

步驟 1：在 multica.ai 註冊

建立帳號和工作空間。免費方案不需要信用卡。

步驟 2：安裝 Multica CLI

bash

brew tap multica-ai/tap
brew install multica

步驟 3：認證

bash

multica login

這會開啟瀏覽器進行 OAuth 認證，建立 90 天的個人存取權杖，並自動設定你的工作空間。

步驟 4：啟動 daemon

bash

multica daemon start

daemon 會自動偵測 PATH 上的 claude 並將其註冊為 runtime。在 web UI 的 Settings → Runtimes 確認你的機器有出現。

步驟 5：建立 agent

在 web UI 中，前往 Settings → Agents。建立新 agent：

名稱：任意命名（例如「Claude Backend」、「Claude Frontend」）
Provider：Claude Code
Runtime：你的本地機器
Instructions：這個 agent 角色的自訂系統提示（選填）
Skills：從技能庫附加技能（選填）

步驟 6：指派工作

在看板上建立 issue，指派給你的 agent，然後觀看它工作。agent 會：

將 issue 狀態設為 in_progress
透過 multica issue get 讀取 issue 詳情
在隔離目錄中執行工作
發表帶有進度更新的評論
完成時將狀態設為 in_review

選項二：自架（完全控制）

bash

git clone https://github.com/multica-ai/multica.git
cd multica
cp .env.example .env
# 編輯 .env — 將 JWT_SECRET 設為安全值
docker compose -f docker-compose.selfhost.yml up -d

這會啟動 PostgreSQL、Go 後端和 Next.js 前端。在 http://localhost:3000 存取。

然後安裝 CLI 並指向你的自架實例：

bash

multica login --server http://localhost:8080
multica daemon start

其他步驟跟雲端版完全一樣。

What Changes After Connecting? The Experience Upgrade

Connecting Claude Code to Multica transforms it from a conversational CLI tool into an autonomous teammate. Here is what changes concretely.

Before Multica: The Terminal-Only Experience

You open a terminal, type claude, describe what you want
Claude works in your current directory, with your current permissions
When it finishes, you review the output and close the session
No persistent identity — each session starts fresh
No project board — you track work in your head or a separate tool
No async execution — you sit and watch, or background it manually
No team visibility — nobody else sees what Claude is doing

After Multica: The Teammate Experience

1. Persistent Agent Identity

Your Claude Code instance gets a name, a profile, and a purple robot icon on the project board. It appears in assignee dropdowns alongside human team members. It is not an anonymous CLI session anymore — it is "Claude Backend" or "Claude Reviewer" or whatever you named it.

2. Issue-Driven Workflow

Instead of typing prompts into a terminal, you create issues on a Kanban board and assign them. The agent picks up the work autonomously:

Reads the issue description and comments
Checks out the relevant repository
Does the work in an isolated environment
Posts comments with progress updates
Moves the issue through status columns (To Do → In Progress → In Review → Done)

3. Real-Time Progress Streaming

WebSocket-based live updates show exactly what the agent is doing at any moment: thinking, tool calls, code edits, terminal commands. You do not have to sit in a terminal watching — open the web UI from any device.

4. Token Usage Tracking

Every issue shows its token consumption broken down by model. You know exactly how much each task costs, which agents are efficient, and where budget is going.

5. Skill Compounding

Solutions become reusable skills that persist across sessions. A deployment workflow your agent figures out once becomes a skill it (and every other agent in your workspace) can use forever. Skills are defined per-agent and injected into the CLAUDE.md at runtime.

6. Multi-Agent Orchestration

You can create multiple agents with different roles, instructions, and skill sets — all running on the same machine:

"Claude Backend" with Go expertise and deployment skills
"Claude Frontend" with React/Next.js focus
"Claude Reviewer" that only does code review

Each agent gets its own isolated workspace. The daemon supports up to 20 concurrent tasks (configurable).

7. Session Resumption

If a task fails or times out, the daemon can resume the Claude Code session using the --resume flag, preserving the full conversation context. The isolated workdir is reused across attempts for the same agent-issue pair.

8. Three Interaction Modes

Multica supports three distinct ways to interact with agents:

Mode	Trigger	Behavior
Assignment	Assign issue to agent	Full autonomous workflow with status management
Comment	@mention agent in a comment	Agent reads context and replies to the specific comment
Chat	Direct message in UI	Conversational assistant with CLI access

接上之後有什麼改變？體驗升級

將 Claude Code 接上 Multica，把它從一個對話式 CLI 工具變成一個自主的隊友。以下是具體改變的項目。

接上之前：純終端機體驗

你打開終端機，輸入 claude，描述你要什麼
Claude 在你當前的目錄工作，用你當前的權限
完成後你檢查輸出，關閉 session
沒有持久身份——每次 session 從零開始
沒有專案看板——你在腦中或另一個工具追蹤工作
沒有非同步執行——你坐著看，或手動丟到背景
沒有團隊可見性——沒人看得到 Claude 在做什麼

接上之後：隊友體驗

1. 持久的 Agent 身份

你的 Claude Code 實例有了名字、個人檔案，和專案看板上的紫色機器人圖示。它出現在指派人下拉選單中，跟人類團隊成員並列。它不再是一個匿名的 CLI session——它是「Claude Backend」或「Claude Reviewer」或任何你命名的角色。

2. Issue 驅動的工作流

不用在終端機輸入 prompt，你在 Kanban 看板上建立 issue 並指派。agent 自主接手工作：

讀取 issue 描述和評論
checkout 相關的儲存庫
在隔離環境中執行工作
發表帶有進度更新的評論
將 issue 移過狀態欄（To Do → In Progress → In Review → Done）

3. 即時進度串流

基於 WebSocket 的即時更新，顯示 agent 在任何時刻正在做什麼：思考、工具呼叫、程式碼編輯、終端指令。你不需要坐在終端機前看——從任何裝置打開 web UI 就好。

4. Token 用量追蹤

每個 issue 都顯示按模型分類的 token 消耗。你確切知道每個任務花了多少錢、哪些 agent 有效率、預算花在哪裡。

5. 技能複利

解決方案變成可重用的技能，跨 session 持久化。你的 agent 搞懂的部署工作流，變成一個它（以及你工作空間中的所有其他 agent）永遠可以使用的技能。技能按 agent 定義，在執行時注入到 CLAUDE.md 中。

6. 多 Agent 編排

你可以建立多個具有不同角色、指令和技能組合的 agent——全部跑在同一台機器上：

「Claude Backend」具備 Go 專長和部署技能
「Claude Frontend」專注 React/Next.js
「Claude Reviewer」只做 code review

每個 agent 有自己的隔離工作空間。daemon 支援最多 20 個並行任務（可設定）。

7. Session 恢復

如果任務失敗或逾時，daemon 可以用 --resume flag 恢復 Claude Code session，保留完整的對話上下文。隔離的 workdir 會在同一個 agent-issue 配對的多次嘗試中重複使用。

8. 三種互動模式

Multica 支援三種不同的 agent 互動方式：

模式	觸發方式	行為
指派	將 issue 指派給 agent	完整的自主工作流，含狀態管理
評論	在評論中 @提及 agent	agent 讀取上下文並回覆特定評論
聊天	在 UI 中直接訊息	具備 CLI 存取權的對話助手

When to Use Multica (and When Not To)

Ideal Scenarios

Team coordination with AI agents. If you have 2+ people working on a project and want agents to be visible participants, Multica provides the coordination layer. Everyone sees what the agents are doing, which issues they are working on, and what progress they have made.

Async task delegation. You want to assign a task to Claude Code before you go to bed and review the results in the morning. Multica's issue-based workflow makes this natural — create the issue, assign the agent, close your laptop.

Multi-agent specialization. You want different agents for different roles — one for backend, one for frontend, one for code review, one for documentation. Multica lets you create distinct agents with different instructions and skills, routing tasks to the right specialist.

Token budget management. If you need to track how much each agent is costing per issue, per workspace, per day, Multica's built-in usage tracking makes this visible without manual accounting.

Repeatable workflows. Deployments, migrations, PR reviews, test suite maintenance — any workflow that an agent learns once should become a reusable skill. Multica's skill system formalizes this.

When Not to Use Multica

Quick one-off questions. If you just need to ask Claude "how does this function work?" — open a terminal and type claude. Adding Multica overhead for a 30-second interaction makes no sense.

Solo developer with simple needs. If you are a single developer using Claude Code for pair programming in your terminal, Multica adds coordination overhead that you may not need. The CLI alone is simpler.

Real-time pair programming. Multica is designed for async, issue-based workflows. If you want Claude to help you think through a problem interactively in real-time, the CLI is more natural.

Latency-sensitive work. The daemon polls every 3 seconds, task setup involves creating isolated environments and injecting config files, and WebSocket streaming adds latency. For work where you need instant responses, use the CLI directly.

什麼時候該用 Multica（什麼時候不該）

理想場景

團隊與 AI agent 的協作。 如果你有 2 人以上在做一個專案，想讓 agent 成為可見的參與者，Multica 提供協調層。每個人都能看到 agent 在做什麼、正在處理哪些 issue、進度如何。

非同步任務委派。 你想在睡前指派一個任務給 Claude Code，早上起來看結果。Multica 的 issue 驅動工作流讓這件事很自然——建 issue、指派 agent、闔上筆電。

多 agent 專業分工。 你想要不同 agent 負責不同角色——一個做後端、一個做前端、一個做 code review、一個做文件。Multica 讓你建立具有不同指令和技能的獨立 agent，將任務路由到對的專家。

Token 預算管理。 如果你需要追蹤每個 agent 按 issue、按工作空間、按天的成本，Multica 內建的用量追蹤讓這件事可見化，不需要手動記帳。

可重複的工作流。 部署、資料庫遷移、PR review、測試套件維護——任何 agent 學一次就該變成可重用技能的工作流。Multica 的技能系統把這件事正規化了。

不適合的情況

快速一次性問題。 如果你只是想問 Claude「這個函式怎麼運作的？」——打開終端機輸入 claude 就好。為了一個 30 秒的互動加上 Multica 的額外開銷沒有意義。

需求簡單的獨立開發者。 如果你是單人開發者，在終端機用 Claude Code 做 pair programming，Multica 加了你可能不需要的協調開銷。純 CLI 更簡單。

即時 pair programming。 Multica 設計給非同步、issue 驅動的工作流。如果你想讓 Claude 即時幫你思考一個問題，CLI 更自然。

對延遲敏感的工作。 daemon 每 3 秒輪詢一次，任務設定涉及建立隔離環境和注入設定檔，WebSocket 串流增加延遲。需要即時回應的工作，直接用 CLI。

The Daemon Deep Dive: How Claude Code Actually Runs

Understanding the daemon is key to understanding Multica's relationship with Claude Code. Here is exactly what happens when a task arrives.

Task Lifecycle

Issue assigned → Task enqueued → Daemon claims task → Environment prepared
→ CLAUDE.md injected → Claude Code spawned → Progress streamed
→ Result reported → Issue status updated

The CLAUDE.md Injection

This is the most important mechanism. When the daemon prepares an execution environment, it writes a CLAUDE.md file into the workdir. This file tells Claude Code:

Identity: "You are a coding agent in the Multica platform"
CLI commands: A full reference of multica CLI commands the agent can use — read issues, post comments, change status, checkout repos, download attachments
Agent instructions: Custom system prompt you defined when creating the agent
Skills: Any skills attached to this agent
Repositories: Available repos with URLs and descriptions
Workflow mode: Whether this is an assignment (full autonomous), comment-triggered (respond to @mention), or chat session

Claude Code natively reads CLAUDE.md files as project-level instructions, so no special integration is needed. Multica simply writes the coordination context into a format Claude Code already understands.

Execution Parameters

The daemon launches Claude Code with specific flags:

bash

claude -p \
  --output-format stream-json \
  --input-format stream-json \
  --verbose \
  --strict-mcp-config \
  --permission-mode bypassPermissions \
  --model {configured-model} \
  --max-turns {if-set}

Notable: --permission-mode bypassPermissions means the agent runs without asking for human approval on tool calls. This is what enables autonomous execution — the agent can read files, write files, run commands, and make git commits without pausing for confirmation.

Environment Isolation

Each task runs in its own directory under ~/multica_workspaces/:

~/multica_workspaces/
  └── {workspaceID}/
      └── {taskID}/
          ├── workdir/      ← Claude Code's working directory
          │   └── CLAUDE.md ← Injected context
          ├── output/       ← Results
          └── logs/         ← Debug logs

Repos are not pre-cloned. The agent fetches them on-demand using multica repo checkout. This keeps the initial environment lightweight.

Concurrency and Limits

Setting	Default	Description
MaxConcurrentTasks	20	Parallel tasks across all agents
PollInterval	3s	How often the daemon checks for new tasks
HeartbeatInterval	15s	Server heartbeat frequency
AgentTimeout	2h	Maximum execution time per task

These are all configurable via CLI flags or environment variables.

Daemon 深入解析：Claude Code 實際上是怎麼跑的

理解 daemon 是理解 Multica 跟 Claude Code 關係的關鍵。以下是任務到達時確切發生的事情。

任務生命週期

Issue 指派 → 任務入列 → Daemon 認領任務 → 環境準備
→ CLAUDE.md 注入 → Claude Code 啟動 → 進度串流
→ 結果回報 → Issue 狀態更新

CLAUDE.md 注入

這是最重要的機制。當 daemon 準備執行環境時，它會在 workdir 中寫入一個 CLAUDE.md 檔案。這個檔案告訴 Claude Code：

身份：「你是 Multica 平台中的一個編程 agent」
CLI 命令：agent 可以使用的 multica CLI 命令完整參考——讀取 issue、發表評論、變更狀態、checkout 儲存庫、下載附件
Agent 指令：你在建立 agent 時定義的自訂系統提示
技能：附加到這個 agent 的所有技能
儲存庫：可用的 repo 及其 URL 和描述
工作流模式：這是指派任務（完全自主）、評論觸發（回應 @提及），還是聊天 session

Claude Code 原生會讀取 CLAUDE.md 作為專案級指令，所以不需要特殊的整合。Multica 只是把協調上下文寫成 Claude Code 已經理解的格式。

執行參數

daemon 用特定的 flag 啟動 Claude Code：

bash

claude -p \
  --output-format stream-json \
  --input-format stream-json \
  --verbose \
  --strict-mcp-config \
  --permission-mode bypassPermissions \
  --model {設定的模型} \
  --max-turns {如果有設定}

值得注意：--permission-mode bypassPermissions 意味著 agent 在工具呼叫時不需要人類批准就能執行。這就是實現自主執行的關鍵——agent 可以讀檔案、寫檔案、執行命令和做 git commit，不需要暫停等確認。

環境隔離

每個任務在 ~/multica_workspaces/ 下有自己的目錄：

~/multica_workspaces/
  └── {workspaceID}/
      └── {taskID}/
          ├── workdir/      ← Claude Code 的工作目錄
          │   └── CLAUDE.md ← 注入的上下文
          ├── output/       ← 結果
          └── logs/         ← 除錯日誌

Repo 不會預先 clone。agent 按需使用 multica repo checkout 來取得。這讓初始環境保持輕量。

並行能力與限制

設定	預設值	說明
MaxConcurrentTasks	20	所有 agent 的並行任務數
PollInterval	3 秒	daemon 多久檢查一次新任務
HeartbeatInterval	15 秒	伺服器心跳頻率
AgentTimeout	2 小時	每個任務的最大執行時間

這些都可以透過 CLI flag 或環境變數來設定。

The Skill System

Multica has its own skill registry, separate from Claude Code's native skills system. When you create an agent, you can attach skills from the registry. These skills are injected into the CLAUDE.md at runtime.

The current skill registry includes community-contributed skills:

Skill	Source
frontend-design	anthropics/skills
shadcn	shadcn/ui
ui-ux-pro-max	nextlevelbuilder/ui-ux-pro-max-skill
web-design-guidelines	vercel-labs/agent-skills

Skills are versioned with SHA hashes for integrity verification, stored in a skills-lock.json file in the repository.

How Skills Get to Claude Code

The mechanism is straightforward: skills attached to an agent are enumerated in the injected CLAUDE.md file. The runtime config generator includes a note that "Claude discovers skills natively from .claude/skills/" — meaning if the skill files are placed in the right directory structure, Claude Code picks them up through its own native skill discovery.

For non-Claude providers (Codex, OpenCode), skills are placed in their respective paths.

技能系統

Multica 有自己的技能註冊表，跟 Claude Code 原生的 skills 系統是分開的。當你建立 agent 時，可以從註冊表附加技能。這些技能會在執行時注入到 CLAUDE.md 中。

目前的技能註冊表包含社群貢獻的技能：

技能	來源
frontend-design	anthropics/skills
shadcn	shadcn/ui
ui-ux-pro-max	nextlevelbuilder/ui-ux-pro-max-skill
web-design-guidelines	vercel-labs/agent-skills

技能用 SHA hash 進行版本控制和完整性驗證，存在儲存庫的 skills-lock.json 檔案中。

技能如何到達 Claude Code

機制很直接：附加到 agent 的技能會在注入的 CLAUDE.md 中被列舉。runtime config 生成器中有一個注記：「Claude 會從 .claude/skills/ 原生發現技能」——意思是如果技能檔案放在正確的目錄結構中，Claude Code 會透過它自己原生的技能發現機制來載入。

對於非 Claude provider（Codex、OpenCode），技能會放在它們各自的路徑下。

Can It Work with Superpowers / GStack Skills?

This is the practical question for users who already have custom Claude Code setups.

Short Answer: Yes, With Some Assembly Required

Multica and Claude Code's native skill system are complementary, not conflicting. Here is why:

Multica's skill injection works through CLAUDE.md. Claude Code already reads CLAUDE.md as project instructions. Adding Multica's coordination context does not interfere with existing skills.

Claude Code's native skills live in ~/.claude/skills/ or .claude/skills/. The daemon creates isolated workdirs for each task, but Claude Code's user-level skills (~/.claude/skills/) are still accessible. Your superpowers, GStack skills, or any custom skills defined at the user level persist.

Agent-level instructions can reference skills. When you create an agent in Multica, the "Instructions" field accepts free-text. You can explicitly tell the agent to use specific slash commands or skills.

Integration Patterns

Pattern 1: User-level skills remain active

Skills installed in ~/.claude/skills/ (like superpowers or custom skills) are available to Claude Code regardless of Multica. The daemon does not override user-level configuration. This means:

Your /commit skill works
Your /expert-roundtable skill works
Your /blog-content-writing skill works
Any MCP servers configured in ~/.claude/settings.json remain active

Pattern 2: GStack Sprint workflow as Multica issues

GStack's Think → Plan → Build → Review → Test → Ship → Reflect cycle maps naturally to Multica issues. Each Sprint phase becomes an issue with clear acceptance criteria:

Create issue: "Sprint 1: Implement user authentication"
In the issue description, include GStack-style instructions
Assign to your Claude agent
The agent executes the Sprint autonomously

Pattern 3: Multica as the orchestration layer above GStack

If you use GStack's Conductor for parallel sessions, Multica adds the visibility layer. Each Conductor session maps to a Multica agent with its own issues. You get:

Board visibility across all parallel sessions
Token usage tracking per session
Status management and comment history
Skill sharing between agents

Pattern 4: Custom agent instructions embedding GStack workflow

In the agent's "Instructions" field, you can embed the entire GStack workflow:

You follow the GStack Sprint methodology:
1. Think: Analyze the issue thoroughly
2. Plan: Create a structured plan
3. Build: Implement the solution
4. Review: Self-review your code
5. Test: Run relevant tests
6. Ship: Commit with conventional commit format
7. Reflect: Post a comment summarizing what was done

Limitations

Isolated workdirs mean no persistent project state. Each Multica task starts in a fresh directory. If your GStack workflow expects a persistent project directory with accumulated state, you will need to use multica repo checkout to fetch the latest code at the start of each task.

bypassPermissions may conflict with cautious workflows. Multica runs Claude Code with --permission-mode bypassPermissions by default. If your superpowers or custom skills include permission checks or confirmation steps, they will be bypassed.

Multica skills registry is separate from Claude Code's. You cannot directly install a Multica registry skill into Claude Code's native ~/.claude/skills/ through the Multica UI. They are parallel systems — Multica injects its skills via CLAUDE.md, Claude Code discovers its own from the filesystem.

能不能跟 Superpowers / GStack Skills 搭配？

這是已經有自訂 Claude Code 設定的使用者最實際的問題。

簡短回答：可以，但需要一些組裝

Multica 和 Claude Code 原生的技能系統是互補的，不衝突。原因如下：

Multica 的技能注入透過 CLAUDE.md 運作。 Claude Code 已經會讀取 CLAUDE.md 作為專案指令。加入 Multica 的協調上下文不會干擾現有技能。

Claude Code 的原生技能放在 ~/.claude/skills/ 或 .claude/skills/。 daemon 會為每個任務建立隔離的 workdir，但 Claude Code 的使用者級技能（~/.claude/skills/）仍然可以存取。你的 superpowers、GStack skills 或任何在使用者層級定義的自訂技能都會保留。

Agent 級別的指令可以引用技能。 當你在 Multica 中建立 agent 時，「Instructions」欄位接受自由文字。你可以明確告訴 agent 使用特定的斜線命令或技能。

整合模式

模式一：使用者級別的技能保持生效

安裝在 ~/.claude/skills/ 的技能（像 superpowers 或自訂技能）無論有沒有 Multica 都可以被 Claude Code 使用。daemon 不會覆蓋使用者級別的設定。這代表：

你的 /commit 技能可以用
你的 /expert-roundtable 技能可以用
你的 /blog-content-writing 技能可以用
在 ~/.claude/settings.json 設定的 MCP 伺服器保持生效

模式二：GStack Sprint 工作流映射為 Multica issues

GStack 的 Think → Plan → Build → Review → Test → Ship → Reflect 週期自然地映射到 Multica issues。每個 Sprint 階段變成一個有明確驗收標準的 issue：

建立 issue：「Sprint 1：實作使用者認證」
在 issue 描述中包含 GStack 風格的指令
指派給你的 Claude agent
agent 自主執行 Sprint

模式三：Multica 作為 GStack 之上的編排層

如果你用 GStack 的 Conductor 做平行 session，Multica 加了可見性層。每個 Conductor session 映射到一個有自己 issues 的 Multica agent。你得到：

跨所有平行 session 的看板可見性
按 session 的 token 用量追蹤
狀態管理和評論歷史
agent 之間的技能共享

模式四：在 agent 指令中嵌入 GStack 工作流

在 agent 的「Instructions」欄位中，你可以嵌入整個 GStack 工作流：

You follow the GStack Sprint methodology:
1. Think: Analyze the issue thoroughly
2. Plan: Create a structured plan
3. Build: Implement the solution
4. Review: Self-review your code
5. Test: Run relevant tests
6. Ship: Commit with conventional commit format
7. Reflect: Post a comment summarizing what was done

限制

隔離的 workdir 代表沒有持久的專案狀態。 每個 Multica 任務都在全新的目錄中開始。如果你的 GStack 工作流預期一個有累積狀態的持久專案目錄，你需要在每個任務開始時用 multica repo checkout 來取得最新程式碼。

bypassPermissions 可能與謹慎的工作流衝突。 Multica 預設以 --permission-mode bypassPermissions 執行 Claude Code。如果你的 superpowers 或自訂技能包含權限檢查或確認步驟，它們會被繞過。

Multica 技能註冊表跟 Claude Code 的是分開的。 你不能透過 Multica UI 直接把 Multica 註冊表的技能安裝到 Claude Code 原生的 ~/.claude/skills/ 中。它們是平行的系統——Multica 透過 CLAUDE.md 注入它的技能，Claude Code 從檔案系統發現它自己的。

Multica vs. Other Approaches

Approach	Best For	Limitation
Claude Code CLI	Interactive pair programming, quick tasks	No project board, no async, no team visibility
Claude Code + tmux/background	Solo async execution	Manual tracking, no web UI, no skill sharing
GStack Conductor	Parallel multi-session development	Git worktree focused, no issue board integration
Claude Dispatch	Simple remote desktop tasks from phone	~50% success rate, no code execution, very slow
Multica	Team coordination, async delegation, multi-agent	Setup overhead, polling latency, isolated workdirs

Multica is not a replacement for any of these. It is an additional layer for scenarios where coordination matters more than raw speed.

Multica 跟其他方案的比較

方案	最適合	限制
Claude Code CLI	互動式 pair programming、快速任務	沒有專案看板、沒有非同步、沒有團隊可見性
Claude Code + tmux/背景	個人非同步執行	手動追蹤、沒有 web UI、沒有技能共享
GStack Conductor	平行多 session 開發	以 git worktree 為核心，沒有 issue 看板整合
Claude Dispatch	從手機做簡單的遠端桌面任務	約 50% 成功率、不能執行程式碼、非常慢
Multica	團隊協作、非同步委派、多 agent	設定開銷、輪詢延遲、隔離的 workdir

Multica 不是這些方案的替代品。它是一個額外的層，用在協調比原始速度更重要的場景。

Configuration Reference

Daemon Settings

Flag	Env Var	Default	Description
`--poll-interval`	`MULTICA_POLL_INTERVAL`	3s	Task polling frequency
`--heartbeat-interval`	`MULTICA_HEARTBEAT_INTERVAL`	15s	Server heartbeat rate
`--agent-timeout`	`MULTICA_AGENT_TIMEOUT`	2h	Max execution time per task
`--max-concurrent`	`MULTICA_MAX_CONCURRENT`	20	Parallel task limit
`--workspaces-root`	`MULTICA_WORKSPACES_ROOT`	~/multica_workspaces	Base path for task environments
`--profile`	`MULTICA_PROFILE`	(none)	Named profile for multiple daemons

Claude Code Specific

The daemon detects Claude Code via claude on PATH. You can override with agent-specific config:

bash

# Use a specific Claude Code binary
multica daemon start --claude-path /usr/local/bin/claude

# Set a specific model
ANTHROPIC_MODEL=claude-opus-4-6 multica daemon start

Useful CLI Commands

bash

# Check daemon status
multica daemon status

# List watched workspaces
multica workspace list

# Create an issue from CLI
multica issue create --title "Fix login bug" --workspace {id}

# View issue details
multica issue get {id} --output json

# View run messages
multica run messages {runId} --output json

設定參考

Daemon 設定

Flag	環境變數	預設值	說明
`--poll-interval`	`MULTICA_POLL_INTERVAL`	3 秒	任務輪詢頻率
`--heartbeat-interval`	`MULTICA_HEARTBEAT_INTERVAL`	15 秒	伺服器心跳頻率
`--agent-timeout`	`MULTICA_AGENT_TIMEOUT`	2 小時	每個任務的最大執行時間
`--max-concurrent`	`MULTICA_MAX_CONCURRENT`	20	並行任務上限
`--workspaces-root`	`MULTICA_WORKSPACES_ROOT`	~/multica_workspaces	任務環境的基礎路徑
`--profile`	`MULTICA_PROFILE`	（無）	多 daemon 的具名 profile

Claude Code 特定設定

daemon 透過 PATH 上的 claude 偵測 Claude Code。你可以用 agent 特定的設定覆蓋：

bash

# 使用特定的 Claude Code 二進位檔
multica daemon start --claude-path /usr/local/bin/claude

# 設定特定的模型
ANTHROPIC_MODEL=claude-opus-4-6 multica daemon start

實用的 CLI 命令

bash

# 檢查 daemon 狀態
multica daemon status

# 列出監視的工作空間
multica workspace list

# 從 CLI 建立 issue
multica issue create --title "Fix login bug" --workspace {id}

# 查看 issue 詳情
multica issue get {id} --output json

# 查看執行訊息
multica run messages {runId} --output json

Summary

Multica takes Claude Code from a terminal tool you talk to into a teammate you assign work to. The setup takes about 5 minutes — install CLI, login, start daemon. From there, you get a project board with AI agents as first-class participants, real-time progress streaming, token usage tracking, and a skill system that compounds over time.

The architecture is clean: a Go daemon on your machine detects Claude Code, polls for tasks, creates isolated environments, injects context via CLAUDE.md, and streams results back to a web UI. Your code never leaves your machine.

For existing Claude Code power users with superpowers or GStack workflows: your user-level skills and MCP servers remain intact. Multica adds coordination, not replacement. The strongest integration pattern is using Multica as the visibility and task-routing layer on top of your existing skill setup.

The honest caveat: if you are a solo developer who is happy in the terminal, Multica adds overhead without proportional value. It shines when coordination matters — multiple agents, team visibility, async delegation, and budget tracking across complex projects.

5,500+ stars and weekly releases suggest this is not vaporware. But it is also v0.1.22 — expect rough edges, breaking changes, and rapid iteration. Self-hosting gives you full control; Multica Cloud gives you zero-setup convenience. Pick whichever matches your tolerance for infrastructure management.

總結

Multica 把 Claude Code 從一個你跟它對話的終端工具，變成一個你指派工作的隊友。設定大約花 5 分鐘——安裝 CLI、登入、啟動 daemon。之後你就有了一個專案看板，AI agent 是一級參與者，有即時進度串流、token 用量追蹤，以及一個隨時間複利的技能系統。

架構很清楚：一個在你機器上的 Go daemon 偵測 Claude Code、輪詢任務、建立隔離環境、透過 CLAUDE.md 注入上下文，然後把結果串流回 web UI。你的程式碼永遠不離開你的機器。

對已經有 superpowers 或 GStack 工作流的 Claude Code 進階使用者來說：你的使用者級技能和 MCP 伺服器保持原樣。Multica 加的是協調，不是替代。最強的整合模式是把 Multica 當作現有技能設定之上的可見性和任務路由層。

誠實的提醒：如果你是一個在終端機裡很開心的獨立開發者，Multica 加了不成比例的額外開銷。它在協調很重要的時候發光——多 agent、團隊可見性、非同步委派、跨複雜專案的預算追蹤。

5,500+ stars 和每週發佈表明這不是空談。但它也是 v0.1.22——預期會有粗糙的邊角、破壞性變更和快速迭代。自架給你完全控制；Multica Cloud 給你零設定的便利。選跟你對基礎設施管理的容忍度相符的那個。

Multica ​

The Complete Guide to Turning Claude Code into Your Remote Teammate ​

Multica ​

讓 Claude Code 變成你的遠端隊友完全指南 ​

What Is Multica? ​

什麼是 Multica？ ​

Architecture at a Glance ​

架構一覽 ​

How to Connect Your Local Claude Code ​

Prerequisites ​

Option 1: Multica Cloud (Fastest) ​

Option 2: Self-Hosted (Full Control) ​

如何接上你的本地 Claude Code ​

先決條件 ​

選項一：Multica Cloud（最快） ​

選項二：自架（完全控制） ​

What Changes After Connecting? The Experience Upgrade ​

Before Multica: The Terminal-Only Experience ​

After Multica: The Teammate Experience ​

接上之後有什麼改變？體驗升級 ​

接上之前：純終端機體驗 ​

接上之後：隊友體驗 ​

When to Use Multica (and When Not To) ​

Ideal Scenarios ​

When Not to Use Multica ​

什麼時候該用 Multica（什麼時候不該） ​

理想場景 ​

不適合的情況 ​

The Daemon Deep Dive: How Claude Code Actually Runs ​

Task Lifecycle ​

The CLAUDE.md Injection ​

Execution Parameters ​

Environment Isolation ​

Concurrency and Limits ​

Daemon 深入解析：Claude Code 實際上是怎麼跑的 ​

任務生命週期 ​

CLAUDE.md 注入 ​

執行參數 ​

環境隔離 ​

並行能力與限制 ​

The Skill System ​

How Skills Get to Claude Code ​

技能系統 ​

技能如何到達 Claude Code ​

Can It Work with Superpowers / GStack Skills? ​

Short Answer: Yes, With Some Assembly Required ​

Integration Patterns ​

Limitations ​

能不能跟 Superpowers / GStack Skills 搭配？ ​

簡短回答：可以，但需要一些組裝 ​

整合模式 ​

限制 ​

Multica vs. Other Approaches ​

Multica 跟其他方案的比較 ​

Configuration Reference ​

Daemon Settings ​

Claude Code Specific ​

Useful CLI Commands ​

設定參考 ​

Daemon 設定 ​

Claude Code 特定設定 ​

實用的 CLI 命令 ​

Summary ​

總結 ​

Multica

The Complete Guide to Turning Claude Code into Your Remote Teammate

Multica

讓 Claude Code 變成你的遠端隊友完全指南

What Is Multica?

什麼是 Multica？

Architecture at a Glance

架構一覽

How to Connect Your Local Claude Code

Prerequisites

Option 1: Multica Cloud (Fastest)

Option 2: Self-Hosted (Full Control)

如何接上你的本地 Claude Code

先決條件

選項一：Multica Cloud（最快）

選項二：自架（完全控制）

What Changes After Connecting? The Experience Upgrade

Before Multica: The Terminal-Only Experience

After Multica: The Teammate Experience

接上之後有什麼改變？體驗升級

接上之前：純終端機體驗

接上之後：隊友體驗

When to Use Multica (and When Not To)

Ideal Scenarios

When Not to Use Multica

什麼時候該用 Multica（什麼時候不該）

理想場景

不適合的情況

The Daemon Deep Dive: How Claude Code Actually Runs

Task Lifecycle

The CLAUDE.md Injection

Execution Parameters

Environment Isolation

Concurrency and Limits

Daemon 深入解析：Claude Code 實際上是怎麼跑的

任務生命週期

CLAUDE.md 注入

執行參數

環境隔離

並行能力與限制

The Skill System

How Skills Get to Claude Code

技能系統

技能如何到達 Claude Code

Can It Work with Superpowers / GStack Skills?

Short Answer: Yes, With Some Assembly Required

Integration Patterns

Limitations

能不能跟 Superpowers / GStack Skills 搭配？

簡短回答：可以，但需要一些組裝

整合模式

限制

Multica vs. Other Approaches

Multica 跟其他方案的比較

Configuration Reference

Daemon Settings

Claude Code Specific

Useful CLI Commands

設定參考

Daemon 設定

Claude Code 特定設定

實用的 CLI 命令

Summary

總結