
Quick take
Linear has gone further with agents than most issue trackers. Linear Agent triages, answers questions and turns an issue into a draft pull request with Claude Code or Codex in a Linear-managed sandbox. Loops run on schedules and events, and third-party agents such as Codex, Cursor and Devin join as assignable members. Paperclip is also a team tool. It runs the same coding agents on your own machines, with people and agents in one org chart, review and approval on every task, budgets with a hard stop and connection rules for every integration. Pick Linear if your team lives in Linear and wants agents there with no infrastructure. Pick Paperclip if the agents are a team of their own, run on hardware you control and work across more than one tool.
At a glance
Scroll sideways to see both columns
| Capability | Paperclip | Linear agents |
|---|---|---|
| Runs Claude Code and Codex | Yeson your machine, with your own login | Yesin Linear’s cloud sandbox, billed with AI credits |
| Shared by a whole team | Yespeople and agents share one org chart, with the same tasks, threads and history | Yesagents are workspace members, admins install them |
| Private projects and tasks | Yeschoose which people and agents can see each one | Yesprivate teams, and the agent sees only what you can see |
| Third-party agents as assignees | Yes13 built-in agents plus Process and HTTP | YesCodex, Cursor, Copilot, Factory, Sentry, Devin and more |
| Routines: scheduled and webhook-triggered work | Yesroutines with schedules, webhooks and Run now, each run is a task | YesLoops, on schedules, Linear events, Slack and GitHub |
| Review and approval built into every task | Yespeople or agents approve the work before it ships, and changes go back to the agent | Partiala draft PR reviewed in Linear Diffs, GitHub rules decide what ships |
| Apps and connections with a rule for each action | Yes40+ apps and any MCP server, each action Off, Ask first or Allowed | Partialadmin-configured MCP connectors, a per-tool approval setting on each loop |
| Shared skills | Yesone library for the whole company, written and tested in Skill Studio | Nonothing in the docs |
| Chat channels | Yesexperimental: Slack, Discord, Teams, Telegram, GitHub and email | PartialLoops trigger on Slack messages, the agent answers inside Linear |
| Spend limits | Yesbudgets with a hard stop, pause at 100% | Yesworkspace, per-user and per-loop limits stop new billable work |
| Org structure for agents | Yesorg chart with reporting lines and delegation | Noagents are workspace members |
| Rules for each connection (Allowed, Ask first, Off) | Yesand you choose who can use each connection | Partiala per-tool approval setting on each loop, admin-configured MCP connectors |
| Activity history and config rollback | Yeswho did what, revisioned config with rollback | Partialloop run history, audit log on Enterprise |
| Runs on your own machines | Yes | NoLinear’s sandbox, or the third-party vendor’s hosting |
| Issue tracking | Partialtasks and projects inside Paperclip | Yesthe core product |
| Work outside code | Yessupport, marketing and operations run in the same app | PartialLoops and agent chat over Linear data |
| Native desktop app | Noinstallable web UI | Yes |
| Self-hosted | Yes | No |
| Hosted option | YesPaperclip Cloud, join the waitlist | Yeshosted only |
| Open source | YesMIT | No |
What Linear agents do well
Linear Agent lives in the tool your team already uses. You mention it in a comment or a doc, and it creates and updates issues, projects and milestones, searches across your workspace and drafts specs and updates. Since June 2026 it also writes code. It takes a well-scoped issue, works in a secure cloud sandbox with Claude Code or Codex and returns a draft pull request that you review as a diff inside Linear. Linear says it resolves roughly 30% of its own incoming bug reports this way.
Loops run on a schedule or an event, such as an issue entering triage, a Slack message or a GitHub pull request. Each loop has a run history and a per-tool approval setting. Admins pick the model for coding sessions from a list that includes Claude, GPT and GLM models.
Third-party agents join the workspace as members you can assign and mention. The directory lists Codex, Cursor, GitHub Copilot, Factory, Sentry and Devin, and a public agent API lets you build your own. Agents don’t count as billable users.
Cost control is real. AI credits are a prepaid balance with no markup on model tokens, and admins set spend limits for the workspace, a user or a loop. When a limit is reached, new billable work stops.
Where Paperclip differs
Governance for a shared space
Both tools are built for a team. Paperclip adds the rules that keep a shared space safe. People and agents share one org chart with roles and permissions. Review and Approval stages hold a task until a named reviewer approves it. Budgets stop spending at a limit. Each connection has action rules (Allowed, Ask first, Off), and you choose who can use each connection and which agents can access it. Config is revisioned with rollback, and an activity history shows who did what. Managed GitHub operations act as the person who directs the work, so each change traces to that person. Sharing is the default, and privacy is a choice: mark a project or a task private, then choose which people and which agents can see it. Opening a private project to the company keeps its protected tasks private. Linear has admin-only agent installs, a per-tool approval setting on each loop, spend limits and an Enterprise audit log. Its docs don’t describe review and approval on an issue or config rollback.
A team of agents, not members of a tracker
Linear’s agents are individual assignees inside Linear. Paperclip’s agents are a team with an org chart. A CTO agent splits a plan into tasks, coder agents build and a QA agent reviews, and delegation follows the chart. Every task has one owner and a thread that keeps the plan, the diff and the results.

Your machines, your logins
Linear’s coding sessions run in Linear’s sandbox and draw AI credits. Paperclip runs the Claude Code or Codex CLI that is installed on your own machine, with the subscription login you already have. An API key is optional. Paperclip can give each task its own git worktree, and the agent opens the pull request with its own git and gh.
People sign off before work ships
In Linear the draft pull request goes to GitHub, where your branch rules decide what ships. In Paperclip the Review and Approval stages are part of the task. The task closes only after approval, and “changes requested” sends it back to the agent.
Open source and self-hosted
Paperclip is MIT licensed and runs as a local server with a web UI. Linear is a hosted product.
Apps with a rule for every action
Paperclip connects to 40+ apps and model providers, including GitHub, Linear, Notion, Slack and Google Workspace, and to any MCP server by URL. You choose who can use each connection and which agents can reach it. Every action has its own rule: Off, Ask first or Allowed. Ask first turns the call into a decision for a person. Linear Agent uses admin-configured MCP connectors, each loop has a per-tool approval setting and Loops run on schedules and events. Its docs don’t describe shared skills.
Routines and shared skills
A routine is repeatable work with a schedule or a webhook trigger. Each run creates a task you can follow, and the routine keeps a history. Skills are shared across the whole company. Skill Studio lets the team write, fork, test and version them, so one person’s fix helps every agent. Chat channels for Slack, Discord, Teams, Telegram, GitHub and email are experimental and off by default.
Use them together
Paperclip has a Linear connector, so tasks can flow between the two. One pattern is to keep planning in Linear and let Paperclip run the agent team that does the work, with the pull request as the handoff.
- A teammate assigns the task
- Anyone comments, the agent wakes
- The reviewer approves
- TaskOne owner. A thread for the plan and results.
- The agent runsWoken by the task, a comment or a schedule.
- Work productPosted in the task thread with the diff or files.
- Review stageA named reviewer, a person or an agent, approves or requests changes.
- ApprovedThe task closes only after approval.
When to choose Linear agents
- Your team lives in Linear and wants triage, specs and small fixes there with nothing to run.
- You want spend limits and a model picker without managing any machines.
- The agents you want are already in Linear’s directory.
- A draft pull request reviewed in Linear is enough process for you.
When to choose Paperclip
- A whole team shares the agents with governance and permissions built in: roles, review and approval, budgets, connection rules, and private projects and tasks for sensitive work.
- You want the agents to run on your own machines with your own logins.
- You want connection rules, config rollback and a history of who did what around a shared agent team.
- You need an org chart with roles and delegation across many tasks.
- You want sign-off on the task itself, not only on the merge.
- The same agents also handle support, marketing or operations.
- You want open source you can self-host.
FAQ
Can Linear Agent write code?
Yes. Since June 2026 it starts a coding session with Claude Code or Codex in a Linear-managed sandbox and returns a draft pull request. It uses AI credits.
Does Linear have per-agent budgets?
Linear has spend limits for the workspace, for each user and for each loop. Third-party agents bill through their own vendors.
Does Paperclip integrate with Linear?
Yes. Paperclip has a Linear connector, so tasks can move between the two tools.
Is Linear open source?
No. Linear is a hosted product with Free, Basic, Business and Enterprise plans.
Sources
- Linear, Agents, Linear Agent, Cloud coding agent, Loops, AI credits, Usage and limits, Developers: agents and pricing, checked November 10, 2026
- Linear changelog, Coding sessions (June 11, 2026) and Linear Diffs (May 27, 2026), checked November 10, 2026
- Paperclip, README, docs and Linear connector, 112,884 stars, checked November 10, 2026


