Multica (32K stars, trending #4 TypeScript) is not another agent wrapper. It is a persistent management layer that treats coding agents as stateful teammates. You assign an issue to an agent the same way you assign to a colleague. The agent picks up the work, writes code, reports blockers, updates status, and accumulates reusable skills across sessions.
The shift is from ephemeral prompt-driven runs to persistent task ownership. Most agent frameworks execute a single task and exit. Multica keeps agents on the board, synchronizes their state with your project tracker, and routes work through Squad delegation patterns when you need multi-agent coordination.
What Multica Does
Multica provides three core layers:
- Persistent task queue: Issues remain assigned to agents across sessions. Partial completion states survive restarts.
- Skill compounding: Agents extract reusable capabilities from completed work and invoke them in future tasks.
- Squad routing: A leader agent receives delegated work and routes subtasks to specialized members based on skill match and availability.
It integrates with Claude Code, Codex, GitHub Copilot CLI, OpenClaw, OpenCode, Hermes, Gemini, Pi, Cursor Agent, Kimi, and Kiro CLI. The platform is vendor-neutral and self-hosted.
Architecture: Task Persistence and State Sync
Task Queue Mechanics
Multica stores agent assignments in a persistent queue backed by a relational database (PostgreSQL by default). Each task record includes:
- Issue ID and source (GitHub, Linear, Jira)
- Assigned agent identifier
- Current state (queued, in_progress, blocked, completed)
- Partial completion artifacts (branch name, draft PR, test results)
- Blocker metadata (error logs, dependency conflicts, human escalation flag)
When an agent starts work, it locks the task row with a lease timeout. If the agent crashes or the lease expires, the task returns to the queue. A background reconciliation loop checks for stale leases every 30 seconds and resets them.
Status Synchronization Protocol
Multica maintains a bidirectional sync between its internal task state and external project trackers:
- Inbound sync: Webhook listeners receive issue updates from GitHub/Linear/Jira and update the task queue.
- Outbound sync: Agents emit status events (started, progress, blocked, completed) that trigger API calls to update the source tracker.
- Conversation threading: Agent comments are posted to the issue thread in the source system, preserving context for human reviewers.
The sync protocol uses optimistic locking with version counters. If two agents or a human and an agent update the same issue simultaneously, the second write detects the version mismatch and retries with the latest state.
Skill Compounding Layer
After completing a task, agents can extract reusable capabilities and store them in a skill library. A skill is a named function with:
- Input schema (JSON Schema)
- Execution template (shell script, API call sequence, or agent prompt)
- Success criteria (exit code, output pattern, test assertion)
Skills are indexed by tags (e.g., “database-migration”, “API-integration”, “test-generation”). When an agent receives a new task, it queries the skill library for relevant matches and includes them in its tool inventory.
Example skill extraction flow:
// After agent completes a database migration task
const skill = {
name: "apply_prisma_migration",
tags: ["database", "prisma", "migration"],
inputSchema: {
type: "object",
properties: {
migrationName: { type: "string" },
environment: { type: "string", enum: ["dev", "staging", "prod"] }
},
required: ["migrationName", "environment"]
},
executionTemplate: `
npx prisma migrate deploy --name {{migrationName}}
npx prisma generate
npm run test:db
`,
successCriteria: {
exitCode: 0,
outputPattern: "Migration.*applied successfully"
}
};
await skillLibrary.store(skill);Skills compound over time. An agent working on a new migration task finds the apply_prisma_migration skill, invokes it, and avoids re-learning the same workflow.
Squad Routing: Leader-Based Delegation
Squads introduce a stable routing layer for multi-agent work. A Squad consists of:
- Leader agent: Receives delegated tasks, decomposes them into subtasks, and routes to members.
- Member agents: Specialized workers (e.g., frontend, backend, testing, documentation).
- Routing policy: Rules for task assignment based on skill tags, agent availability, and historical performance.
Delegation Flow
- Human assigns a complex issue to the Squad leader.
- Leader agent analyzes the issue, identifies required skills, and generates subtasks.
- Leader queries the skill library and member availability.
- Leader assigns subtasks to members and monitors progress.
- If a member reports a blocker, the leader escalates to a human or reassigns to another member.
Routing Decision Table
| Subtask Type | Skill Tags Required | Assigned To | Fallback Strategy |
|---|---|---|---|
| API endpoint | backend, REST, validation | Backend agent | Leader handles if blocked |
| UI component | frontend, React, styling | Frontend agent | Leader handles if blocked |
| Integration test | testing, E2E, Playwright | Testing agent | Queue for human review |
| Documentation | docs, markdown, API-spec | Documentation bot | Leader generates draft |
The routing policy is configurable. You can specify hard constraints (e.g., “never assign database tasks to frontend agent”) or soft preferences (e.g., “prefer agent with highest success rate for this skill tag”).
Observability and Failure Modes
Monitoring Hooks
Multica exposes metrics and logs through:
- Task queue depth: Number of queued, in-progress, and blocked tasks per agent.
- Lease timeout rate: Percentage of tasks that expire without completion.
- Skill invocation success rate: Percentage of skill executions that meet success criteria.
- Sync conflict rate: Frequency of version mismatches during status updates.
These metrics feed into Prometheus or Datadog. Alerts trigger when lease timeout rate exceeds 10% or sync conflict rate spikes.
Common Failure Modes
| Failure Mode | Symptom | Mitigation |
|---|---|---|
| Agent crashes mid-task | Task stuck in in_progress state | Lease timeout resets task to queue |
| Skill execution fails | Agent reports blocker, task moves to blocked | Leader reassigns or escalates to human |
| Sync conflict storm | Multiple agents update same issue | Exponential backoff on retry, version locking |
| Skill library query timeout | Agent cannot find relevant skills | Fallback to zero-shot task execution |
| Leader agent unavailable | Squad tasks pile up in queue | Promote a member to temporary leader |
Deployment Shape
Multica runs as a monorepo with three services:
- API server (Node.js, Express): Handles task queue operations, skill library queries, and webhook listeners.
- Agent runtime (TypeScript, isolated containers): Executes agent code with sandboxed filesystem and network access.
- Sync worker (background job processor): Polls external trackers and reconciles state.
Self-hosted deployment uses Docker Compose or Kubernetes. The recommended setup:
- PostgreSQL for task queue and skill library
- Redis for lease locking and rate limiting
- S3-compatible storage for agent artifacts (logs, diffs, test results)
Cloud deployment (multica.ai) adds managed authentication, multi-tenancy, and observability dashboards.
Security Boundaries
Agents run in isolated containers with:
- Read-only access to the codebase (mounted as volume)
- Write access to a scratch directory for generated files
- Network access restricted to approved API endpoints (configurable allowlist)
Secrets (API keys, database credentials) are injected as environment variables and never logged. Agent output is sanitized to remove credentials before posting to issue threads.
The skill library enforces input validation. Skills cannot execute arbitrary shell commands unless explicitly marked as trusted by a human administrator.
Technical Verdict
Use Multica when:
- You want agents to own tasks across sessions, not just execute one-off prompts.
- You need a vendor-neutral layer that works with multiple agent backends (Claude, Codex, Copilot).
- You want agents to accumulate reusable skills and improve over time.
- You need multi-agent coordination with Squad delegation patterns.
Avoid Multica when:
- You only need ephemeral agent runs (a simple CLI wrapper is sufficient).
- Your agents require real-time spatial coordination (Spine Swarm is better for that).
- You need browser-based orchestration (Agent MCP Studio handles that layer).
- You want fully managed cloud sandboxes (Twill.ai provides that).
Multica fills the operational gap between “agent runs a task” and “agent is a team member.” It is infrastructure for persistent, stateful agent management.