- Multica is a free open-source platform that manages AI coding agents the way teams manage human contributors — with tasks, blockers, and updates.
- AI coding agents in Multica accumulate reusable skills over time, so solutions to common problems don’t get lost in old prompt histories.
- The platform supports eight major agent providers including Claude Code, Codex, Gemini, and Cursor, with no vendor lock-in.
- Installation takes a single terminal command, and self-hosting with Docker is fully supported for teams that want to keep everything on-premises.
The Problem Nobody Talks About With AI Coding Agents
If you’ve spent any real time working with AI coding agents — Claude Code, OpenAI’s Codex, Cursor Agent — you’ve probably run into the same invisible ceiling. The individual interactions are impressive. The workflow, as soon as more than one person or more than one task is involved, falls apart fast. You paste a prompt, watch the output scroll by, tweak something, paste again. It works. It just doesn’t scale. And it definitely doesn’t feel like running a team.
That’s the gap a new open-source project called Multica is trying to close. The core idea is deceptively simple: stop treating AI coding agents like chatbots and start treating them like teammates. Assign them issues. Let them report blockers. Watch their progress stream in real time. Let the things they learn accumulate into shared knowledge the whole team can use.
It’s early software — the project is currently at v0.2.x — but the fundamental loop is working, and the timing couldn’t be more relevant. As more development teams start integrating AI agents into daily workflows, the coordination problem is getting harder to ignore.
What Multica Actually Does for AI Coding Agents
At its core, Multica gives AI coding agents a home inside your existing team workflow rather than a isolated terminal window. You create an agent, assign it a task the same way you’d assign a GitHub issue to a colleague, and the agent picks it up, executes it on a connected runtime (your local machine or a cloud instance), and streams progress back in real time. When it needs clarification or hits something it can’t resolve, it posts a comment — just like a developer would.
The task lifecycle is explicit and trackable: tasks move through states — enqueued, claimed, started, completed, or failed. That visibility matters more than it might sound. Right now, most teams running AI coding agents have no shared view of what’s been automated, what’s in progress, or what broke last Tuesday. Multica gives you an audit trail by default.
A few features stand out as genuinely interesting rather than just table-stakes infrastructure:
- Reusable skills. When an agent handles something well — a deployment script, a database migration pattern, a code review checklist — that solution gets saved as a reusable skill the whole team can pull from. Skills accumulate over time. That’s the “compound” in Multica’s tagline, and it’s addressing one of the most frustrating aspects of current AI agent workflows: every developer reinventing the same prompts from scratch.
- Multi-agent, multi-workspace routing. You can run multiple agents across different machines, organized into isolated workspaces with their own issues, agents, and settings. Different tasks can be routed to different agents on different runtimes — useful when, say, a frontend task should go to a Cursor Agent while a backend migration goes somewhere else.
- Vendor neutrality. Multica works with Claude Code, Codex, OpenCode, OpenClaw, Hermes, Gemini, Pi, and Cursor Agent. You’re not locked into one provider, which matters as the competitive dynamics in the AI coding agents space continue to shift rapidly.
Under the Hood: A Sensible Tech Stack
The architecture is straightforward and well-separated. The frontend runs on Next.js 16 with the App Router. The backend is Go using the Chi router, with sqlc for type-safe database queries and gorilla/websocket handling the real-time streaming. The database is PostgreSQL 17 with pgvector — that last part is what powers skill embeddings and similarity search, which is how Multica can surface relevant past solutions when a new task comes in.
The piece that ties everything together is a local daemon. It’s a small process that runs on your machine and bridges the gap between the Multica server (cloud-hosted or self-hosted) and whatever agent CLIs you’ve got installed. The daemon auto-detects agent CLIs on your PATH, so you don’t need to configure anything manually. When a task gets assigned to an agent, the server routes it to the right daemon, which spawns the CLI process and streams output back over WebSocket.
The codebase is roughly 53% TypeScript and 43% Go, with a clean separation between frontend and backend. That’s a sensible split for an open-source project — contributors can work on one side without needing to understand the full stack.
Getting AI Coding Agents Up and Running With Multica
Setup is genuinely fast. One command installs everything on macOS or Linux via Homebrew, or via a curl script if you prefer. Windows users get a PowerShell equivalent. Then:
- Run multica setup to authenticate and start the daemon in one shot
- Open the web app, go to Settings → Runtimes, and your machine shows up automatically
- Create an agent, pick a provider, pick a runtime, and start assigning tasks
For teams that want to keep everything on-premises, self-hosting is fully supported. Adding –with-server to the install script pulls the official Docker images from GitHub Container Registry. The project’s SELF_HOSTING.md covers the full configuration. For contributors who want to run the full development environment, a single make dev command auto-detects your environment, handles .env setup, installs dependencies, runs database migrations, and starts all services. Prerequisites are Node.js v20+, pnpm v10.28+, Go v1.26+, and Docker.
Is Multica Worth the Infrastructure Overhead?
That depends on where you are in your AI agent journey. For a solo developer running occasional one-off tasks, the raw CLI is probably enough. The overhead of a daemon, a PostgreSQL database, and a task board isn’t justified for light usage.
But here’s the honest case for Multica: if you’re on a team — even a small one — and you’ve started running AI coding agents with any regularity, the coordination problems arrive faster than you’d expect. Who knows what’s been automated? What did the agent actually do last week? Why does every developer have their own private prompt history for the same recurring tasks? Multica is a direct answer to those questions.
The comparison to tools like Linear or GitHub Issues is apt. Those tools didn’t create the concept of task tracking — they just made it structured, visible, and shared. Multica is doing the same thing for AI agent workflows. The analogy to managing human teammates isn’t just marketing language; it’s the actual design philosophy.
What Multica takes on in return is real: you’re running additional infrastructure. A daemon process, a database, a web app. That’s not nothing. But for teams already running Docker and PostgreSQL as standard practice, the marginal cost is low.
The Bigger Picture for AI Coding Agents in 2025
The release of Multica lands at an interesting moment. The biggest AI coding agents — Claude Code from Anthropic, Codex from OpenAI — have both seen massive adoption spikes this year, and the tooling ecosystem around them is scrambling to catch up. Most of the current infrastructure was built for single-developer, single-task use. The assumption was that a developer would run an agent, review the output, and move on. That assumption is breaking down as teams try to run agents continuously, in parallel, across projects.
Multica isn’t the only project thinking about this. Platforms like LangChain’s LangGraph and Microsoft’s AutoGen are attacking the multi-agent coordination problem from the framework side. But Multica takes a more pragmatic, team-workflow-first approach — it’s less about building complex agent graphs and more about giving existing agent CLIs a coherent home inside a real team process.
Whether it becomes the standard layer for managing AI coding agents at the team level will depend on how quickly the project matures and how the community around it grows. At v0.2.x, rough edges are expected and present. But the architecture is sound, the problem it’s solving is real, and the momentum appears genuine. As AI agents move from experimental tools to standard parts of the development stack, platforms like this stop being optional infrastructure and start being the thing that makes the whole operation legible.
