Paperclip vs. Multica, Revisited Seven Months Later

In my last post I designed a screen for watching AI agents work. Earlier, back in March 2026, I left myself a note. Instead of growing my own execution engine, I'd hand execution and orchestration to Paperclip and focus on writing documents in Obsidian.

Seven months later, both Paperclip and Multica, which aims at a similar spot, have changed a lot. Both ship releases almost every week. So I went back to the criteria from that note and compared the two tools from scratch.

All numbers and features in this post are as of October 20, 2026. Both projects move fast, so check the latest changelogs in the links below before you adopt either one.

The Roles From My March Note#

The note split the system into three roles. I used the same three as the yardstick for this comparison.

1. Planning and docs — Write goals, tasks, and PRDs in Markdown in Obsidian. Focus only on "what to build, and why."
2. Execution and orchestration — Push the written tasks into a work queue and delegate agent assignment, state transitions, context injection, and budget management.
3. Visualization — Pull agent states (idle, running, blocked) and show them as pixel-art characters.

Back then, Paperclip went into slot 2. The question for this post is what changes if Multica goes into that slot instead.

Each Tool in One Sentence#

Paperclip is a tool for running a whole company with AI agents. You create a company, set its goal, and hire a CEO agent. The CEO proposes a strategy and a human approves it. Org charts, reporting lines, budgets, and approvals are all built in.

Multica is a workspace where humans and agents work as one team. You assign an issue to an agent the way you'd assign it to a teammate, and the agent posts progress as comments and comes back with results. It looks a lot like an issue tracker such as Linear, with agents joining as team members.

If you leave DATABASE_URL empty, Paperclip starts right away on embedded PostgreSQL. For solo use, start in local_trusted mode, which needs no login. For Multica, bring up the full stack with Docker Compose or Helm, or use the managed Cloud. Paperclip Cloud is still at the waitlist stage.

They Start Work Differently#

The biggest difference between the two is when an agent wakes up. That one choice shapes cost, predictability, and how the tool feels to use.

Paperclip: Agents Wake on Heartbeats#

Paperclip agents work in cycles called heartbeats. An agent wakes on a schedule or on an event like a ticket assignment, runs one cycle, and goes back to rest. Each cycle leaves run records, usage, and session state behind, so it's easy to trace later.

The five-minute getting-started guide follows the same flow. Create a company and hire a CEO, and the first heartbeat fires. The CEO submits a strategy for approval. Only after a human approves do the first tasks appear on the board.

Multica: Only Explicit Triggers#

Multica's docs state plainly that agents do not start work on their own. A run starts only from one of these four:

1. Issue assignment — Assign an issue to an agent
2. @-mention — Call an agent in a comment
3. Chat — Talk to an agent directly
4. Autopilot — Run recurring work on a schedule or from a webhook

That said, "Multica has nothing like heartbeats" is no longer true. v0.5.1 (Sep 21) added wakeup rules that wake an issue's agent again when a comment arrives or on a schedule. v0.6.0 (Sep 28) went further with conditional wakeups that react to status changes, finished sub-issues, and pull request changes.

Paperclip's own comparison page (paperclip.ing/vs/multica) says Multica has no heartbeat execution. Since it's written by a vendor, it may not reflect recent changes like these. Read it alongside the original docs.

@-Mentions Mean Opposite Things#

Here's a fun difference. In v2026.1005.0, Paperclip changed things so that @-mentions no longer start runs. A mention now only adds context for the assignee. To bring in another agent, you assign the task or request a review.

In Multica, it's the reverse: @-mentions are the main way to hand off work. When you assign an issue to a squad, a group of agents, only the leader agent wakes up. The leader reads the context and @-mentions the right member in a comment to pass on the next step.

Paperclip Has Much Tighter Cost and Control#

Once you run several agents, cost is the first thing you worry about. This is where the two tools differ most clearly.

Paperclip: Budget Caps and Approvals by Default#

Paperclip lets you set budgets per company, agent, and project. You get an alert when spend crosses a warning threshold, and the agent is paused automatically when it hits the cap. The dashboard shows this month's spend and the number of budget incidents at a glance.

Decisions like strategy approval and hiring agents go through an approval queue. Every change lands in an audit log, so you can trace what happened and why.

One thing to know: since v2026.1001.0, the default execution mode is full-auto. Claude defaults to approve-all, and Codex defaults to bypassing approvals and the sandbox. Paperclip's own approval process stays in place, but if you need tool-level approval gates, you have to set a restrictive mode on each agent yourself.

Multica: Costs Are Visible, but There's No Cap#

Multica keeps improving cost visibility too. The execution log shows a cost bar for each run with tokens, time, and model (v0.6.3), and the issue sidebar shows a cumulative cost curve (v0.6.1). The Analytics page breaks out spend and error trends separately.

But within what I checked in the official docs and changelog, I couldn't find budget caps or spend-based automatic pausing. Multica can show you costs, but only Paperclip can stop them for now.

How Agents Get Connected#

Multica: Use the CLIs on Your Own Machine#

In Multica, the server records and coordinates the work, and a daemon on a connected computer claims each run and launches a local AI coding tool. Your code, files, and each tool's credentials stay on your machine. One caveat: anything you put in an agent's custom_env is stored on the server, so keep secrets out of it.

It supports a whopping 26 tools, including Claude Code, Codex, Cursor Agent, GitHub Copilot CLI, OpenCode, Grok, Hermes, Kimi CLI, and Qwen Code. Most of them support session resumption and skill injection.

Comparison posts from April 2026 said Multica supports 8 runtimes. The official docs now list 26, so read older comparisons with a grain of salt.

Paperclip: Broad Reach via Adapters and Connectors#

Paperclip connects agent runtimes through adapters. Claude Code (claude_local), Codex (codex_local), Gemini CLI, Cursor, OpenCode, Pi, Hermes, Grok, and Kimi Code come built in. There's also a process adapter that wraps shell commands and an http adapter that calls your own service via webhook, so you can "hire" things that aren't coding agents at all.

On top of that, Paperclip has a native runner that manages its own run lifecycle, and it supports sandboxed execution on providers like Daytona. You can also attach connectors such as Slack, GitHub, Railway, and Browser Use Cloud with per-action permissions. If you want to delegate work beyond coding, Paperclip gives you more options.

Where the Recent Releases Point#

Read through the changelogs and you can see where each project is heading.

Paperclip Is Shedding Weight#

A common criticism of Paperclip was that "the governance model is complicated." Recent releases respond to exactly that.

• Much shorter default instructions — In v2026.1012.0, the default CEO instructions dropped from about 1,900 words to 20. The bundled planning skills shrank to around 400 words.
• Chat-first UI — Agent Chat moved to the top of the navigation. There's also an experimental setting that folds the Inbox into the task list.
• External agent connections (experimental) — MCP clients like Claude Code and Codex can connect to Paperclip as the signed-in user, create tasks, and receive signed event webhooks.
• Skill management — Import and sync skill folders from a GitHub repository, and let agents update company skills directly.

The trade-off is a heavy upgrade burden. Seven of the last ten releases are marked as breaking changes. Get in the habit of reading the migration notes before every upgrade.

Multica Is Being Polished as a Team Collaboration Tool#

Multica's recent releases focus on refining the collaboration experience rather than big structural changes.

• Smarter wakeups — Agents react to comments, schedules, status changes, and pull request changes
• Cost visibility — See per-run and per-issue costs at a glance
• Collaboration niceties — Sortable and filterable Markdown tables, Cmd/Ctrl+K workspace switching, and comment permalinks
• More integrations — Connect Slack, Telegram, Lark, and DingTalk channels, plus GitHub, GitLab, Gitea, and Forgejo repositories

Always Read the License Itself#

Paperclip uses the plain MIT license. You can take it, modify it, and even sell it as a service.

For Multica, GitHub shows the license as NOASSERTION, and some comparison sites say "its license terms aren't publicly specified." But open the LICENSE file in the repository and it clearly says this is the Multica License: Apache 2.0 with additional conditions.

1. Internal use is free — Even across multiple workspaces, you don't need a commercial license
2. Hosting for others is restricted — Offering Multica as a service to third parties requires a commercial license, even if it's free
3. UI branding must stay — If you use the Multica UI, you can't remove or change the logo, product name, or copyright notices

Using it on your own or within your team is fine. But if you plan to build a service on top of Multica, these conditions could be the deciding factor.

Plugging Both Back Into the March Roles#

Here's how the two tools map onto the three roles from the start.

The visualization row is where they differ most. Paperclip now pushes events through webhooks, though the feature is still experimental. Within what I checked in Multica's official docs and changelog, there are no outbound event webhooks. Multica's webhooks are inbound triggers that start autopilots.

So if you want to hook up a pixel-art dashboard, the realistic approach with Multica is a bridge that reads state periodically with --output json.

# Multica: fetch the issue list as JSON and process it in the dashboard bridge
multica issue list --output json

Which One Should You Pick?#

There's no single right answer, but splitting it like this makes the choice easier.

Paperclip fits when

• You want multiple agents with roles and reporting lines designed in
• Budget caps and automatic pausing are a must
• You want to delegate work beyond coding, like Slack, deployments, or browser tasks
• You want the freedom of the MIT license to modify it and build services on it

Multica fits when

• Human teammates and agents need to work together on the same issue board
• You want to run the coding CLIs you already use, on your own machine
• You want to check on work from anywhere via desktop and mobile apps or chat channels
• You prefer a tool that ships frequent small improvements over big structural changes

The core of my March note was "delegate execution, and focus on the docs." That principle holds no matter which tool you pick. Start by deciding whether you want the feel of running a company or of bringing teammates onto a team. Once you have that answer, the tool choice follows naturally.

For the record, I'm using Multica right now.

References#

• Paperclip Changelog
• Paperclip v2026.1012.0 release notes
• Paperclip v2026.1005.0 release notes
• Paperclip v2026.1001.0 release notes
• Paperclip docs
• Paperclip five-minute path
• Paperclip adapters overview
• Paperclip deployment overview
• Paperclip GitHub
• Paperclip vs Multica (Paperclip's official comparison page)
• Multica Changelog
• Multica docs
• How Multica works
• Multica supported AI coding tools
• Multica squads
• Multica autopilots
• Multica CLI
• Multica GitHub
• Multica vs Paperclip vs Claude Managed Agents (Flowtivity, April 2026)
• Multica vs Paperclip (OpenAlternative)

I have done my best: that is about all the philosophy of living one needs.

— Lin-yutang