Bops vs Paperclip: Action Approvals or Review Stages?
Compare Bops and Paperclip on action permissions, task review and hosting to choose where your team should put human control.
Founder, Task Machine
Bops and Paperclip separate the decision to permit an action from the decision to accept completed work. Bops documents per-bot approval cards, while Paperclip documents ordered review and approval stages with people or agents participating.
For a small team, the choice depends on where work needs to stop. An operator may need to approve a bot sending an email, while a developer may need a reviewer to return a finished change for revision before it moves forward.
Bops gives an operator a bot team
Bops' README describes a main bot, Boppy by default, that delegates to specialists. The specialists keep threads and report back in chat. You can direct the team from a Mac app or email the main bot a task.
Its bots can operate on Orgo cloud computers or your Mac, and Full access on the Mac includes a shell. This fits work where the operator wants assistants using tools and accounts directly, with a computer they can observe or take over. The product also supports self-hosting with your own provider keys.
The shared work record is a limitation of what is published. Bops' docs describe bot delegation and threads, but do not describe assigning those same task records to people. If a colleague needs to become the owner, verify how you would preserve the context and track that handoff.
Paperclip organizes agents and their work
Paperclip's public product documentation describes tasks assignable to agents or people, with threads for conversations, plans, blockers, files and run history. Its organization model also includes goals, roles, reporting lines and budgets. A CEO agent can create and assign issues, while manager agents delegate to their reports.
That makes it relevant when you need more than one operator directing bots in chat. A person can own a task, and task review can become part of the process. Paperclip also starts recurring work through routines and agent heartbeats.
Running the service is a separate choice from arranging the work. Paperclip supports local and self-hosted deployments. Its homepage offers a Cloud waitlist, so its published Cloud documentation should not be read as proof that general hosted access is available.
Control an action or return a deliverable
Bops' cloud-runner documentation gives each bot action rules and approval requests in Needs your attention and chat. Allow once permits an individual request, Always allow saves a bot-and-action rule, and Deny rejects it. The standing rule applies regardless of recipient or content, which matters for actions such as sending email.
Paperclip's action permissions apply per connection, with Allowed, Ask first and Off settings. Its Decisions queue holds approvals, questions and agent proposals. That permission scope differs from Bops' bot-and-action rules, so inspect which agents share the connection you are configuring.
For completed work, Paperclip's execution policies define ordered stages for human or agent review and approval. Reviewers can ask for changes that return to the executor. These are review stages, not general branching workflow steps.
Bops documents work email checks for business-data lookups and Preview for human testing of app changes. Its public docs do not describe requirement checks or scoring criteria for completed tasks. If you need a review stage to return a draft for correction, do not assume an action approval card provides that process.
Paperclip's bundled quality guidance includes acceptance criteria and a manual validation plan. Its policies do not establish automatic checks on every task requirement. Ask separately who reviews the artifact, what evidence they inspect and how a failed check returns to the executor.
Compare planning and code review with rollout limits intact
Bops supports discussing work with bots and delegating it to specialists. Its public docs do not describe converting the conversation into a task plan or reviewing steps before execution. Its release notes describe saving code changes to GitHub and publishing apps from Preview, without describing pull-request feedback handling.
Paperclip's Agent Chat can research and draft a plan, then create tasks with the agreed plan and what done looks like. That feature is experimental. Plan mode also gives you a plan to inspect before implementation.
For code, Paperclip describes agents creating pull requests and pushing fixes after review. Its GitHub review bots are experimental and can publish a check on the reviewed commit. Repository rules can require that check before merge, but experimental availability should remain part of your evaluation.
Bops' public docs do not describe an independent second review of risky customer changes. Paperclip execution policies can route work to an independent reviewer. If independent review is a condition for shipping, check the actual policy and reviewer assignment instead of counting any approval as a code review.
Deployment changes what you must maintain
Bops can run eligible cloud task routines while the Mac is closed, but some work remains on the Mac. Its homepage and README also disagree on billing. The homepage lists $0/month, computers from $0.055/hour, AI at Orgo's rate and phone numbers at $3/month, while the README lists Free, Pro at $20/month and Max at $200/month.
Paperclip's homepage describes self-hosted software under the MIT license. You arrange hosting and AI access, and its checked Cloud documentation does not publish a price. Self-hosting also means planning updates and recovery, not only installing the service once.
Bops and Paperclip, point by point
The table presents both products against the same questions, with a source and check date for each answer. Similar labels can cover different permission scopes or review mechanisms.
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 | Bops | Paperclip |
|---|---|---|
| Goals |
Bops
Not published
Its public docs do not describe an owned goal with a measurable target and progress reviews. Watching an inbox or dashboard is documented, but not tracking a goal against a metric. |
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 |
Bops
Yes
The main bot, Boppy by default, runs the workspace's team and hands work to specialists. Bots keep threads and report back in chat. |
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 |
Bops
Partly
Bots hand work to specialists, keep threads and report back in chat. Its docs do not describe assigning the same task records to people. |
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 |
Bops
Yes
Routines and reminders run on schedules, and you can email the main bot a task. Cloud mode can run eligible task routines on the bot's computer while your Mac is closed. |
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 |
Bops
Partly
Routines repeat scheduled jobs, and bots save skills as drafts for you to publish. Its docs do not describe a configurable process with fixed steps and branches. |
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 |
Bops
Yes
Per-bot rules decide which actions pause for approval, with requests shown in Needs your attention and chat. Cards offer Allow once, Always allow or Deny, and Always allow saves a rule for that bot and action. |
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 |
Bops
Not published
Its docs do not describe proposing permission changes from your approval history. Always allow is a rule you explicitly save for a bot and action, not a recommendation inferred from past approvals. |
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 |
Bops
Partly
Bots remember what you tell them per workspace across channels, using Honcho for long-term memory. Its docs do not explain how you inspect or correct those memories. |
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 |
Bops
Partly
You discuss work with bots in chat, and the main bot delegates to specialists. Its docs do not describe turning that conversation into a task plan or reviewed steps before execution. |
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 |
Bops
Yes
Email a task to the main bot and receive its answer by email. The main bot can hand work to specialists in its workspace. |
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 |
Bops
Yes
Bops documents about 1,400 connected apps, API calls through saved keys, and signed webhooks for Slack, texts and calls. Self-hosting supports a public relay and your own Slack app. |
Paperclip
Yes
Paperclip lists service connectors and supports custom MCP servers. Routines can also start work through webhooks. |
| Models |
Bops
Partly
Self-hosted configuration exposes separate chat, session and hard model settings. Its public setup instructions do not explain automatic model selection per 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 |
Bops
Yes
Bots can work on Orgo cloud computers or your Mac, where Full access also grants a shell. Bops supports its hosted provider service and self-hosting with your own keys. |
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 |
Bops
Yes
In self-hosted mode Bops calls providers directly with your keys, and Bops plans do not apply. The README says Mac tasks never use your ChatGPT account. |
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 |
Bops
Yes
The homepage lists $0/month, computers from $0.055/hour, AI at Orgo's rate and phone numbers at $3/month. Its README instead lists Free, Pro at $20/month and Max at $200/month, so the public prices disagree. |
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 |
Bops
Partly
Business-data lookups check work email addresses before use, and app changes go to Preview for human testing. Its docs do not describe requirement checks or scoring criteria for completed tasks. |
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 | Bops | Paperclip |
|---|---|---|
| Code review rules |
Bops
Not published
Its public docs do not describe bots reviewing generated code against repository rules. The documented type, lint and browser checks test Bops itself rather than a customer's delivered changes. |
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 |
Bops
Not published
Its public docs do not describe an independent second review of risky customer changes. A documented independent review concerns development of Bops' own interface. |
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 |
Bops
Not published
Its public docs do not describe a change-risk rating before merge. Preview review and confirmation of the publishing destination are documented, without a risk score. |
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 |
Bops
Partly
Tasks can save code changes to GitHub, and publishing can push an app to its repository. Its docs do not describe bots opening pull requests or responding to review feedback. |
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. Bops 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 Bops if you want specialist bots using a Mac or cloud computer while you handle concrete action requests. Its public docs do not establish a task-review process with requirement checks, and Always allow has a broad bot-and-action scope.
Pick Paperclip if you want self-hosted agent coordination, human-owned tasks and ordered review stages. General Cloud availability is not established, and experimental planning and review features need to be evaluated as such.
Where Task Machine fits
Task Machine puts the reviewed plan, deliverable and run history on a Task, with requirement checks before human review. Workflows can include branches and verifier feedback, and action permissions are set per agent. Task Machine is the wrong pick if you require Paperclip's self-hosted stack, which you give up when moving. See Switch from Paperclip to Task Machine.
The direct comparisons, Task Machine vs Bops and Task Machine vs Paperclip, separate those review mechanisms. Next, write the acceptance requirements for one deliverable and identify whether your current process can return failed work to its executor.