Multica is a task board that assigns work to coding agents and collects their progress, blockers, and results. The agents run the tasks on the machines you connect, so you can leave AI agents running 24/7 on a VPS while your laptop is off. With several running at once, you centralize tracking in one place and stop copying context between terminals. (github.com)

Source: Multica — Project Management for Human + Agent Teams
The deployment in the video brings the dashboard and agent execution together on a server. The goal is to have projects, tasks, and reviews accessible from the browser, without burning through the battery or memory of the machine you carry around.
What Multica does with your coding agents
Multica works like a project manager where agents execute the tasks. You create a task, assign it to an agent, and check what it’s doing. The agent can report a blocker, leave comments, and hand in the result for review; the interface looks like Jira or Linear. (github.com)
The unit of work is the task. Its description captures what you want to achieve, and its comments hold the conversation about that deliverable. That helps you tell apart what’s pending, what’s still in progress, and what needs a decision from you.
Multica uses the coding tools you already have installed, like Claude Code, Codex, or OpenCode. Each keeps its own access requirements and its relationship with the model provider; Multica adds the coordination and the shared view of the work. You can browse the project in its official GitHub repository. (multica.ai)
If you’re moving from a conversation with one agent to spreading work across several, the article on how to build a team with MiniMax Code goes deeper into that decision. In Multica, that organization shows up in projects, owners, and task statuses.
How the server and the daemon split the work
Multica separates two pieces: the server stores tasks, comments, agent configuration, and history, and the daemon runs the work on the connected machine. Its architecture includes a Go backend, PostgreSQL, and a Next.js web interface. (github.com)

Source: Daemon and runtimes
The daemon is the process that works alongside the code. It runs on the connected machine, detects the available AI tools, and tells the server what it can execute. A “runtime” represents that execution environment: a machine with a specific coding tool. (multica.ai)
A task’s journey in the video follows this sequence:
- You assign an issue to an agent.
- The server creates an execution, or “run”, and puts it in a queue.
- The daemon gets a notification over WebSocket and claims the work.
- It prepares the working directory and launches the coding tool.
- Commands, errors, and results show up in the task.
- The result becomes available for review.
The separation explains a failure that can throw you off: seeing the dashboard running doesn’t prove there’s a machine executing tasks. If the daemon is off, the server is still the place where you check the work, but the process that should pick it up is missing.
The workflow shown uses git worktrees to separate the work on a repository. Each agent gets its own directory and can move forward without directly editing the same file tree as another. Afterwards you have to review how the changes fit together: separate directories don’t by themselves resolve incompatible decisions about an API or a data structure.
What changes when you run the agents on a VPS
With agents running on a VPS, closing the lid, switching networks, or taking your laptop with you no longer cuts the work short: the daemon stays active on the server and you open the dashboard from the browser. The execution environment lives outside your machine, and you come back when there’s something to review.
The deployment in the video uses a HostGator VPS with 4 GB of RAM. That’s the demo configuration; as you add simultaneous tasks, you also have to watch memory and the processes the agents spawn. Compiling a project and running tests adds load on top of the assistant’s own work.
Remote access also changes the dashboard configuration. An installation pointing to localhost needs addresses reachable from your browser and from the daemon. The video uses a subdomain, a DNS record pointing to the VPS IP, and Caddy as a reverse proxy to serve access over HTTPS.
There are two distinct places to look for a failure. If the browser can’t reach the dashboard, check the domain, DNS, and proxy. If the dashboard loads but the task doesn’t start, check the runtime and daemon connection before touching the web server.
A VPS brings continuity, but the provider’s sessions and quotas still condition the work. Having the process on all day doesn’t mean you get unlimited generation.
How to connect the runtime without running agents as root
Create a separate user called agente, with no admin permissions, and connect Multica from that account. Launching Claude Code as root fails because the execution tries to use a mode that skips permission prompts and the tool rejects that combination. It’s the most useful error in the video, and it gets fixed by separating the execution account from the admin one.
Careful: presenting the environment as a “sandbox” to get around the rejection leaves the privilege problem untouched. The process that modifies repositories must work with the user set up for that job.
To replicate the video’s setup without dragging the root session along:
-
Create the
agenteuser without adding admin permissions. -
Install the coding tool inside its session and sign in with the provider.
-
Connect Multica from that same user.
-
For the connection on machines without a browser, use the token generated in the settings and the public address of your instance.
-
Select the runtime that shows up as connected when you create the agent.
-
Enable the daemon’s autostart from that account:
multica daemon autostart enable
The video shows another confusion that’s easy to reproduce: the previous root runtime and the new user’s runtime both stay registered. Check which one is online and which one you assigned to the agent before resending a task.
The execution account determines which files and credentials the tool can use. Also review the repository permissions and the accesses you hand to the agent. The API security checklist for agents works for reviewing that part when the job involves external services.
How to split implementation and review
Each deliverable goes in its own task: in the video’s case, a backend that consumes the YouTube API and a dashboard to visualize statistics. They’re related deliverables, but you can check the backend’s output before deciding whether the dashboard is using its data correctly.
For that split to work, describe in the task what each agent must deliver. “Create a dashboard” leaves decisions about technology, data, and presentation open. If you need a specific framework or an existing integration, write it down before launching the run.
The result shown for the dashboard uses plain HTML and CSS. That deliverable fits an open-ended request, but it would fall short if you expected to integrate it directly into an application with a different structure. The review must compare the result against the requirements you set.
You can also separate the role that codes from the one that reviews. The reviewer sends comments back when it finds something that should be corrected, and you decide on the final deliverable. A useful check for you is that each piece of feedback points to a file, a behavior, or an unmet condition; “make it better” adds little context for the next run.
The article on agent orchestration in Go expands on how to organize workflows when you need to control the coordination from code.
When to use Multica and what to check before automating
Multica fits when you maintain several projects, spread tasks across agents, or need to pick work back up without rebuilding it from different terminals. It also offers an Autopilot section to schedule tasks like PR reviews or dependency audits, as shown in the video.
For a one-off change you’re going to supervise in your editor, standing up a server adds pieces you’ll have to maintain. The board pays off more when you need persistent tracking, remote execution, and an explicit split of responsibilities.
Before scheduling recurring work, verify one manual task from start to finish. It must reach the right runtime, show activity, and finish with files you can locate and review. A “review” status means you have a deliverable pending verification.
Create a small task in a test repository and assign it to the agente user’s runtime. Review the changes and run the project’s checks before turning on recurring tasks in Autopilot.



What do you think?
Leave your opinion, question or suggestion. Comments are synced with GitHub Discussions .