Hyperagent vs Paperclip: Threads or Owned Tasks?
Compare Hyperagent threads with Paperclip tasks, review stages, hosting choices and the pricing each vendor publishes.
Founder, Task Machine
Hyperagent vs Paperclip turns on where you want responsibility for a job to live: a shared thread or an assigned task. Hyperagent's thread guide keeps instructions, questions and results in conversations. Paperclip's product reference gives work an owner, while its execution policies add review stages.
For a small software team, that choice becomes visible when someone asks who must finish a change. A thread can hold the investigation and the answer. An assigned task can also identify the person or agent expected to act on a review request, with the discussion and run history attached.
Hyperagent brings the team into the thread
Hyperagent's thread documentation brings instructions, working notes, questions and outputs into the same conversation. Agents can describe a plan there, update progress and accept further direction. Its public docs do not describe a required review of the plan and acceptance criteria before execution.
A room gives people and agents a shared place to work around a goal. Scheduled room activity can inspect metrics or blockers. The docs do not establish a named lead tracking a metric against a goal, so a room's shared purpose should not be read as a separate outcome owner.
This is a useful structure for work that needs discussion while an agent builds a report or dashboard. When another agent contributes, its result can return to the original thread. Your evaluation should include how a teammate finds the current instruction after several rounds of questions and revisions.
Paperclip makes assignment part of the record
Paperclip's published product reference describes tasks assigned to a person or agent. Their threads retain plans, blockers, files, conversation and run history. Its organization includes goals and budgets, while manager agents delegate through reporting lines.
Its execution-policy documentation defines ordered review and approval stages with human or agent participants. A reviewer can request changes and return work to the executor. These policies govern review stages, not general branching workflow steps.
For a change that needs implementation and then review, assignment and review order are directly relevant. You can assess whether the work has reached the reviewer and whether a rejected result has returned to its executor. That is a different inspection task from reading a conversation to understand the latest state.
Approval rules and result checks serve separate jobs
Hyperagent's autonomy documentation describes policies that allow an action, require approval or deny it. Repeated eligible approvals can prompt a proposed reusable rule, which an authorized owner must confirm. The docs do not describe proposals that tighten review after corrections.
Paperclip's action-permission guide sets connector actions to Allowed, Ask first or Off per connection. Its Decisions queue collects approvals, questions and proposals. The permission boundary is a connection, so check whether that matches how you want different agents to use the same service.
Result quality needs its own decision. Hyperagent's evaluation guide describes weighted rubrics that score thread responses and give reasons. Scoring inspects an existing response without rerunning the task, while Replay & evaluate creates a separate run in a hidden thread.
Paperclip instead documents returning rejected work through execution policies. A bundled quality skill includes acceptance criteria and a manual validation plan, but its docs do not establish automatic checks on every requirement. If a draft fails your release checklist, ask whether you need a score for analysis, a change request to the owner, or both. Neither an action approval nor a scored response alone answers that entire question.
Recurring work and memory change the handoff
Hyperagent's schedule guide records each scheduled occurrence's status and history. Runs can continue one thread or start separate ones, and webhooks can also launch work. For a weekly report, decide whether continuity in the conversation or a clean thread for each delivery makes review easier.
Paperclip's routine guide describes tasks created on schedules or through signed webhooks. Its docs do not describe a stable root task with separate occurrence histories. A routine that creates tasks gives your team an assignment to review each time, with a different record structure from scheduled conversation history.
Memory has a separate setup cost. Hyperagent's memory guide describes saved corrections and preferences that you can edit and restore, scoped to an agent or workspace. Paperclip's memory connectors are experimental and off by default. You configure a provider, and agents save and retrieve context through tools. Its checked docs do not establish user inspection or correction of those stored memories, or automatic background sync.
Hosting and AI access belong in the budget
Hyperagent's pricing page offers a free allowance and monthly budgets from $20 to $10,000. A $100 payment provides $115 in monthly credit, and unused plan credit expires each period. Its execution docs describe remote virtual machines and private thread sandboxes, with no published own-computer or self-hosting option.
Paperclip's homepage offers self-hosted software under the MIT license and a hosted waitlist. Its Cloud documentation describes organizations but does not establish general hosted availability or publish a Cloud price. Self-hosting leaves you to arrange the hosting and AI access.
Both can use an existing subscription, with different scope. Hyperagent documents connecting a subscription for supported GPT model usage. Paperclip's agent setup supports subscriptions or provider API keys. Do not treat the absence of a Cloud price as an all-in operating price for a self-hosted installation.
Hyperagent and Paperclip, point by point
The table asks the same questions of both products and includes sources and check dates. A narrower published capability is explained in its answer, even where the labels match.
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 | Hyperagent | Paperclip |
|---|---|---|
| Goals |
Hyperagent
Partly
Rooms bring people and agents together around a goal, and a room schedule can check a metric. The docs do not establish an agent or named owner tracking a metric against a 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 |
Hyperagent
Partly
Agents can delegate work to other agents, and room schedules can review progress and blockers. The docs do not establish a named lead or owner role coordinating that work. |
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 |
Hyperagent
Partly
Threads bring a job's instructions, working notes, questions and results together, and rooms let people and agents collaborate. Its docs describe no task record owned by either a person or an agent. |
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 |
Hyperagent
Yes
Schedules run in your timezone and record each occurrence's status and history, and webhooks start agents from outside events. Scheduled occurrences can continue in one thread or start separate threads. |
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 |
Hyperagent
Partly
Skills save methods and checks for reuse, and schedules repeat an agent's instructions. The docs do not establish a defined multi-step process that runs the same way each time. |
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 |
Hyperagent
Yes
An access policy can allow, require approval for or deny specific actions. Approvals collects questions and approval requests in the workspace. |
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 |
Hyperagent
Yes
After repeated eligible approvals Hyperagent can suggest a reusable rule that an authorized owner reviews and confirms before the policy changes. Its docs do not describe a suggestion to tighten review after corrections. |
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 |
Hyperagent
Yes
Agents recall saved corrections and preferences in later work, and you can edit memories and restore earlier versions. Memories can belong to an agent or workspace, but the docs do not describe the same separate goal, project and team scopes. |
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 |
Hyperagent
Yes
In a thread an agent can lay out a plan and update its progress, and you can give it further direction. The docs do not describe required review of a plan and acceptance criteria before work starts. |
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 |
Hyperagent
Yes
Email and webhooks can start agent work, and a room webhook can let eligible agents respond. The docs do not describe a team lead that triages incoming task records to owners. |
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 |
Hyperagent
Yes
Agents can use connected apps and custom remote Model Context Protocol servers, and webhooks can start runs. Custom servers do not support local servers or static bearer tokens. |
Paperclip
Yes
Paperclip lists service connectors and supports custom MCP servers. Routines can also start work through webhooks. |
| Models |
Hyperagent
Yes
Auto chooses a model for each message using a quality, balanced or low-cost profile. You can instead select a model manually. |
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 |
Hyperagent
Partly
Hyperagent runs skill scripts on an agent's remote virtual machine and gives each thread a private sandbox. Its docs describe no option to run agents on your own computer or infrastructure. |
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 |
Hyperagent
Yes
Hyperagent lets you connect your ChatGPT subscription to cover supported GPT model usage. Its docs describe no connection for other AI providers. |
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 |
Hyperagent
Yes
Hyperagent has a free allowance and paid monthly budgets from $20 to $10,000. A $100 payment gives $115 in monthly credit, and unused plan credit expires each period. |
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 |
Hyperagent
Yes
Rubrics hold weighted criteria, and evaluations score thread responses with reasons. The docs do not describe automatic acceptance checks on every task or verifier retries on workflow steps. |
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 | Hyperagent | Paperclip |
|---|---|---|
| Code review rules |
Hyperagent
Partly
Skills can contain steps, constraints and checks, and an agent can inspect a repository and run its checks. The docs do not establish code review against your 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 |
Hyperagent
Partly
One agent can delegate a task to another, and evaluations can use a different judging model. The docs do not establish an independent second review of risky changes. |
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 |
Hyperagent
Partly
A webhook prompt can ask an agent for a pull-request risk summary with links. The docs do not establish a risk rating 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 |
Hyperagent
Partly
Agents can inspect repositories, edit files, run checks and use GitHub tools for issues and pull requests. The docs do not establish agents addressing pull-request 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. Hyperagent 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 Hyperagent if shared conversations, recurring thread history and rubric-based evaluation match how you direct deliverable work. Its docs do not establish a person-or-agent-owned task record, or an option to run agents on your own infrastructure.
Pick Paperclip if you want assignable tasks, organizational reporting lines and review stages in a system you can host yourself. Be prepared to maintain that deployment, and treat experimental memory connectors and the hosted waitlist as explicit limits.
Where Task Machine fits
Task Machine combines owned Tasks with defined Workflows that can branch, ask human questions and check a step through a verifier. Failed checks can return work with feedback. Its Task reviews check every acceptance requirement before a person reviews the result, which differs from both a scored conversation and a review-stage policy.
Task Machine offers Managed Cloud or a Local Worker on a computer you control for local files, tools and accounts. 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. Start with Task Machine vs Hyperagent and Task Machine vs Paperclip, using one rejected deliverable to trace who receives the next action.