Best Linear AI Agents in 2026
Dott
If you've typed "linear ai agent" into a search box this year, you probably found two different things wearing the same name. One is Linear Agent, the assistant Linear switched on in every workspace back in March. The other is the growing list of agents you can hand an issue to the way you'd assign a teammate: Codex, Cursor, GitHub Copilot, Devin and about thirty more in Linear's agents directory.
I build one of them. Merlin is first on this list, and not only because you're reading Merlin's blog. It's the agent that works our own Linear issues every day, so it's the one I know best, and I'll tell you who shouldn't pick it.
For the other eleven, here's how I worked. I read each vendor's docs, pricing page and changelog (all checked on October 11, 2026), opened every vendor's own site instead of trusting the directory card, and compared them on the three things their marketing tends to skip: which engine actually writes the code, where it runs, and whose bill it lands on. I didn't install all eleven in our workspace, so where something is my judgement rather than a documented fact, I say so.
If you're just here for a quick recommendation, here's the summary.
The short answer
- Your engineers already run Claude Code or Codex: Merlin. Delegate the issue, the work runs on a teammate's machine with everything that machine can reach, and nobody buys another model.
- You want the agent that comes with Linear: Linear Agent, for workspace work on any plan and for cloud coding sessions on paid plans.
- You already pay for ChatGPT, Cursor or Copilot: Codex, Cursor or GitHub Copilot.
- You want an autonomous engineer on its own cloud: Devin or Factory.
- You want Claude Code on your own keys, open source: Cyrus.
- You want to bring your own subscription to a rented sandbox: Tembo or Boxes.dev.
- The issue is a production error: Sentry Seer.
- The issue is not code at all: ChatPRD.
The 12 agents at a glance
Here's the whole list in one table. The "Under the hood" column is the one I'd read first, because it tells you whether you're getting Claude Code, Codex, a vendor's own agent, or your pick.
| Agent | Best for | Runs on | Under the hood | You pay |
|---|---|---|---|---|
| Merlin | Teams already on Claude Code or Codex | Your team's machines | Claude Code or Codex | Per workspace, models on your own plans |
| Linear Agent | Workspace work, small cloud fixes | Linear's cloud sandbox | Claude Code or Codex | Linear seat plus AI credits |
| Codex | ChatGPT shops | OpenAI's cloud | Codex | Paid ChatGPT plan |
| Cursor | Cursor shops | Cursor's cloud VMs | Cursor cloud agents | Cursor plan plus usage |
| GitHub Copilot | GitHub-centric teams | GitHub Actions | Copilot cloud agent | Paid Copilot plan |
| Devin | An autonomous engineer with playbooks | Devin's cloud VMs | Devin | From $20 per month |
| Factory | Enterprises on Factory | Factory's cloud | Droids, any model | From $20 per month, preview |
| Cyrus | Claude Code on your keys, open source | Your server or Cyrus cloud | Claude Code, your keys | Free self-hosted, $50 per month |
| Tembo | Picking the engine per issue | Tembo's cloud VMs | Your pick | Free trial, $60 per month |
| Boxes.dev | Stock agents on your subscription | Cloud devboxes | Claude Code or Codex, your login | Free trial, $19 per user |
| Sentry Seer | Bugs that started in Sentry | Sentry's cloud | Seer | Seer add-on, $40 per contributor |
| ChatPRD | Issues that aren't code | ChatPRD's cloud | ChatPRD | Teams plan, $29 per seat |
These are the list prices I saw on October 11, 2026. At least one of them will change before you finish reading, so follow the links in each section for today's number.
Two kinds of agent, and what I compared
Before the list, one thing worth getting straight, because it explains why these twelve look so different. Linear Agent is Linear's own assistant, part of the product. Everything else in the directory is an app user: a third-party service that Linear can hand an issue to. Linear's docs describe those as teammates that "can open PRs against issues, help write documents, and take most actions that human users can" (AI agents in Linear), they aren't billable seats, and they work on every Linear plan. They share the issue, the agent session and the stop button, and nothing else.
So I compared every entry on the three things that actually differ:
- The work it takes. Workspace work (write and tidy issues, break down a project, summarize a thread, triage) or code, where the pull request is the unit of output.
- Where the code runs. Linear's own cloud, the vendor's cloud, or your own machines. This decides what the agent can reach: a sandbox has to be handed your repositories, secrets and tools, while a machine your engineer already uses starts with them.
- The engine, and whose plan pays for it. Claude Code, Codex, a vendor's own agent, or your pick, billed through the vendor's seats or credits, Linear's prepaid AI credits, or the Claude and ChatGPT plans your engineers already have. Half of the twelve run Claude Code or Codex under the hood, and they disagree about who pays for it.
Linear's directory lists 34 agents today. Not all of them still exist, which is the first thing to check.
The 12 best Linear AI agents in 2026
1. Merlin
Best for teams that already run Claude Code or Codex.
Merlin brings the Claude Code and Codex your engineers already run into Linear, Slack and GitHub.
Here's the problem I started Merlin to fix. The most capable agent in most software companies isn't in Linear's directory. It's Claude Code or Codex on one engineer's laptop, with the repositories cloned, the credentials working, the MCP servers wired in and the skills written. Linear is where the rest of the company already queues work for that engineer. Merlin lets them queue it for the agent instead: delegate an issue to Merlin or mention it in a comment, Merlin picks an eligible runtime in your workspace (a teammate's machine running the Merlin desktop app or CLI), and the work runs there through the Claude Code or Codex already installed (Linear guide).
A real session from our own workspace: delegate, watch the actions, get the pull request, then steer with a follow-up.
What stands out
- The agent starts inside an environment that already works: your repositories, credentials, tools and MCP servers, instead of a fresh sandbox you have to fill.
- Everything happens in the open. Progress lands in the session as thoughts and actions, the result arrives as a response with the pull request linked, the issue moves to In Progress on the way, and a follow-up in the same session steers active work or continues a finished task. The stop control cancels it.
- One Merlin, every surface. The same agent answers in Slack and on GitHub, with shared skills one person publishes for the whole workspace, schedules for recurring work, and memory kept per workspace. Each machine owner decides whether their runtime stays private or is shared (devices and runtimes).
Worth knowing
- Not for you yet if nobody on the team runs Claude Code or Codex (prerequisites). Start with one of the cloud agents below and come back.
- A shared runtime has to stay awake and online, we support those two agents only, and your Linear admin approves the install.
Pricing: we don't host a model, so model usage stays on each machine owner's own Claude or ChatGPT plan. Merlin itself is per workspace: Starter at $9 per month for up to 3 people and 1,000 requests, Team at $59 per month for up to 50 people, Scale at $99 per month for up to 200, with a 14-day Team trial and no card (pricing).
2. Linear Agent
Best built-in option, and really two products.
Linear Agent is on by default in every workspace. Its coding sessions are a separate, credit-metered thing.
Linear Agent is the one you don't install. Linear launched it in public beta on March 24, 2026, the week its CEO declared that "issue tracking is dead", and it's "available by default in your workspace" on every plan, Free included. Press ⌘J, mention @Linear in a comment, or talk to it from Slack or Teams. The second product arrived on June 11, 2026: coding sessions, where you delegate a well-scoped issue to Linear and it "writes and tests the change in a secure cloud environment, then returns a draft pull request for review" (coding sessions).
What stands out
- Workspace work with zero setup: it answers questions about the workspace (and, on Business and Enterprise, about your code through Code Intelligence), creates and updates issues, projects, milestones and initiatives, summarizes threads and customer requests, and edits text. Good conversations can be saved as skills, and admins write guidance at the workspace, team and personal level.
- Coding sessions run Claude Code or Codex in Linear's cloud, with GPT-6 Sol as the default model and Anthropic, OpenAI and GLM models selectable. The diff lands in Linear's Reviews tab and updates in real time since October 8.
- Loops, added July 20, run the same agent on a schedule or an event.
Worth knowing
- The credits are a second meter on top of seats, and they're non-refundable. The sandbox is Linear's, not yours: one repository per environment, repositories must come through the GitHub integration, and a session starts with what Linear can install rather than with the tools on your engineers' machines.
- Linear's docs list Basic, Business and Enterprise for coding sessions and Loops, while the pricing grid shows the rows from Business. Check the current page before you count on Basic.
Pricing: Linear Agent is included in the seat (Free at $0, Basic at $10 and Business at $16 per user per month on annual billing, per Linear's pricing). Coding sessions and Loops are paid-plan features billed from prepaid AI credits: model tokens at provider rates with no markup, plus $0.25 per 20-minute block of sandbox time, with a $10 minimum top-up and a 12-month expiry.
3. Codex
Best if your engineers already pay for ChatGPT.
Codex has been a first-party Linear agent since December 2025. The page is OpenAI's docs rather than the product.
Codex is OpenAI's own Linear agent, and it has been one since December 4, 2025. Assign an issue to Codex or mention @Codex in a comment, and "Codex creates a cloud chat and replies with progress and results." Setup is three steps: connect GitHub in Codex and create a cloud environment for the repository, install Codex for Linear from Codex settings, then mention @Codex once to link your Linear account.
What stands out
- Linear suggests a repository from the issue and Codex picks the matching cloud environment, so there's nothing to tag.
- You can assign several issues at once and get an inbox notification when one needs input or is ready for review.
- It's the cleanest answer on this list to "who pays for the model": the ChatGPT plan you already have.
Worth knowing
- Codex doesn't open the pull request from Linear. It posts a summary and a link to the finished chat, and you create the PR from Codex. The directory card skips this, and I'd want to know it.
- Every new repository is another cloud environment to set up, and on ChatGPT Enterprise an admin has to switch on cloud chats and the Linear connector first.
Pricing: paid ChatGPT plans only. The Linear integration is listed for Plus ($20 per month), Pro (from $100), Business ($20 per user per month on annual billing) and Enterprise (Codex pricing, seen on October 11, 2026), with usage metered in that plan's credits.
4. Cursor
Best for teams already on Cursor.
Cursor cloud agents take a Linear issue and come back with a pull request.
Cursor was the first big vendor to ship a Linear agent, on August 21, 2025, and Linear later wrote up how it was built. Delegate an issue to Cursor or mention @Cursor, and a cloud agent starts in one of Cursor's isolated VMs, shows live status in the issue and updates it with a pull request when it's done (docs).
What stands out
- Steering is a comment away: another
@Cursorredirects the running agent, and triage rules can start agents from labels without anyone assigning anything. - Repository and model are chosen per issue with a
[repo=owner/name]tag, a repository label or amodelkey, with a dashboard default as the fallback. - The docs say Cursor "filters out non-development work automatically," so a ticket that isn't code gets politely ignored instead of mangled.
Worth knowing
- A Cursor admin connects the workspace and source control, and the setup steps include "enable usage-based pricing," because cloud agents are "charged at API pricing for the selected model." Somebody on your team owns the monthly surprise.
- For your procurement folder: SpaceX closed its acquisition of Cursor in August 2026.
Pricing: a paid Cursor plan (pricing lists $20 per month for individuals and $40 per user per month for teams, seen on October 11, 2026) plus cloud agent usage at API prices.
5. GitHub Copilot
Best if your code and your Copilot seats already live on GitHub.
Copilot's cloud agent runs in GitHub Actions and opens a draft pull request from a Linear issue.
GitHub's agent reached Linear in public preview on October 28, 2025 and went generally available on July 23, 2026. Assign an issue to GitHub Copilot, or mention @GitHub, and the cloud agent reads the issue and its comments, opens a draft pull request that shows up under the issue's links as "[WIP]", works "in its own ephemeral development environment powered by GitHub Actions," streams progress into the Linear timeline and asks for your review when it's done (docs).
What stands out
- From the issue you can choose the model, a custom agent from your repository or the base and working branches, and steer with further comments.
- It's included in every paid Copilot plan, so for a GitHub shop it's the agent you already own.
- The draft PR is in your repository from the first minute, with your branch protections and reviews applying as usual.
Worth knowing
- The sandbox is a GitHub Actions runner with hard edges: a session runs for at most 59 minutes, works on one repository and one branch, and opens one pull request per task (about cloud agent). Anything not reachable from GitHub (an internal service, a staging database, a local MCP server) isn't reachable from the agent.
- Only people with write access to the target repository can start it.
Pricing: "Available for all paid Copilot plans": Pro at $10 per month, Pro+ at $39, Max at $100, Business at $19 and Enterprise at $39 per seat per month (plans, seen on October 11, 2026). Since June 1, 2026 usage is metered in GitHub AI Credits at one cent each, and a long session on a frontier model costs more of them.
6. Devin
Best autonomous engineer with playbooks.
Devin was a launch agent when Linear opened its agent platform in May 2025.
Devin was one of the three launch agents when Linear opened its platform on May 20, 2025, and it's the one I'd describe as a full autonomous engineer rather than a coding tool with a Linear door. Each session boots a Linux virtual machine from a snapshot of your environment, in Cognition's cloud, and the engine is Devin itself.
What stands out
- Three triggers: assign the ticket and Devin runs your default playbook, add a playbook label such as
!plan,!implement,!triageor!review, or mention Devin with instructions and it skips the playbooks and does what you said. - Automation triggers start sessions when a ticket changes team, label or status, with no human in the loop.
- It posts an activity feed, syncs its plan into Linear's plan view, attaches the pull request and session links, and answers follow-up comments.
Worth knowing
- Quotas plus on-demand credits mean a typical ticket's cost is something you learn by running tickets.
- One twist on who pays: Devin can bill "the GPT model portion of your sessions" to a linked ChatGPT plan (docs). Cognition raised over $2B at a $48B valuation in September 2026, so the plans will still exist next quarter.
Pricing: since the April 2026 plan change, Pro at $20 per month with a daily and weekly usage quota, Max at $200, Teams from $80 per month plus $40 per full seat, and Enterprise billed in ACUs (billing docs, seen on October 11, 2026). The Linear integration starts at Pro.
7. Factory
Best for enterprises with a Factory contract.
Factory's Linear delegation is a private preview. The page tells you to ask your account team.
Factory's Droids got a Linear agent on October 16, 2025. Assign an issue to Factory or mention @Factory, and "Droid runs on a remote computer and posts progress and results in Linear" (docs). Under the hood is Droid, Factory's model-agnostic agent (GPT-5, Claude, Gemini and open-weight models, with bring-your-own-key support), on Factory-hosted compute.
What stands out
- It moves the issue to In Progress, streams its thinking and tool calls as agent activities, opens a pull request and returns the URL, and anyone can press Stop.
- Delegated work runs as a service account with its own Git credentials, which is what a platform team wants and a five-person startup doesn't need.
- Model choice is wide open, including your own keys.
Worth knowing
- The docs are candid that this is "the Private Preview delegation flow" and tell you to "contact your Factory account team to request access." A preview can change shape.
- The repository has to be named in the issue, and a personal Linear connector in Factory doesn't install the agent.
Pricing: Pro at $20 per month, Plus at $100, Max at $200, Teams at $60 per month plus $40 per seat, Business and Enterprise custom (pricing, seen on October 11, 2026), metered in Factory credits plus compute. Linear delegation is gated by the preview rather than the plan.
8. Cyrus
Best for Claude Code on your own keys, open source.
Cyrus runs Claude Code from Linear issues on your own API keys, self-hosted or in its cloud.
Cyrus is an open-source agent (Apache 2.0) built for one job: turning Linear issues into pull requests with Claude Code, on your own Anthropic API key or Claude Pro or Max subscription. If you like Merlin's "your keys, your machine" idea but want something you can read the source of, this is the one to look at.
What stands out
- Assign an issue, set an auto-assign label or mention
@Cyrus, and a session thread opens on the issue with a live feed of tool calls and edits. The status walks from Todo to In Progress to In Review, the pull request link lands at the end, and a reply in the thread redirects it (Linear docs). - Codex, Cursor, Gemini and OpenCode are available as alternative engines, picked per issue with a tag or label.
- You choose where it runs: your own machine or server, or Cyrus's hosted runtime. The project announced SOC 2 Type II compliance on October 8, 2026.
Worth knowing
- On Community and Pro the agent is only as awake as the machine you run it on, and switching runtimes drops the context of active issues.
- Two bills: the Cyrus plan and your model usage.
Pricing: a free self-hosted Community edition where you create your own Linear app, Pro at $50 per month (self-hosted only, up to 5 Linear members and 5 repositories), Team at $120 (up to 20 members and 10 repositories, with the hosted runtime), Enterprise custom (pricing, seen on October 11, 2026).
9. Tembo
Best when you want to pick the engine per issue.
Tembo lets you choose which coding agent takes the issue.
Tembo is an agent router with Linear support since June 2025. Assign a Linear issue to Tembo, or add its label, and the agent you configured takes it in an isolated Linux VM in Tembo's cloud, with the repository cloned in and your MCP servers attached.
What stands out
- The engine is your choice: Claude Code, Codex, Cursor, Amp or OpenCode (coding agents), which makes it the easiest way to compare engines on real tickets.
- It reads the ticket and linked context, picks the repositories (several at once if needed), runs tests and opens a pull request linked to the issue, with status updates and session links posted back.
- The pricing model is the part I find interesting: "subscription-backed inference costs $0 through Tembo." Connect your Claude, ChatGPT or SuperGrok subscription, or your own API keys, and you pay only for the compute (models).
Worth knowing
- Iterating is documented through
@temboon the pull request or in Slack rather than in the Linear thread. - The sandbox is Tembo's, so your environment has to be reproducible from the repository.
Pricing: a free trial, then Pro at $60 per month ($60 allowance, up to 5 users) and Max at $200 ($200 allowance, up to 10 users), Enterprise custom (pricing, seen on October 11, 2026). Linear is included on every plan.
10. Boxes.dev
Best cloud sandbox for the Claude Code and Codex subscriptions you already have.
Boxes.dev runs the stock Claude Code and Codex on a cloud devbox, on your own subscription.
Boxes.dev is the closest thing in the directory to Merlin's bet, with one word changed. Assign or delegate a Linear issue to it, or mention it in a comment, and it starts "your chosen agent, Claude Code or Codex, on a fresh devbox" (directory page): a cloud Linux machine snapshotted from a template box with your whole development environment, not just a repository checkout. The word that changed is where: a devbox in Boxes.dev's cloud instead of the machine your engineer already tuned.
What stands out
- The engine is the real thing: "the real Claude Code CLI with your Claude login or an API key, so your
CLAUDE.md, skills, and hooks work the way they do on your laptop," and likewise Codex with your ChatGPT login (guide). - Model usage counts toward your own Claude or ChatGPT plan, and Boxes.dev says it doesn't sell tokens.
- Progress and the final answer land in the issue's agent session with a link to the full thread, a reply sends a follow-up, Linear's stop control ends the work, and the agent can attach its pull request or preview to the session.
Worth knowing
- It's a two-person company from YC's Fall 2026 batch that launched in June, the integration is configured from its desktop app, and each user gets one default automation per Linear workspace.
- If you want the same idea with a per-task sandbox and a free tier of five tasks a day, Sinatra is the other Linear-first option, with the caveat that its default engine is the open-source oh-my-pi harness rather than Claude Code or Codex.
Pricing: a free trial with 20 box-hours, then Starter at $19 per user per month with 40 box-hours and Pro at $99 with 250, where a box-hour is a 4 vCPU, 8 GB devbox awake for one hour and sleeping boxes are free (plans, seen on October 11, 2026). Tokens stay on your own subscription.
11. Sentry Seer
Best when the Linear issue came from a Sentry error.
Sentry's agent runs Seer on the Sentry error linked to a Linear issue.
The Sentry Agent for Linear arrived on October 2, 2025, and it's the specialist on this list. Assign a Linear issue that is linked to a Sentry error to Sentry, or comment @sentry, and it runs a Seer issue fix in Sentry's cloud.
What stands out
- A root cause analysis and a proposed code fix, posted into the issue where the rest of the team can see them.
- You can let Seer open the pull request itself, or hand the fix to Claude Code, Cursor or Copilot.
- It fits in front of any other agent on this list: diagnosis first, then whoever writes the fix.
Worth knowing
- The docs label it a beta, a Sentry owner, manager or admin installs it, it doesn't work with self-hosted Sentry, and the cookbook notes that "the agent needs a linked Sentry issue to work."
- Private Linear teams aren't supported.
Pricing: Seer is an add-on at $40 per active contributor per month on Sentry's Team ($26 per month) and Business ($80 per month) plans, with a 14-day trial (Sentry pricing, seen on October 11, 2026).
12. ChatPRD
Best for the issues that are not code.
ChatPRD is the product manager's agent in Linear.
ChatPRD was another of the three launch agents in May 2025, and it's the one entry here that never opens a pull request on purpose. Mention @chatprd in a comment and it works on the ticket itself.
What stands out
- It suggests a better title and a structured description, breaks the issue into sub-issues, or answers a requirements question in the thread.
- Since June 2025 it listens only to mentions, so it won't pile onto every new issue.
- Organization-level access means the whole product team shares one agent.
Worth knowing
- It improves the ask, not the code. Pair it with one of the agents above.
Pricing: the Linear agent is part of the Teams plan at $29 per seat per month, or $349 per seat per year (pricing, seen on October 11, 2026).
How to choose a Linear AI agent
I've always found roundups like this one to be a starting point rather than a verdict. Before you install anything, run three questions in order and stop at the first one that eliminates options.
- Is the issue code? If not, Linear Agent is already in your workspace and costs nothing extra, and ChatPRD is the specialist for requirements. If it is, keep going.
- Does the work need your real environment? If the task touches local repositories, internal services, staging databases or the MCP servers your engineers rely on, a cloud sandbox has to be handed all of that first. An agent on your own machines starts with it. That's Merlin's lane, and Cyrus's if you self-host it. Everyone else gives you a sandbox: Linear's own, or the vendor's.
- Who pays for the model? If your engineers already pay for Claude or ChatGPT, Merlin keeps model usage on those plans, Cyrus runs on your own keys or Claude subscription, and Tembo and Boxes.dev let you connect a subscription and pay only for their compute. Codex, Cursor and Copilot bill through the plan you already have with them. Everything else meters a currency of its own: Linear's AI credits, Devin's quotas, Factory's credits.
Four things most lists skip
- "Agent" is two products. Linear Agent is a workspace assistant that happens to have a coding mode. The agents in the directory are app users that Linear hands an issue to. They share a session UI and nothing else: different engines, different sandboxes, different bills. A feature grid that scores them together is comparing a kitchen to a restaurant.
- There is no Claude Code agent. Codex has had a first-party Linear agent since December 2025, Cursor since August 2025 and Copilot since October 2025. Anthropic has shipped none, and the request on the Claude Code repository has been open since December 3, 2025. What Linear offers under "Claude" is an MCP connector, which lets Claude Code read and write Linear from a terminal, not take an issue. The roads from a Linear issue to Claude Code today are Linear's own coding sessions, Merlin, Cyrus, and the rented sandboxes that accept your subscription, Tembo and Boxes.dev. My bet, and the reason Merlin exists, is that the one starting inside an environment your engineers already tuned ships code more convincingly than a fresh box.
- Agents are free seats. Credits are not. Linear's docs are explicit: "Agents are not counted as billable seats in Linear" (AI agents), and the agent platform is included from the Free plan. Linear's own coding sessions need a paid plan plus prepaid AI credits that expire after a year. Before comparing a vendor's price with "Linear already does this," add the credits.
- Directories go stale. Linear's directory still lists Charlie, whose site now reads "Charlie has shut down." It was on my shortlist until I opened the page. Check the vendor's own site before you install anything from a directory, ours included.
FAQ
Two things. Linear Agent is the assistant built into Linear: it answers questions, writes and updates issues, projects and documents, and on paid plans can run coding sessions in Linear's cloud. A Linear AI agent in the broader sense is any app user you can delegate an issue to or @mention, such as Merlin, Codex, Cursor, GitHub Copilot or Devin. Linear's docs describe them as teammates that can open PRs against issues and take most actions a human user can.
The assistant is. Linear's pricing page includes Linear Agent from the Free plan, and its chat, summaries and issue edits don't use AI credits. Coding sessions and Loops are different: they need a paid plan and draw from prepaid AI credits, billed as model tokens at provider rates plus $0.25 per 20-minute block of sandbox time (AI credits).
Not to Anthropic's Claude Code directly, because there's no first-party Claude Code agent in Linear's directory as of October 2026. You can get Claude Code working on an issue through Linear's own coding sessions (Claude Code as the engine in Linear's cloud), through Merlin (on your team's machines, on each owner's own plan), through Cyrus (on your own API keys) or through a cloud devbox vendor such as Boxes.dev or Tembo.
No. Linear states that agents aren't counted as billable seats, and the agent platform is available on every plan including Free. You pay the agent's vendor, not Linear, for the agent. The one exception is Linear's own coding sessions and Loops, which are billed through Linear's AI credits.
Not for third-party agents: delegation and @mentions work on every Linear plan, and the agent's own requirements (a Cursor admin, a paid ChatGPT plan, a Copilot subscription) are what gate you. Linear's own coding sessions and Loops are listed for Basic, Business and Enterprise in Linear's docs, while the pricing grid shows them from Business, so check the current page before you count on Basic.
It depends on the agent, and it's the most important thing to ask. Linear Agent runs in Linear's cloud sandbox. Codex, Cursor, Copilot, Devin, Factory, Tembo and Boxes.dev run in their own cloud environments. Merlin runs on your team's machines through the Claude Code or Codex already installed there, and Cyrus can be self-hosted. A cloud sandbox has to be given your repositories, secrets and tools before it can do real work. Your own machine already has them.
With Merlin, yes: it drives the Claude Code and Codex already installed on your team's machines, so model usage stays on each machine owner's own plan. Codex in Linear uses your paid ChatGPT plan. Cyrus, Tembo and Boxes.dev accept your own API keys or your Claude and ChatGPT subscriptions, and Devin can bill its GPT usage to a linked ChatGPT plan. Linear's coding sessions, Copilot and Factory bill model usage through their own credits or plans.
Linear Agent is Linear's product: it runs Claude Code or Codex in Linear's cloud, is billed through Linear's AI credits, and returns a diff inside Linear's Reviews tab. Delegating to Codex or Cursor hands the issue to that vendor's agent, which runs in the vendor's cloud, bills through your plan with that vendor, and posts progress back to the issue. Both show up as an agent session in Linear.
That's my list. If you land on Merlin, great, and if you land somewhere else, I'd like to hear which one and why.
Try Merlin for free
Hand work to Claude Code and Codex from Slack, Linear and GitHub. Free for 14 days, no API keys, no card required.
Get started for free