Build Your AI Coder Army for Free

Powerful AI coding agents like Claude Code, OpenCode, and Hermes deliver impressive results, but they often operate in isolated command-line interfaces. This siloed existence makes managing, coordinating, and scaling their contributions across complex development projects nearly impossible. Developers currently struggle to integrate these potent individual tools into a coherent workflow, losing crucial context and making progress tracking difficult.

Developing an agentic coding system moves far beyond simple prompt-and-response interactions. These advanced AI entities can plan, execute, and adapt their strategies across an entire codebase. They autonomously identify necessary tasks, break down complex problems, write and test code, fix bugs, and even update project statuses without constant human oversight. Such systems aim to function as genuine teammates, capable of contributing meaningfully and autonomously to an ongoing development cycle.

Multica emerges as the critical solution bridging this gap between individual agent power and collaborative team efficiency. This open-source platform transforms disparate AI coding agents into a cohesive, manageable workforce. It provides a robust project management layer where users can create custom agents, each with unique system prompts and skills, then assign them specific tasks with clear status updates and priorities.

Multica allows developers to schedule recurring work for their AI agents and monitor their progress via familiar Kanban-style boards. Agents appear as assignees alongside human team members, integrating seamlessly into existing project workflows. Offering a unified dashboard for local daemons and cloud runtimes, Multica automatically detects installed CLIs like Claude Code, OpenClaw, and OpenCode, providing real-time monitoring and control. This robust system empowers developers to build and manage their own AI coder army, scaling capabilities dramatically and efficiently. Multica effectively elevates AI from a mere tool to an an indispensable, collaborative AI team within the development pipeline.

Multica emerges as an indispensable open-source project management layer, transforming isolated AI coding agents into a cohesive, manageable workforce. This "command center" directly addresses the challenge of orchestrating powerful AI models that often operate within complex command-line interfaces, bridging a critical gap for knowledge workers. It provides a unified environment to manage and scale your burgeoning AI team effectively, solving multi-model and multi-agent collaboration hurdles.

The platform empowers users to create highly customized agents, each equipped with unique system prompts and specialized skills. Developers can tailor these AI teammates precisely, defining their core directives and equipping them with the necessary tools to execute tasks efficiently. This granular control allows for precise delegation of coding assignments, problem-solving initiatives, and even the creation of reusable skill sets from successful agent solutions.

Task assignment and tracking are central to Multica's design, employing a familiar Kanban board interface. Users can assign issues, set priorities, and monitor progress with real-time status updates, mirroring human-centric project management tools. Multica treats these AI agents as first-class teammates, integrating them seamlessly into mixed human-AI workflows; they appear directly alongside human colleagues in assignee lists, autonomously reporting blockers and updating task statuses. The system even supports scheduling recurring work, ensuring continuous automated operations.

Beyond its core management capabilities, Multica boasts extensive compatibility, supporting a wide array of AI agents far beyond the popular Claude Code. The platform automatically detects and integrates with various terminal coding tools. This broad support includes: - OpenCode - Hermes - OpenClaw - Codex CLI - Gemini - Pi - Cursor Agent

This comprehensive agent integration cultivates a versatile environment, enabling teams to leverage diverse AI capabilities from a single, intuitive dashboard. Multica stands as a robust, budget-friendly open-source alternative to proprietary managed agent solutions, allowing users to harness their existing AI subscriptions for personal and team projects without vendor lock-in.

Opting for self-hosting Multica, the open-source agent command center, fundamentally boils down to two critical factors: security and control. Unlike many managed AI services, deploying Multica on your own infrastructure grants unparalleled sovereignty over your code and operational data. This approach ensures your intellectual property remains within your purview, sidestepping third-party data policies and potential vulnerabilities.

Running Multica on a dedicated Virtual Private Server (VPS) — as demonstrated with a Hetzner instance — fortifies your security posture. Your AI agents process sensitive code and execute tasks entirely within your environment, potentially secured further with network overlays like Tailscale. This prevents proprietary information from traversing external cloud providers, safeguarding your development workflows and project specifics from external exposure or compliance headaches.

Beyond security, self-hosting offers significant cost advantages. Leveraging a budget-friendly VPS from providers like Hetzner, coupled with Multica's open-source nature, dramatically undercuts the recurring costs of proprietary managed agent platforms or Anthropic's paid routines. This DIY strategy transforms a potentially expensive operational cost into an affordable, scalable solution for individuals and small teams. For more information on the project, visit Multica.

However, this autonomy comes with responsibilities. Self-hosting demands a commitment to setup, ongoing maintenance, and ensuring robust security practices. Users must handle software updates, database management, and network configuration. Additionally, you forgo certain conveniences found in cloud-native solutions, such as native mobile notifications or direct integrations with communication platforms like Telegram, as highlighted by the video's honest assessment of the agent setup Multica offers.

Orchestrating your AI coder army begins with a robust self-hosting strategy. Your battle plan requires three critical prerequisites: a Virtual Private Server (VPS), exemplified by a Hetzner instance in the demonstration, Docker installed on that VPS, and a terminal coding agent like Claude Code or Open Code already set up. This foundation ensures Multica has the environment and tools to manage your AI workforce effectively.

Installation commences with a single Docker command, which automatically deploys Multica's core components. This action establishes three distinct containers: the Multica backend, written in Go; the Multica frontend, built with TypeScript and Next.js; and a PostgreSQL database, essential for storing session information and project data. This containerized setup streamlines deployment and ensures all necessary services are provisioned and interconnected.

Following the initial deployment, you must run `multica setup self-host`. The video highlights a common authentication hurdle here, specifically with external email services. To circumvent this, modify the `.multica/server/.env` file directly, setting `APP_ENV=development` and ensuring the `RESEND_API_KEY` value remains empty. After restarting your containers to apply these changes, you can log in using the default code `888888`.

The final step connects the Multica daemon to your instance, enabling it to interact with your installed coding agents. Navigate to settings within the Multica UI, generate a new API token, and then use `multica login --token [YOUR_TOKEN]` in your VPS terminal. Stop and restart the daemon to activate it. This daemon continuously checks for installed agent binaries, polls Multica for assigned tasks, and efficiently spawns multiple agents using worktrees to execute these tasks. Crucially, this setup allows you to connect multiple VPS machines to a single Multica UI, unifying management across diverse computational resources.

Authentication presented the first hurdle for self-hosters. Multica’s default configuration attempts email verification, a process requiring an external Resend API key. The video creator bypassed this by directly editing the `.env` file located within the `.multica/server` directory on the VPS.

Within that file, setting `APP_ENV=development` was crucial. Equally important was clearing the value for `RESEND_API_KEY`, leaving it empty. After restarting the Docker containers to apply these environment variable changes, the system accepted a simplified login using the default code of six eights.

With the Multica UI accessible, the next challenge involved connecting the local runtime—your coding agents installed on the VPS—to the frontend. This requires navigating to the UI's settings to generate a new API token. Back on the VPS, executing `multica login --token [YOUR_TOKEN]` establishes the critical link.

An initial `multica daemon status` check might show an error if no terminal coding tools are installed. The daemon requires agents like Claude Code or Open Code to function. Once agents are present and the login command is executed, the `multica daemon` scans for these binaries, polls Multica for assigned tasks, and then spawns multiple agents using worktrees to execute them.

This architecture offers significant scalability. Users can connect numerous machines or VPS instances, each hosting different agents and leveraging its own unique API token, to a single Multica UI. This effectively centralizes management, allowing you to orchestrate an entire distributed AI coder army from one dashboard.

Forging your first AI agent within Multica’s intuitive UI begins by navigating to the agents section and clicking the prominent plus button. This initiates a guided creation flow, exemplified in the video by the "Medi-Bot"—a specialized agent configured for personalized medical information retrieval. This initial step swiftly establishes a new AI entity, ready for tailored assignments.

Defining the System Prompt is paramount, as it imbues the agent with its core identity, behavioral guidelines, and operational directives. For the Medi-Bot, this prompt directed it to securely access medical data from a private GitHub repository. A significant advantage of self-hosting Multica emerges here: instead of relying on the agent to clone sensitive data, users can pre-clone such repositories directly onto their VPS, enhancing data sovereignty and streamlining agent startup by providing immediate access to necessary files.

Agents inherit a foundational set of skills directly from their underlying CLI tools, such as Open Code or Claude Code | Anthropic's agentic coding system, which the Multica daemon automatically detects and makes available. However, Multica's interface provides a powerful, user-friendly layer for augmenting these inherent capabilities. Developers can add bespoke custom skills directly within the UI, creating new functions specific to the agent's role, as demonstrated by the video creator adding a "test skill" to illustrate this granular expansion of the agent's toolkit beyond its CLI origins.

Granular control extends further to defining specific environment variables, allowing for precise, context-specific configurations that tailor the agent's operational parameters without affecting system-wide settings. Crucially, Multica enables passing custom arguments directly to the underlying CLI command, such as `Open Code run`. This robust feature empowers developers to enforce specific execution behaviors, like compelling an agent to utilize a particular large language model (e.g., the "Big Pickle model from Open Code Zen"), or adjusting concurrency limits, ensuring consistent performance, resource allocation, or adherence to specific model capabilities for critical tasks.

This dual approach ensures that while agents leverage the inherent power and versatility of installed command-line tools, Multica acts as a sophisticated, intelligent management layer. It transforms generic, often isolated, CLI agents into highly specialized, task-oriented teammates, each finely tuned with bespoke prompts, custom skills, and precise execution parameters. This comprehensive control fosters a truly customized and efficient AI workforce, seamlessly integrated into your project management pipeline.

Multica fundamentally transforms AI agent management by framing tasks as "issues," a paradigm immediately recognizable to users familiar with modern project management platforms. Initiating a workflow begins with creating a new issue, as demonstrated by the 'medical question' task, explicitly prompted with: "Can you check my medical information and let me know if I can eat calamari?" This direct instruction effectively sets the AI's objective, forming the bedrock of its subsequent operations.

Within Multica's intuitive issue interface, users define comprehensive task parameters, including priorities, due dates, and traditional assignees, mirroring capabilities found in established issue trackers. A pivotal moment occurs when the prompt is finalized and the task is assigned to a specific AI agent, such as the custom-built Medi-Bot. This assignment is more than a label; it serves as the immediate trigger for the agent, compelling it to initiate its work autonomously, without requiring any further manual intervention from the user.

The agent's progress unfolds visibly on Multica’s integrated Kanban board, offering real-time status updates. Upon assignment, the task automatically shifts from the 'To Do' column to 'In Progress', dynamically reflecting the Medi-Bot's active engagement. As the agent systematically executes its directives, researching and formulating its response, it autonomously transitions the task to 'In Review', signaling its completion and readiness for human validation or further action. This automated movement ensures a continuously updated project overview.

Central to Multica’s operational transparency is its comprehensive execution history log, accessible for every task. This invaluable feature provides granular insight into the agent's entire operational sequence. For the Medi-Bot, this log meticulously details every `bash` tool call it executed, such as commands issued to query the locally cloned medical information repository. It captures the exact commands run, their respective outputs, and the agent's evolving internal reasoning, offering complete auditability and a profound understanding of its decision-making process throughout the task lifecycle.

Multica’s Autopilot feature stands out as the robust, open-source counterpart to Anthropic’s paid 'Routines,' democratizing powerful scheduled automation for your self-hosted AI agent ecosystem. This crucial capability transforms reactive AI usage into proactive workflow management, empowering users to delegate recurring, time-sensitive tasks to their custom agents, significantly reducing manual oversight, and building a true "AI coder army."

Initiating a recurring task within the Multica UI is an intuitive process, designed for efficiency. Users navigate to the dedicated Autopilot tab, then select "start from scratch" to define a new automated workflow. The video effectively illustrates this by configuring an agent to fetch daily newsletter articles, showcasing Autopilot’s immense potential for consistent information gathering, automated content curation, or even routine data analysis without constant human intervention, thereby freeing up valuable developer time.

The configuration sequence is both precise and user-friendly, ensuring agents execute tasks exactly as intended. First, you explicitly select the designated AI agent from your roster, assigning ownership and leveraging its specialized system prompt and skills for the upcoming routine. Next, you compose a clear, detailed prompt that unambiguously defines the agent's objective and expected output, for instance, "Summarize the top three tech headlines from today's major newsletters, highlighting any AI-related developments." The final, critical step involves setting the execution schedule, specifying granular parameters such as "daily at 9:00 a.m. London time," guaranteeing the task runs consistently and punctually.

While Multica’s Autopilot currently presents certain limitations compared to its commercial counterparts, notably the absence of direct API or GitHub event triggers for dynamic initiation, its core strength lies in reliable, time-based scheduled automation. This focus makes it exceptionally potent for a vast array of continuous operations. Think generating daily project status reports, aggregating market intelligence, performing routine system health checks, managing recurring code reviews, or even automating simple data migration tasks. Autopilot transforms intermittent agent interactions into a continuous, self-sustaining operational framework, maximizing the efficiency and utility of your AI coder army. This feature alone provides a compelling reason to embrace Multica for ongoing, automated tasks, ensuring your agents are always working for you.

Video creator expressed a personal reluctance for agent communication through Kanban boards, preferring a more dynamic, conversational interface. This critique highlights a common desire for real-time debugging alongside AI agents. Users want to intervene, ask clarifying questions, and guide an agent's thought process as it executes tasks, mirroring human-to-human developer collaboration.

Such direct dialogue enables immediate course correction, preventing agents from veering off track or wasting cycles on incorrect assumptions. It provides a granular level of control, essential when dealing with complex or ambiguous coding challenges where an AI might misinterpret intent or encounter unexpected roadblocks.

Multica's adoption of a Kanban workflow, however, stems from established project management principles designed for scalable, asynchronous work. This paradigm offers a structured approach for managing multiple AI agents and tasks efficiently. Kanban excels at transparent status tracking, clearly delineating "To Do," "In Progress," and "Done" stages for each issue. It facilitates efficient team collaboration, where both human and AI teammates contribute to a unified project view, ensuring everyone understands task progress and dependencies.

Consider the complexity of orchestrating an army of agents across diverse projects; a structured system becomes indispensable for oversight and accountability. While agents leverage powerful underlying models—you can explore these capabilities further in the Models overview - Claude API Docs—their output still benefits immensely from organized oversight. Kanban provides that essential framework.

Multica bridges this perceived gap with its direct chat feature, allowing users to initiate one-off conversations outside the formal issue-tracking process. This offers a hybrid interaction model, combining the structured benefits of Kanban for project management rigor with the immediacy of direct dialogue for agile debugging and impromptu guidance, catering to a broader range of user needs.

Multica directly challenges the established giants of agentic AI orchestration, notably Anthropic's Managed Agents and Routines. This open-source project offers a compelling alternative to proprietary, cloud-hosted solutions, positioning itself as a powerful, free command center for your AI workforce. It signifies a pivotal shift, democratizing advanced agent management previously confined to corporate ecosystems or expensive subscriptions.

Opting for Multica means embracing complete sovereignty over your AI operations. Self-hosting on a VPS grants developers and startups unparalleled control over data, infrastructure, and agent behavior, sidestepping vendor lock-in. This approach also translates to significant cost savings, leveraging existing API subscriptions for models like Claude Code without incurring additional platform fees for orchestration.

Conversely, managed platforms like Anthropic's provide a distinct set of advantages. They offer seamless convenience, handling all infrastructure, security, and updates, reducing operational overhead for IT teams. Enterprises often prefer these solutions for their inherent security-by-default, compliance assurances, and out-of-the-box integrations, such as mobile notifications or Telegram connectors, which self-hosted Multica currently lacks.

The decision between Multica and a managed service isn't about superiority; it's about alignment with specific needs. A developer or lean startup prioritizing deep customization, data control, and minimal expenditure will find Multica an invaluable tool. For larger organizations demanding enterprise-grade support, guaranteed uptime, and hassle-free deployment, a managed solution presents a more practical, albeit costlier, path.

Regardless of the chosen path, the rise of sophisticated orchestrators like Multica fundamentally changes how teams interact with AI. These platforms transform powerful but isolated agents into collaborative teammates, making advanced agentic AI accessible to a broader audience. Whether you build your army on open-source foundations or leverage a managed service, the era of the AI coder army has definitively arrived.

What is Multica?

Multica is an open-source platform that acts as a project management layer for AI coding agents. It allows you to create custom agents, assign them tasks on a Kanban board, and automate recurring workflows, turning individual agents into a collaborative team.

Do I need a Claude subscription to use Multica with Claude Code?

Yes. Multica is the orchestration and management tool; it does not replace the AI model itself. You still need an active Claude subscription or Anthropic account to use the underlying Claude Code agent.

Is self-hosting Multica difficult for beginners?

Self-hosting Multica requires some technical expertise, specifically with Docker, command-line interfaces, and managing a Virtual Private Server (VPS). While the video highlights some setup steps, it is best suited for developers comfortable with these technologies.

What is the main benefit of Multica over a managed service like Claude Managed Agents?

The primary benefits are cost-effectiveness, data sovereignty, and vendor neutrality. By self-hosting, you control your data, avoid potentially expensive managed service fees, and can integrate agents from various providers, not just Anthropic.