Latest release v2026.1106.0 is live (November 6, 2026).

See what's new
← All comparisons

Work platforms with agents

Paperclip vs Linear agents

In the tracker or above it

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

CapabilityPaperclipLinear agents
Runs Claude Code and CodexYeson your machine, with your own loginYesin Linear’s cloud sandbox, billed with AI credits
Shared by a whole teamYespeople and agents share one org chart, with the same tasks, threads and historyYesagents are workspace members, admins install them
Private projects and tasksYeschoose which people and agents can see each oneYesprivate teams, and the agent sees only what you can see
Third-party agents as assigneesYes13 built-in agents plus Process and HTTPYesCodex, Cursor, Copilot, Factory, Sentry, Devin and more
Routines: scheduled and webhook-triggered workYesroutines with schedules, webhooks and Run now, each run is a taskYesLoops, on schedules, Linear events, Slack and GitHub
Review and approval built into every taskYespeople or agents approve the work before it ships, and changes go back to the agentPartiala draft PR reviewed in Linear Diffs, GitHub rules decide what ships
Apps and connections with a rule for each actionYes40+ apps and any MCP server, each action Off, Ask first or AllowedPartialadmin-configured MCP connectors, a per-tool approval setting on each loop
Shared skillsYesone library for the whole company, written and tested in Skill StudioNonothing in the docs
Chat channelsYesexperimental: Slack, Discord, Teams, Telegram, GitHub and emailPartialLoops trigger on Slack messages, the agent answers inside Linear
Spend limitsYesbudgets with a hard stop, pause at 100%Yesworkspace, per-user and per-loop limits stop new billable work
Org structure for agentsYesorg chart with reporting lines and delegationNoagents are workspace members
Rules for each connection (Allowed, Ask first, Off)Yesand you choose who can use each connectionPartiala per-tool approval setting on each loop, admin-configured MCP connectors
Activity history and config rollbackYeswho did what, revisioned config with rollbackPartialloop run history, audit log on Enterprise
Runs on your own machinesYesNoLinear’s sandbox, or the third-party vendor’s hosting
Issue trackingPartialtasks and projects inside PaperclipYesthe core product
Work outside codeYessupport, marketing and operations run in the same appPartialLoops and agent chat over Linear data
Native desktop appNoinstallable web UIYes
Self-hostedYesNo
Hosted optionYesPaperclip Cloud, join the waitlistYeshosted only
Open sourceYesMITNo

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.

The Work Timeline page in Paperclip, with a lane for each agent and bars for every run during one day
Screenshot: the Work Timeline in Paperclip. Each lane is one agent. Blue bars are delegated runs and orange bars are routines, so you can see Codex and Claude Code agents working through a day without anyone watching a terminal.

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
  1. TaskOne owner. A thread for the plan and results.
  2. The agent runsWoken by the task, a comment or a schedule.
  3. Work productPosted in the task thread with the diff or files.
  4. Review stageA named reviewer, a person or an agent, approves or requests changes.
  5. ApprovedThe task closes only after approval.
Diagram: one task in Paperclip when the agent does the work. The whole team sees the same task, thread and history. A budget can pause the agent at any step.

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

Try Paperclip today

Open source under MIT. Runs on your own machine. One command to install.

npx paperclipai@latest onboard --yes

See how Paperclip runs a team of agents