TechLatest

Posted on Jun 18 • Originally published at faun.pub on Apr 10

The Open-Source Claude Managed Agents Alternative Is Here — Meet Multica

#claudecode #claude #opensource #multica

A few days ago, Anthropic quietly pushed something important into the ecosystem: managed infrastructure for deploying AI agents at scale.

If you’ve used tools like Claude Code, you already know how powerful coding agents have become. They can write code, debug systems, and even reason across complex workflows.

But there’s a catch.

Those agents still don’t work like a team.

And more importantly:

They don’t belong to you.

The Problem: Powerful Agents, Locked Ecosystems

The idea behind managed agents is simple: instead of running prompts manually, you deploy agents that can operate continuously, take tasks, and execute them like autonomous workers.

Anthropic’s approach proves this works. But it comes with limitations:

Claude-only ecosystem
Fully cloud-hosted
Vendor-controlled infrastructure
Limited flexibility

If you want:

self-hosting
multi-agent support
vendor neutrality

…you’re back to building everything yourself — orchestration, execution, tracking, and coordination.

That’s not trivial. It’s an entire system.

Enter Multica — The Open-Source Answer

This is where Multica changes the game.

Multica is essentially the open-source version of Claude Managed Agents , but more flexible, more extensible, and fully self-hostable.

It exploded to 4,000+ GitHub stars in under a week — and for good reason.

Multica doesn’t just give you agents.

It gives you infrastructure for running AI agents like employees.

From Tools to Teammates

What makes Multica fundamentally different is how it redefines interaction.

Instead of prompting:

You assign work.

Instead of running commands:

You manage outcomes.

Instead of babysitting AI:

You collaborate with it.

Inside Multica, agents behave like actual teammates. They appear on the same board as humans. You assign them issues the same way you assign tasks to a colleague. They pick up the work, execute it, and keep you updated.

There’s no prompt copy-pasting. No terminal babysitting.

Just delegation.

How Multica Actually Works

The experience feels surprisingly natural.

You install the CLI, start a daemon on your machine, and Multica automatically detects available agent tools like:

Claude Code
OpenAI Codex
OpenClaw
OpenCode

From there, you create an agent, give it a name, and it shows up in your workspace like any other team member.

Now comes the interesting part.

You create an issue and assign it to the agent.

That’s it.

The agent:

claims the task
creates an isolated environment
executes the work
streams progress in real time
reports blockers
updates status

All of this happens automatically via a runtime system powered by a local daemon and WebSocket streaming.

It’s not a demo.

It’s a working system.

The Real Innovation: Skill Compounding

The most underrated feature in Multica is not autonomy — it’s memory in the form of skills.

Every time an agent completes a task, that solution can be saved as a reusable capability.

Over time, your system evolves.

Day 1:

The agent writes a migration

Day 10:

All agents can write migrations

Day 30:

Agents deploy, test, review, and refactor

This creates something extremely powerful:

A compounding system where your team’s intelligence grows over time.

Not just smarter agents — a smarter organization.

One Board, One Team

Another subtle but powerful idea is the unified interface.

Humans and agents exist in the same workflow:

Same task board
Same assignment system
Same activity feed

There’s no separation between “AI tools” and “team members.”

This matters more than it sounds.

Because the biggest friction in AI adoption today is not capability — it’s integration into real workflows.

Multica solves that.

Why This Matters (More Than You Think)

Anthropic made an important statement:

Agents need managed infrastructure to work in production.

And they’re right.

But what’s even more interesting is what happened next:

The open-source community rebuilt that infrastructure in less than a week.

Multica proves something big:

You don’t need to rely on a single vendor
You don’t need to give up control of your data
You don’t need to rebuild orchestration from scratch

You can run everything on your own terms.

Step 1: Self-Hosting Multica (Your Own Agent Infrastructure)

One of the strongest advantages of Multica is that you can run it entirely on your own infrastructure.

The setup is surprisingly straightforward.

Start by cloning the repository:

git clone https://github.com/multica-ai/multica.git
cd multica
cp .env.example .env

Update your environment variables (at minimum, set a JWT secret), then start the system using Docker:

Before starting Multica, you need to configure its environment variables by editing the .env file, which acts as the app’s configuration layer. This file defines things like database connection details, server URLs, and security keys required for the system to run. The most important step here is updating the JWT_SECRET, which is used to securely sign and verify authentication tokens—leaving it as the default value makes your setup insecure. Once you replace it with a strong random string and save the file, you can start the entire system using Docker, which spins up the database, backend, and frontend services together, making the application ready to use locally.

Step 2: Build and Start Multica Using Docker

After configuring the .env file, the next step is to build and start all services using Docker. Run the following commands in your terminal:

docker compose -f docker-compose.selfhost.yml build --no-cache
docker compose -f docker-compose.selfhost.yml up -d

The first command builds the backend and frontend images from scratch (without using cache), ensuring that all dependencies and recent changes are properly included. The second command starts all services in detached mode, which means PostgreSQL, backend, and frontend run in the background. As shown in the output, Docker loads the build definitions, prepares the containers, and initializes the full Multica stack successfully on your local machine.

Step 3: Access the Multica Dashboard

Once all containers are up and running, you can access the Multica interface directly in your browser. Open:

http://localhost:3000

As shown above, the Multica landing page will load successfully, confirming that your frontend, backend, and database are all working together. This dashboard is your central control panel where you’ll manage agents, assign tasks, and monitor execution. From here, you can log in, create a workspace, and start turning AI agents into real teammates.

Step 4: Connect Your Machine as a Runtime

Right now:

UI is running ✅
Backend is running ✅
But agents can’t execute tasks yet ❌

You need to connect your machine using the CLI.

Install Multica CLI

If not installed:

brew tap multica-ai/tap
brew install multica

Step 5: Log in to Multica

Run:

multica login

What will happen:

The browser will open
You’ll log in (or sign up)
CLI gets authenticated

Step 6: Create and Assign Your First Task to an Agent

Once your agent is created, the final step is to assign it real work. Navigate to the Issues section in your workspace, as shown above. This is where all tasks are created and managed.

Click on “New Issue” from the left sidebar to create a task. You can describe the task in plain English, just like assigning work to a developer. For example:

Create a simple REST API in Node.js with an endpoint /health that returns { status: "ok" }

After creating the issue, assign it to the agent you created earlier. As soon as the assignment is made, the agent will automatically pick up the task, start execution on your local runtime, and begin reporting progress in real time.

This is where Multica truly shines — instead of manually prompting an AI, you’re delegating tasks and watching them get executed autonomously, just like a real teammate.

Step 7: Understand the Workflow & Board System

Your issue is now visible in the Kanban-style board:

Backlog → Todo → In Progress → In Review → Done

You can:

Move tasks between columns
Update status
Track progress manually

This gives you a clear idea of how Multica structures work — even before introducing agents.

Step 8: Create Your First Agent

Now that your system is running and an issue has been created, the next step is to bring AI into the workflow by creating your first agent. This is what transforms Multica from a simple task board into an autonomous development system.

Inside the dashboard, navigate to the Agents section from the sidebar. This is where you define AI teammates that can pick up and execute tasks. Click on the “Create Agent” button, and you’ll be prompted to configure a new agent.

At this stage, you give your agent a name, such as Backend Developer or API Builder, and select the runtime provider. Multica automatically detects available agent runtimes on your machine — in your case, you’ll see options like OpenCode or OpenClaw, which were registered when the daemon started successfully.

OpenCode (recommended) → More stable for general coding tasks → Better for things like APIs, scripts, backend work → Easier to start with (less friction)
OpenClaw → More experimental → Sometimes better for complex reasoning workflows → But it can be less predictable for beginners

Once created, the agent becomes part of your workspace just like a human teammate. It will appear in assignment dropdowns, activity feeds, and task boards. This is a key concept in Multica — agents are not treated as tools, but as actual collaborators that can own and execute work.

Under the hood, the agent is connected to your local runtime via the Multica daemon, which means it can securely execute tasks, create code, and interact with your development environment while streaming progress back to the UI in real time.

This step marks the transition from manual task tracking to autonomous execution. You’re no longer just managing work — you’re enabling a system where AI can actively contribute to it.

Step 9: Assign the Issue to Your Agent

Now that your agent is configured, the next step is to give it work.

Go back to your Issues / My Issues board where you created the task:

“Create a simple REST API in Node.js with /health endpoint”

Click on that issue card, and in the assignee section , select your newly created agent:

Backend Developer or API Builder

The moment you assign the issue, something powerful happens behind the scenes. The Multica daemon picks up the task, the agent claims it, and starts working in an isolated environment. You don’t need to write prompts or manually trigger anything — the agent behaves like a real teammate who just got assigned a ticket.

You’ll start seeing activity updates, logs, and progress as the agent executes the task. Depending on the runtime, it may generate code, structure the project, and even explain what it built.

When I first assigned the task to the agent, it failed. This wasn’t a bug, but an important realization — unlike simple AI tools, Multica agents require an actual workspace to operate. Once I connected a repository, the agent had a place to write code, and execution started working as expected.

Conclusion: From AI Tools to Autonomous Systems

What Multica ultimately represents is a shift in how we think about AI in software development. For the past couple of years, most of us have interacted with AI through prompts — asking questions, generating snippets, and manually stitching things together. It has been powerful, but still very hands-on. Multica changes that interaction model entirely. Instead of treating AI as something you constantly instruct, it turns it into something you collaborate with.

By combining agents, runtimes, task management, and execution infrastructure into a single system, Multica moves us closer to a world where AI doesn’t just assist — it actively participates. You’re no longer just generating code; you’re assigning responsibility. And that subtle shift has massive implications for how teams operate.

What makes this even more significant is the fact that it’s open-source and self-hostable. In a landscape where most powerful AI systems are locked behind APIs and vendor ecosystems, Multica gives developers control — over their infrastructure, their data, and their workflows. It proves that you don’t need to rely entirely on closed systems to build something production-ready and scalable.

Of course, it’s still early. There are rough edges, setup challenges, and moments where things don’t work perfectly (as we saw with the initial agent failure). But that’s exactly what makes this space exciting. The foundation is already here — and it’s evolving fast.

If you zoom out, Multica isn’t just another AI tool. It’s a glimpse into how future engineering teams might operate — a hybrid workforce where humans and agents collaborate seamlessly on the same problems, in the same systems, with shared context.

And once you experience that shift, it’s hard to go back to just writing prompts.