If you've been using Claude Code, Codex, or similar AI coding agents, you've probably felt the friction: you paste a prompt, watch the run, babysit the output, copy something into the next prompt, and repeat. It works, but it doesn't scale — and it definitely doesn't feel like working with a team.

Multica is an open-source project that tries to fix that. The pitch is simple: treat your AI agents the way you treat human teammates. Assign them issues. Watch them post updates. Let them report blockers. Have them compound skills over time.

What Multica Actually Does

At its core, Multica gives your coding agents a place to live inside your team's workflow. Instead of operating a chatbot in isolation, you assign tasks to an agent the same way you'd assign a GitHub issue to a colleague. The agent picks it up, executes it on a runtime (your local machine or a cloud instance), streams progress back in real time, and posts comments when it needs clarification or hits a wall.

A few things stand out:

Task lifecycle management. Tasks move through states: enqueue, claim, start, complete, or fail. You're not just running a command and hoping — you have visibility into where each task is.

Reusable skills. When an agent solves something well — a deployment script, a migration pattern, a code review checklist — that solution becomes a reusable skill the whole team can pull from. Skills accumulate over time, which is where the "compound" part of the tagline comes from.

Multi-agent, multi-workspace. You can have multiple agents running on different runtimes, organized into workspaces. Each workspace is isolated with its own issues, agents, and settings.

Vendor-neutral. Multica works with Claude Code, Codex, OpenCode, OpenClaw, Hermes, Gemini, Pi, and Cursor Agent. You're not locked into one provider.

The Architecture in Plain Terms

The stack is straightforward:

┌──────────────┐     ┌──────────────┐     ┌──────────────────┐
│   Next.js    │────>│  Go Backend  │────>│   PostgreSQL     │
│   Frontend   │<────│  (Chi + WS)  │<────│   (pgvector)     │
└──────────────┘     └──────┬───────┘     └──────────────────┘
                            │
                     ┌──────┴───────┐
                     │ Agent Daemon │  runs on your machine
                     └──────────────┘

• Frontend: Next.js 16 with the App Router
• Backend: Go with the Chi router, sqlc for type-safe queries, and gorilla/websocket for real-time streaming
• Database: PostgreSQL 17 with pgvector (for skill embeddings and similarity search)
• Agent runtime: A local daemon that auto-detects whatever agent CLIs you have on your PATH

The daemon is the key piece. It bridges your machine (where the actual agent CLI lives) with the Multica server (cloud or self-hosted). When an agent is assigned a task, the server routes it to the appropriate daemon, which spawns the CLI process and streams output back via WebSocket.

Getting Up and Running

Installation is one line:

macOS / Linux:

brew install multica-ai/tap/multica
# or without Homebrew:
curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash

Windows:

irm https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.ps1 | iex

Then connect everything:

multica setup   # authenticate + start the daemon in one command

After that, open the web app, go to Settings → Runtimes, and you should see your machine listed. From there you create an agent (pick a provider and runtime), and you're ready to assign tasks.

The CLI surface is minimal:

If you want to self-host the whole thing (server included), add --with-server to the install script:

curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server
multica setup self-host

This pulls the official Docker images from GHCR. You'll need Docker. The full self-hosting guide lives in SELF_HOSTING.md in the repo.

For Contributors

The dev setup is a single command:

make dev

It auto-detects your environment, sets up the .env file, installs dependencies, runs DB migrations, and starts all services. Prerequisites: Node.js v20+, pnpm v10.28+, Go v1.26+, and Docker.

The codebase is about 53% TypeScript and 43% Go — frontend and backend are clearly separated, which makes it easy to work on one without touching the other.

Multica vs Going Solo With an Agent CLI

Here's an honest comparison of what Multica adds versus just running claude or codex directly:

What you gain:

• A shared board where your whole team sees what agents are working on
• Real-time streaming progress instead of waiting for a long CLI run to finish
• A skills library that accumulates team knowledge rather than living in individual prompts
• Multi-agent routing — different tasks can go to different agents on different machines
• An audit trail: who assigned what, when, and what happened

What you take on:

• Running a daemon process (or a full server if self-hosting)
• A PostgreSQL database
• The overhead of a web app and task board

If you're a solo developer running occasional agent tasks, the CLI alone might be enough. If you're on a team — even a small one — trying to coordinate multiple agents across projects, Multica addresses a real gap.

Is It Worth Trying?

It depends on where you are with AI agents.

If you're still experimenting and running agents manually on single tasks, Multica is probably more infrastructure than you need right now. Start with the agent CLI directly and see what breaks.

If you've gotten past that point and are starting to feel the coordination pain — agents running on different machines, teammates not knowing what's been automated, the same solutions being re-invented in different prompts — that's exactly the gap Multica is designed to fill.

It's early software (v0.2.x as of this writing), so expect rough edges. But the core loop — assign, execute, report, reuse — is working, and the momentum behind the project is real.

Links:

• GitHub: https://github.com/multica-ai/multica