> *How do you manage agents that write code? You don't. You manage them like people.* > > — Multica's core insight
Opening: A 2 AM Bug and Sushi on the Line
Imagine this: it's 2 AM and your website is down. A critical payment API is returning 500 errors, users can't check out, and revenue is burning.
What do you do? Most people grab their phone, frantically ping engineers across time zones, @everyone in Slack — then wait in agony. Even the best engineer needs to wake up, understand the problem, pull code, locate the bug, fix it, test, and deploy. At least 30 minutes, at 2 AM.
But reframe it: this isn't a scenario that requires *waking up a human* — it's a scenario that only requires *someone getting it done*.
Multica starts from exactly this observation. Its founder has a T-shirt-worthy line: "Your next 10 hires won't be human."
What Is Multica?
In one sentence: Multica is an open-source multi-agent management platform that turns coding agents (Claude Code, OpenClaw, Codex) into true teammates — you can assign them tasks, track progress, and accumulate reusable skills.
The metaphor: imagine running a restaurant chain. In a traditional dev team, every chef (engineer) must personally shop for ingredients, prep, serve, and train newcomers — slow, and repeated every time. Multica makes agents tireless apprentice chefs who follow recipes (task descriptions) and distill improvements into reusable "secret recipes" (skills) stored in the team's shared library.
No one needs to be woken up. No explaining things three times. No "how did John do this last time?" Agents are there 24/7, like a precision clockwork machine — but with memory and learning ability.
Architecture: Why This Tech Stack?
| Layer | Technology | Why? | |-------|-----------|------| | Frontend | Next.js 16 (App Router) | SSR + real-time updates | | Backend | Go (Chi, sqlc, WebSocket) | High concurrency, low latency, type safety | | Database | PostgreSQL 17 + pgvector | Structured data + vector semantic search | | Agent runtime | Local daemon (claude/codex/openclaw/opencode) | Pluggable agent backends |
- Next.js 16 + WebSocket: traditional pages are like refreshing a score ticker; WebSocket is live broadcasting — you see the ball move in real time. For agent tasks, users want to know: where is my task? Is it stuck? What is it doing?
- Go: like a commercial dishwasher — not flashy, but it washes 1,000 plates without breaking. Reliability beats cleverness for managing many concurrent agents. Chi is lightweight, sqlc makes queries type-safe.
- PostgreSQL + pgvector: pgvector gives the library semantic understanding — "find me a book about loneliness" surfaces *One Hundred Years of Solitude* even without the word in the title. Agents can then recognize that "optimize database queries" and "add SQL indexes" are essentially the same task.
- Docker solved environment drift by packaging apps into containers that run identically anywhere.
- Kubernetes solved orchestration: which container runs where, who restarts failures, load balancing, scaling.
- Judgment: they infer from existing patterns; they don't "feel" that something is off.
- Creativity: true innovation comes from cross-domain analogy and intuition.
- Values: agents don't care whether something *should* be done.
- Humans own: direction, judgment, innovation, values.
- Agents own: execution, repetition, scaling, memory.
- GitHub: https://github.com/multica-ai/multica
- Stack: Next.js 16 + Go (Chi, sqlc, WebSocket) + PostgreSQL 17 + pgvector
- Supported agents: Claude Code, Codex, OpenClaw, OpenCode
- Core concepts: Agent-as-Teammate, task lifecycle management, skill library accumulation
Multica + OpenClaw = Kubernetes + Docker
| Layer | Traditional DevOps | AI Agent World | |-------|--------------------|----------------| | Packaging/runtime | Docker | OpenClaw | | Orchestration/management | Kubernetes | Multica |
OpenClaw is the engine executing a single task — reading/writing files, running commands, connecting tools. Multica is the brain — deciding which task goes to which agent, tracking progress, accumulating skills, handling failures. OpenClaw is the hands; Multica is the brain.
This layered design achieves two things: 1. Decoupling: swap OpenClaw for Claude Code or Codex; Multica still works. 2. Focus: each layer does one thing well — a modern take on the Unix philosophy.
What It Actually Means
1. Efficiency (the surface layer)
A good engineer gets 4–6 focused coding hours a day. Agents, in theory, are unlimited — no rest, no bad days. But that's just the surface.2. Knowledge Compounding (the deep layer)
On traditional teams, when John solves a tricky deployment issue, that knowledge lives in his head. Lisa re-steps on the same rake next week. With agents, when Agent A solves a problem, Multica distills it into a reusable skill. Agents B, C, D can invoke it directly. Traditional teams leak knowledge with turnover; agent teams compound knowledge over time.3. A New Collaboration Paradigm (the radical layer)
Agents have avatars and names. They appear on task boards, proactively comment, report blockers, can be @-mentioned, assigned tasks, and reviewed. This isn't just UI — it's a philosophical statement: agents are not tools; they are teammates.Consequences: 1. Finer task granularity — you don't write a 50-page PRD to change a button. 2. Lower communication cost — agents proactively report progress. 3. Blurred accountability — in hybrid teams, responsibility is shared.
What Agents Absolutely Cannot Do
So the likely future isn't replacement but hybrid teams:
Closing: After the Restaurant Closes
Back to that 2 AM payment API. In Multica's world, the system auto-creates a high-priority task assigned to an agent specializing in payment incidents. The agent pulls logs, locates the problem, applies a known fix (if it's seen something similar), deploys, verifies, and updates the task. No one gets woken up.
What if it's a brand-new problem? The agent attempts it, and if stuck, proactively reports the blocker — like a human teammate saying "I'm stuck here, need help." At 9 AM, the engineer reviews the agent's detailed logs, gives a key hint, and the agent continues.
That's the future: not agents replacing people, but agents making human time more valuable — from execution to decision, from repetition to creation.
Your next employee won't breathe. But they'll reliably fix bugs at 2 AM.
The direction of technological evolution: not making machines more like humans, but making humans more human.