Nebula vs Paperclip: Channels or Shared Task Ownership?
Compare Nebula and Paperclip on human task ownership, recurring work, approval settings and the cost of running agents.
Founder, Task Machine
Nebula and Paperclip put a different question in front of a small team: should work live in a shared conversation, or in a task that a person can execute? Nebula builds around channels and live calls with agents. Paperclip documents tasks assigned to either people or agents.
That distinction matters when an agent drafts a change and a developer takes over the remaining work. A channel keeps the discussion close to execution. A shared task makes the handoff itself part of the ownership model, so begin with the jobs your team actually passes between people and agents.
Nebula keeps the agent team in the conversation
Nebula's channel documentation describes giving a channel a purpose and coordinating agents around it. In Autonomous channels, its orchestrator can check progress, begin the next work and follow up on a commitment. People can also discuss the work on live calls, where the orchestrator can answer and delegate.
Its task guide puts progress, tool calls, approval cards and results in an agent task's thread. A plan card can ask for approval before execution, followed by a running to-do list. The same guide describes people requesting and steering work, but does not describe people executing those same task records as owners.
For a team already coordinating through channels, the attraction is continuity. The request, the agent's actions and your correction can stay together. Test a job that ends with a human implementation step, though, because steering an agent's thread and owning its unfinished work are different requirements.
Paperclip gives people and agents assigned work
Paperclip's public product reference describes tasks that hold plans, conversations, blockers, files and run history, with either a person or an agent assigned. A CEO agent can create and assign issues, while manager agents delegate to their reports. This fits teams that want the work allocation to remain visible outside a conversation.
Its self-hosted software is MIT-licensed, according to the homepage. You arrange the hosting and AI access. The homepage offers a waitlist, while its documentation describes Paperclip Cloud organizations, so general hosted availability is not established by the checked pages.
Paperclip also documents goals with targets, linked projects and sub-goals. Its goal documentation does not describe linked metric values and trends automatically prompting a goal lead's review. A measurable target in a task system should not be mistaken for an agent continuously reviewing the changing number.
Repeating the job and reviewing its result
Both products publish recurring execution. Nebula supports schedules, channel events, connected-app events and webhooks, and keeps a scheduled task's runs together with pause, resume and run-now controls. Paperclip's routines guide describes scheduled or signed-webhook task creation, alongside agents waking on heartbeats.
The history differs. Nebula explicitly groups the runs of a scheduled task. Paperclip's checked documentation does not describe a stable root task with separate occurrence histories. For a weekly repository report, inspect how you would find a failed occurrence without confusing it with the standing job.
Review also takes different forms. Nebula saves repeatable procedures and checks as Skills, and scheduled tasks expose editable steps. Paperclip's execution policies define ordered review and approval stages, where human or agent reviewers can request changes. Those policies describe review stages, not a general branching process.
For correctness, Nebula documents linked pull-request check results and review by another coding agent. Its public docs do not describe equivalent defined-criteria checks for non-code deliverables. Paperclip's execution policies send work back for changes, while its bundled QA guidance describes acceptance criteria and a manual validation plan, without establishing automatic checks on every requirement.
Decide where permission is enforced
Nebula's notification and safety settings include risky-write approval, allowed-tool exemptions and device-action permissions. Approval cards appear in task threads, and its Inbox raises waiting threads. The write gate starts off, so review that setting before an unattended run.
Paperclip puts approvals, questions and agent proposals in Decisions. Its connector permissions offer Allowed, Ask first or Off per connection. That is a connection-level boundary, while Nebula combines a risky-write gate with tool exemptions and device permissions.
Choose a concrete action for the evaluation, such as changing a connected service's record. Write down whether you need permission to depend on the connection, the tool or the executing agent. The presence of an approval queue alone does not tell you which of those boundaries you can configure.
Separate subscriptions from execution costs
Nebula's pricing page lists $25 per person per month for messaging, calls, orchestration and research. Native-agent tasks, tools and cloud-device hours consume additional Nebula Credits, and the subscription adds no monthly credits. Connected coding agents can use an existing coding subscription or provider API key, without Nebula billing their tokens, but that does not cover native models.
Paperclip's self-hosted software uses the MIT license, and you arrange AI access. Its checked Cloud pages do not publish a price. Compare these as different responsibilities: a workspace subscription plus separately metered execution on one side, and software you operate with separately arranged services on the other.
Nebula and Paperclip, point by point
The table shows each product's answers to the same questions. Each answer includes its source and check date, so you can distinguish a documented capability from a limit of the published material.
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 | Nebula | Paperclip |
|---|---|---|
| Goals |
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. |
Paperclip
Partly
Goals can contain measurable targets, link to projects and have sub-goals. The docs do not describe linked metric values and trends that automatically trigger a goal lead's review. |
| Leads |
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. |
Paperclip
Yes
A CEO agent creates and assigns issues, while manager agents delegate to their reports. The docs do not describe distinct goal and project leads that review outcomes and propose gaps for approval. |
| Tasks |
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. |
Paperclip
Yes
Tasks can be assigned to an agent or a person, and their threads keep conversations, plans, blockers, files and run history. |
| Recurring work |
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. |
Paperclip
Yes
Agents wake on heartbeats, and routines create tasks on schedules or from signed webhooks. The docs do not describe a stable root task with separate occurrence histories. |
| Workflows |
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. |
Paperclip
Yes
Execution policies provide ordered review and approval stages with human or agent participants, and reviewers can request changes. These are review stages rather than general branching workflow steps. |
| Autonomy |
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. |
Paperclip
Yes
The Decisions queue contains approvals, questions and agent proposals. Connector actions can be Allowed, Ask first or Off per connection, rather than a per-agent rule for every action. |
| Learned autonomy |
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. |
Paperclip
Partly
People can capture decision examples with notes and export them for a training pipeline. The docs do not describe automatic proposals to change an agent's autonomy based on approval history. |
| 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. |
Paperclip
Partly
Experimental memory connectors let agents save and retrieve context through providers including Mem0 and Zep. Paperclip has no separate memory page or automatic background memory sync, and the checked docs do not establish that users can inspect or correct the saved memories. |
| Planning |
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. |
Paperclip
Yes
Experimental Agent Chat can research and draft a plan with you, then create tasks with the agreed plan and what done looks like. Plan mode gives you a plan to review before implementation. |
| Intake |
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. |
Paperclip
Yes
A routine webhook can create a task and assign it to an agent, and a CEO agent can create and assign issues. The docs do not describe the same project-token intake with an optional proposal first. |
| 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. |
Paperclip
Yes
Paperclip lists service connectors and supports custom MCP servers. Routines can also start work through webhooks. |
| Models |
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. |
Paperclip
Partly
You choose models and runtimes per agent. Experimental pools route accounts for new tasks and pin later runs, rather than automatically choosing a model for each work stage. |
| Cloud or your own computer |
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. |
Paperclip
Partly
Paperclip supports local and self-hosted deployments, and its docs describe Paperclip Cloud organizations. Its homepage offers a waitlist. General hosted availability is not established. |
| Your own subscription |
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. |
Paperclip
Yes
Paperclip lets agents use your Claude or ChatGPT subscription, or an Anthropic or OpenAI API key. Connect the provider during agent setup and select the model on the agent. |
| Pricing |
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. |
Paperclip
Partly
Paperclip's self-hosted software is open source under the MIT license. You arrange AI access. Its homepage offers a waitlist, and the checked Cloud documentation does not publish a price. |
| Correctness |
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. |
Paperclip
Yes
Execution policies route work through review and approval stages, with change requests returned to the executor. A bundled QA skill describes acceptance criteria and a manual validation plan rather than automatic checks on every task requirement. |
For software work
| What you compare | Nebula | Paperclip |
|---|---|---|
| Code review 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. |
Paperclip
Yes
An experimental GitHub review bot accepts your own code-review guidance for pull requests. Its docs do not describe discovering repository rules and screening suggested rules against examples. |
| Adversarial review |
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. |
Paperclip
Yes
Execution policies can route an issue to an independent reviewer, and low-trust review can contain work on external pull requests. The docs do not describe two independent adversarial reviewers automatically examining high-risk changes together. |
| Risk rating |
Nebula
Not published
Its docs describe pull-request status and check results, but do not describe rating a code change's risk before merge. |
Paperclip
Partly
A bundled GitHub pull request skill instructs an agent to include risk and rollback information in the pull request. It does not describe a revision-specific Low, Moderate or High merge-risk rating. |
| Pull requests |
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. |
Paperclip
Yes
Agents can create pull requests and push fixes after review. Experimental review bots publish a check on the reviewed commit, which GitHub repository rules can require before merging. |
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. Nebula and Paperclip are named only to identify them, and there is no relationship between the companies. Has something changed? Tell us.
Who each one suits
Pick Nebula if your developers want agents present in shared channels and calls, with scheduled runs kept in their task threads. Its public task documentation does not describe human executors owning those same work items, so check your human handoff requirements first.
Pick Paperclip if a person and an agent need to exchange ownership of assigned tasks, and you want self-hosted software. You take responsibility for operating that installation, and the published waitlist does not establish generally available hosted service.
Where Task Machine fits
Task Machine makes a person or agent the owner of a Task and retains its decisions and runs. Its Workflow documentation describes branches, questions, approvals and verifier checks that return weak work with feedback. That answers the ownership and review question differently when your repeated job needs both human execution and explicit checks on non-code results.
Task Machine is the wrong pick when shared live calls are the deciding requirement or you specifically want to host Paperclip's MIT-licensed system. The Task Machine vs Nebula and Task Machine vs Paperclip pages cover the third option. Take one recurring job with a human handoff and use those comparisons to trace its owner, approval boundary and failed-result path before choosing.