Connecting Linear to AI Coding Agents

Updated September 2, 2026 · first published July 23, 2026 · by the AQ team

A team can run coding agents from Linear issues in five ways as of September 2026: open the issue directly in a coding tool like Claude Code or Cursor, give the agent read and write access to Linear through the hosted MCP server, delegate the issue to a cloud agent from Linear's agent directory, delegate it to Linear itself (Linear Agent now runs its own coding sessions through Claude Code or Codex in a managed sandbox), or use a label-driven harness that turns issues into prepared agent workspaces on infrastructure you control. The routes differ most on two questions: does the tracker start the agent or does a person, and whose machine does the agent run on?

What a Linear integration has to move

The issue tracker is where work gets defined, prioritized, and assigned, which makes it the natural entry point for agent work. Any integration worth using has to move three things:

• Context in. The issue title, description, comments, and linked references are the spec. The agent should start with all of it, not a paraphrase.
• Status back. When work starts, progresses, and lands as a pull request, the issue should reflect it without a human transcribing updates.
• Ownership. Someone has to be accountable for what the agent produces, and the tracker's assignee field is where the rest of the company looks for that answer.

Every route below is a different tradeoff between those three flows and one more variable the tracker cannot see: where the agent executes.

Route 1: open the issue in your coding tool

Linear ships a direct handoff for local agents. In Settings, under Code and reviews, you can enable coding tools such as Cursor, Claude Code, and Codex; from any issue, the Work on issue menu (press W then O) opens the issue in your chosen tool, carrying the issue's data plus a customizable prompt template with standing instructions, as of September 2026.

This is the simplest integration: the agent runs on your machine, under your accounts, and you are present for the whole session. The limit: a one-shot handoff. The agent gets the issue as it existed at launch, new comments do not reach it, and nothing syncs back. Status updates and the PR link are your job.

Route 2: let the agent read and write Linear over MCP

Linear runs a hosted MCP (Model Context Protocol) server that gives any compatible agent structured access to your workspace: tools for finding, creating, and updating issues, projects, and comments. It uses Streamable HTTP at mcp.linear.app/mcp, authenticates with OAuth 2.1 (bearer tokens and API keys also work for headless setups), and offers a read-only endpoint (mcp.linear.app/mcp/readonly) when you want an agent that can look but not touch, as of September 2026.

# Claude Code
claude mcp add --transport http linear-server https://mcp.linear.app/mcp

# Codex CLI
codex mcp add linear --url https://mcp.linear.app/mcp

With the server connected, the agent itself becomes the integration: ask it to pull the issue and acceptance criteria before coding, post its plan as a comment, or move the issue when the PR is up. This composes with route 1 (open the issue in the tool, let the tool talk back through MCP) and with any harness, because the connection lives in the agent CLI's configuration. We keep step-by-step setup guides for Claude Code and Codex.

The tradeoff: the tracker only gets updated when the agent is told to update it, and MCP says nothing about where the agent runs, whether the session survives your laptop closing, or how a teammate could see what it is doing.

Route 3: delegate the issue to a cloud agent

Linear's agent platform treats agents as app users in the workspace. An admin installs an agent from the integrations directory and grants it team access; anyone on those teams can then delegate an issue by assigning it to the agent or @mentioning it in a comment. Delegation deliberately does not transfer ownership: the human teammate remains the assignee and stays responsible for the work. Workspaces can also set agent guidance (markdown instructions at the workspace and team level, under Settings then Agents then Additional guidance, that agents receive automatically), and on Business and Enterprise plans, triage rules can delegate incoming issues to an agent with no human in the loop at all. Agents do not consume billable Linear seats; you pay the agent vendor separately, as of September 2026.

The major coding agents all plug into this model, per their own documentation as of September 2026:

• Cursor. Delegate an issue to @Cursor or mention it in a comment and a cloud agent launches, pulling in the issue details, comments, and linked references. Status streams back to Linear in real time, and the agent opens a pull request when it finishes.
• OpenAI Codex. Mention @Codex in a comment or assign the issue to it; Codex uses the full issue context, picks the matching repository automatically, and replies on the issue with progress and results. Triage rules can auto-delegate to Codex.
• GitHub Copilot coding agent. Generally available for Linear since July 2026: assign an issue to Copilot and it works in an ephemeral environment powered by GitHub Actions, streams progress to the issue's activity timeline, and opens a draft pull request. You can pick the model, use a custom agent from your repository, set the base branch, and redirect it mid-run by mentioning it in a comment.
• Devin. Assign the issue to Devin, mention @devin, or apply a playbook label; automation triggers can start sessions based on team, label, or status.

This is the most automated route, and its costs follow from that. Execution happens in the vendor's cloud, on the vendor's terms, with the vendor's model billing. The session is not something you sit in: you find out what the agent did when the PR and status comments arrive, and steering means another round trip through comments. And a triage rule that delegates automatically will produce unreviewed diffs faster than a team reviews them; the constraint is almost never generation speed, it is review bandwidth.

Route 4: delegate the issue to Linear itself

Since June 2026, Linear is also a coding agent vendor. Delegate an issue to Linear and Linear Agent starts a coding session tied to that issue: it reads the issue and its discussion, investigates the codebase, proposes an approach, writes the code in a managed sandbox, and drafts a pull request with the diff attached to the issue. Under the hood the session runs through Claude Code or Codex, and a session target picker lets you hand an in-progress session to a different harness or environment with its conversation history intact, as of September 2026.

Coding sessions are available on Linear's Basic, Business, and Enterprise plans, require a GitHub connection with code access, and are usage-billed from a prepaid workspace-level pool of AI credits: model tokens at the provider's published rates with no markup, plus sandbox runtime billed per 20-minute block, per Linear's pricing as of September 2026. The appeal is zero integration work: the tracker, the agent, and the billing live in one product. The tradeoffs mirror route 3: execution happens in Linear's sandbox rather than on machines you control, the session lives inside the issue rather than in a terminal your team can open, and the model bill runs through a second meter (credits) instead of the AI subscriptions your engineers already pay for.

Route 5: build your own on webhooks

Linear's developer platform supports custom agents: the Agent Interaction API and SDK (a developer preview as of September 2026) deliver agent session events by webhook, and the full GraphQL API is available underneath. The simpler pattern is a webhook consumer that watches for a label or status convention and drives infrastructure you already own: create a branch, prepare an environment, notify a channel. That keeps execution wherever you want it, at the cost of building and operating the glue: webhook handling, retries, status sync in both directions, and cleanup when issues are canceled.

The routes at a glance

Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. Its Linear integration is route 5 built as a product, with one deliberate opinion: label an issue "ai-task" and a workspace appears for the team, but no agent launches until a person launches it.

The workspace the label creates is an isolated git worktree on its own branch with dependencies installed automatically, ready before anyone types a prompt. Status syncs both ways between the issue and the workspace, and workspace ownership follows the Linear assignee, so the tracker and AQ agree on whose work it is. When someone opens the workspace, they start the agent themselves: Claude Code, Codex, Cursor Agent, Kimi, Grok, or a plain shell, running as a real CLI in a persistent tmux session on the team's VM and streamed live to the browser. The session survives a closed laptop, teammates can open the same workspace and see and steer the same live session, and there is no shared multi-tenant execution tier: your agents run on your VM. Agents commit, push, and open pull requests with each user's own GitHub auth, and those PRs are tracked on the workspace. Each engineer signs into the CLIs with their own accounts, and AQ never marks up model usage, so an issue-driven agent run costs whatever your existing Claude or OpenAI subscription already covers. The step-by-step loop is written up in the Linear coding agent workflow guide, and the Linear to PR use case walks a sprint through it end to end.

Plainly: if you want fire-and-forget automation, routes 3 and 4 are built for exactly that, and the vendors above do it well. AQ is for teams that want the tracker wired to agent workspaces on their own infrastructure, with a live session anyone can inspect and a person deciding when each agent starts, so agent output stays matched to what the team can actually review. The Free plan is a personal sandbox for one person: AQ creates a private machine in an isolated network, nothing to install, no time limit. The Team plan is $50 per user per month (early access; standard $200, billed monthly) with your whole team, VMs you connect from your own cloud account, or a dedicated always-on AQ-managed VM in its own isolated network, and your rate locked for your first 12 months.