Multica vs Nebula: Issues or Shared Channels?
Compare Multica and Nebula on human ownership, recurring work and approvals to decide where your team should coordinate agents.
Founder, Task Machine
Multica and Nebula ask your team to choose where agent work belongs: on an issue owned by a person or agent, or inside a channel where an orchestrator delegates work. For a small software team, that choice determines how a human takes over a job after an agent finishes its part.
Both publish scheduled work and local execution, so the decision needs more precision than whether either can run agents in the background. Start with the handoff you repeat most often, such as an agent researching a customer report before a developer decides what to change. Decide whether the developer should own the same record or steer the agent through its thread.
Multica gives the issue an owner
Multica's issue documentation describes assignments to people, agents or squads, with deliverables, discussion, status and agent runs attached. That gives a team an issue to inspect when the work changes hands. A human can be an executor on that record, not only someone requesting an agent's work.
Projects can have a person or agent as lead, and squad leaders route issues to members. Project workflows then move work through agent or human steps. Multica also documents uses beyond engineering, including content and community work, so an issue-based process need not stop at code.
The limit is the meaning of a completed review. Its issue and workflow documentation describes acceptance criteria and sending rejected work back, but does not establish checks of the delivered result against those criteria. Your team should specify what a reviewer needs to inspect before advancing an issue.
Nebula keeps coordination in the conversation
Nebula's channel documentation starts with a channel purpose and an agent team. Its orchestrator can participate in live calls, delegate jobs and propose specialists. In Autonomous channels, it follows progress, starts subsequent work and follows up when a person's commitment comes due.
An agent task retains its thread, progress, tool calls, approvals and result. That fits a team discussing a customer problem together while agents investigate separate parts. Its public docs describe people requesting and guiding those tasks, but do not describe people owning those same work items as executors.
That distinction matters when a job becomes human work. A developer who wants to keep discussing the investigation in a channel may prefer Nebula's arrangement. A team whose queue depends on named human assignments should examine Multica's issue record first.
Compare repeated jobs by their history
Multica's Autopilot guide describes scheduled and webhook starts. An Autopilot can create an issue for a run or execute without an issue. Issue wakeups also return an agent to existing work, although regular checks require an end date.
Nebula's task guide describes schedules, channel events, connected-app events and webhooks. A scheduled task groups its runs and exposes pause, resume and run-now controls. A team reviewing a recurring investigation can therefore inspect the job's grouped history.
For a weekly report, ask whether each occurrence should enter your issue queue or remain inside the ongoing agent task. Also examine missed starts: Multica documents that Run only Autopilots skip when their runtime is unavailable and do not automatically retry failed runs in that mode. Do not assume that a configured schedule guarantees a report will be waiting.
Locate the approval before enabling unattended work
Multica's workflow documentation supports handing a review step to a person and returning rejected work. Its Inbox documentation describes notifications. Its public documentation does not describe per-agent action approval settings or approval requests collected in that Inbox.
Nebula's notification settings include risky-write approval, allowed-tool exemptions and device-action permissions. Requests appear as cards in task threads, while waiting threads rise in the Inbox. The risky-write gate starts off, and each person enables it separately.
For work that may send a customer message, evaluate the exact stop point. Multica's published mechanism is a human workflow step. Nebula publishes an action gate, with exceptions you need to inspect before leaving a task unattended. Neither description should be reduced to a generic promise that a person is always asked.
Separate model charges from the execution location
Multica's home page offers connected computers, managed cloud sandboxes and self-hosting. It says internal organizational use is free, including self-hosting, while external hosting or embedding needs a commercial license. The home page does not publish a cloud price.
Nebula's pricing page lists $25 per person per month for Workspace messaging, calls, orchestration and research. Native tasks, tools and cloud-device hours consume additional Nebula Credits, and the subscription adds no monthly credits. Its device documentation lists own-computer use without a device charge.
Existing coding subscriptions need a separate check. Nebula's connected coding agents can use your Claude plan or a provider API key without a Nebula token charge, but that does not fund its native models. A local coding agent is private to its owner, and sharing it with teammates requires a shared cloud device.
Multica and Nebula, point by point
The table shows both products' answers to the same questions. Each answer includes its source and check date so you can inspect the scope behind it.
Both columns answer the same questions from each company's public pages. Yes means the company publishes the capability the question asks about, Partly means something narrower, No means it says it does not offer it, and Not published means its public pages do not describe it. Every answer links to its source and shows when we last checked it. The oldest check on this page was November 13, 2026.
| What you compare | Multica | Nebula |
|---|---|---|
| Goals |
Multica
Partly
Projects have a shared goal and a member or agent lead. The documentation does not describe linked outcome metrics monitored by that lead. |
Nebula
Partly
You give a channel a purpose, and Nebula delegates work and checks in toward it. Its docs do not describe tracking a measurable target against that goal. |
| Leads |
Multica
Yes
Project leads can be people or agents, and squad leaders route issues to members. The documentation does not describe goal leads that monitor outcomes or project leads that independently review goal conflicts. |
Nebula
Yes
Nebula coordinates each channel's agent team, delegates tasks and proposes specialists. In Autonomous channels it checks progress, starts the next work and follows up when someone's commitment comes due. |
| Tasks |
Multica
Yes
Assign an issue to a person, agent or squad. Its discussion, deliverables, status and multiple agent runs remain on the issue. |
Nebula
Partly
An agent's task keeps its thread, progress, tool calls, approvals and results together. Its docs describe people requesting and steering tasks, not people owning the same work items as executors. |
| Recurring work |
Multica
Yes
Autopilots start from schedules or webhooks, creating an issue each time or running without one. Recurring wakeups also return an agent to an existing issue, but regular checks require an end date. |
Nebula
Yes
Tasks run on schedules or from channel events, connected-app events and webhooks. A scheduled task keeps its runs together, with pause, resume and run-now controls. |
| Workflows |
Multica
Yes
Project workflows hand steps to agents or people, with a next step and a send-back step for rejected work. They do not document general conditional branches or per-requirement verifier checks. |
Nebula
Yes
Skills save reusable procedures with the same steps and checks for each use. Scheduled tasks also keep an editable prompt and steps for their repeated runs. |
| Autonomy |
Multica
Partly
An Inbox collects notifications and workflows can hand a review step to a person. The documentation does not describe configuring which agent actions require approval or collecting approval requests in the Inbox. |
Nebula
Yes
You can enable risky-write approval, exempt allowed tools and manage device-action permissions. Approval cards appear in task threads, and the Inbox holds waiting threads at the top. The write gate starts off. |
| Learned autonomy |
Multica
Not published
Multica documents agent access and workflow handoffs. Its documentation does not describe proposing changes to an agent's autonomy based on approval history. |
Nebula
Not published
Its docs describe manual safety-gate settings and allowed-action lists, but do not describe proposals to change an agent's permissions based on your approval history. |
| Memory |
Multica
Partly
Multica retains Hermes memory per agent and can optionally enable Codex native memory. Its documentation does not describe whether users can inspect or correct that memory. |
Nebula
Yes
Native agents retain learned memory under Brain, where you can read it and delete a wrong memory immediately. Connected coding agents instead keep their runtime's own memory. |
| Planning |
Multica
Yes
Chat agents can create issues when asked, and issues can contain acceptance criteria. The documentation does not describe a required plan and acceptance-criteria review before an agent starts. |
Nebula
Yes
You can discuss a channel's goal in chat or on a call and ask for a draft plan. Tasks can show a plan card for approval before work starts and a to-do list while they run. |
| Intake |
Multica
Yes
A webhook can trigger an autopilot that creates an issue, and a squad leader can route an assigned issue to members. The documentation does not describe a project-token intake that places a proposal in the Inbox first. |
Nebula
Yes
A webhook URL starts a run whenever an outside service calls it. Triggered jobs have a channel and an agent to run as, so incoming events reach configured agent work. |
| Connectors |
Multica
Yes
Agents can use individual or shared MCP servers, and autopilots accept webhook triggers. The documentation does not describe the same catalog of API, command-line and MCP connectors. |
Nebula
Yes
Connections support app accounts, API-based external agents and remote Model Context Protocol servers. Connected-app events and webhook URLs can start tasks, and custom tools can be added beyond the catalog. |
| Models |
Multica
Partly
You can select a model and thinking level for supported agent runtimes. The documentation does not describe automatic model selection for each work stage based on price and budget. |
Nebula
Partly
Tasks use a model pinned to the agent, chosen for the channel or inherited from the workspace. These are saved settings. Its docs do not describe automatically choosing a model to fit each task or step. |
| Cloud or your own computer |
Multica
Yes
Connect a laptop or server to run installed coding agents, or use Multica's managed cloud sandboxes. You can also self-host the Multica service. |
Nebula
Yes
Agents can work on a cloud device or your own computer, with a channel default and agent-specific device choices. Cloud-device time uses Nebula Credits, while your own computer has no device charge. |
| Your own subscription |
Multica
Yes
Multica invokes installed AI coding tools such as Claude Code, Codex and GitHub Copilot CLI using your local sign-in or model-provider setup. Available models depend on the tool, local configuration, signed-in account and subscription entitlements. |
Nebula
Partly
Connected coding agents use your Claude or ChatGPT plan, or a provider API key, without Nebula billing their tokens. That sign-in does not cover Nebula's own models, whose native tasks use credits. |
| Pricing |
Multica
Partly
Multica says internal organizational use, including self-hosting, is free, and external hosting or embedding requires a commercial license. It does not publish a cloud price on its home page. |
Nebula
Yes
Nebula Workspace costs $25 per person per month for messaging, calls, orchestration and research. Native-agent tasks, tools and cloud-device hours use additional Nebula Credits. The subscription adds no monthly credits. |
| Correctness |
Multica
Partly
Issues can contain acceptance criteria, and a workflow can send rejected work back from a review step. The documentation does not establish that results are checked against defined criteria. |
Nebula
Partly
Coding tasks show whether linked pull-request checks passed or failed, and a second coding agent can review a change. Its docs do not describe comparable checks against defined criteria for non-code results. |
For software work
| What you compare | Multica | Nebula |
|---|---|---|
| Code review rules |
Multica
Partly
You can assign an agent a review skill or instructions and set a workflow review step. The documentation does not establish that code is reviewed against rules. |
Nebula
Partly
You can ask one coding agent to review another's change, and coding agents follow their runtime's instructions. Its docs do not establish a code-review system that checks changes against configured repository rules. |
| Adversarial review |
Multica
Partly
A workflow can send work to a review agent and return rejected work for changes. Its documentation does not establish an independent second review of risky changes. |
Nebula
Yes
A published guide pairs a writer with a second coding agent that reviews the change and reports to a person. You arrange the hand-off or tag the reviewer yourself, and can steer each round. |
| Risk rating |
Multica
Partly
Linked pull requests show checks and merge conflicts. The documentation does not describe rating the exact revision's merge risk. |
Nebula
Not published
Its docs describe pull-request status and check results, but do not describe rating a code change's risk before merge. |
| Pull requests |
Multica
Partly
Agents can open pull requests, and linked issues show their state, checks and conflicts. The documentation does not establish that agents work on pull requests with review feedback. |
Nebula
Yes
Coding agents can open pull requests, take a reviewer's feedback in the task thread and revise the change. Task cards show the pull request's status and checks. The review guide leaves merging with the person. |
A fact we cannot find or cannot check is left out, and prices can change after the date shown. Task Machine publishes this comparison and is an interested party. Multica and Nebula are named only to identify them, and there is no relationship between the companies. Has something changed? Tell us.
Who each one suits
Pick Multica if your team wants human and agent assignments on an issue, with project handoffs and self-hosting available. Its published review steps do not establish automatic checks against every acceptance criterion.
Pick Nebula if shared channels, live calls and an orchestrator fit how your team coordinates work. Its agent-task documentation does not describe people executing as owners of the same work items, and local coding agents stay private.
Where Task Machine fits
Task Machine answers the ownership question with Tasks owned by people or agents and the review question with acceptance checks before human review. Its Workflow documentation also describes branches, human approvals and verifier checks that return failed work with feedback. Those features suit a report that needs both an agent's draft and a person's decision on the same job.
Task Machine is the wrong pick if you require live calls with an agent listening, because its docs do not describe live team calls with an agent listening. See Switch from Nebula to Task Machine. The Multica comparison and Nebula comparison explain the corresponding ownership and review boundaries. Use one real human-agent handoff to check those two pages against your team's required owner and approval point.