Linear

Linear's official MCP server connects AI agents directly to your Linear workspace through the Model Context Protocol. Agents can list and filter issues, create new tickets, update statuses, post comments, query projects and cycles, and navigate the full issue graph, all authenticated with a single Linear API key. It is the cleanest project-management bridge available for agents running inside Claude Code, Devin, Cursor, or any other MCP-compatible client.

Most project management integrations for AI agents are afterthoughts. A webhook here, a Zapier connection there, maybe a fragile script that polls an API and appends to a context file. Linear's MCP server is not that. It is a first-party, hosted, GraphQL-backed bridge that gives agents the same access to your Linear workspace that a team member has. The difference in quality shows immediately.

Quick verdict

If your team uses Linear and you run AI agents in any MCP-compatible client, this is one of the first servers you should configure. The hosted endpoint, the quality of the underlying API, and the breadth of available tools combine to make Linear MCP the best project-management bridge available today. It is not perfect, and it has real alternatives worth knowing about. But for ticket-driven AI workflows, nothing else is close.

What the Linear MCP server actually does

The server exposes Linear's core data model to agents as callable tools. An agent can list issues, filter them by team, status, priority, or label, and read their full content including description and comments. It can create new issues with complete metadata and update existing ones. It can add comments. It can query the project and cycle structure to understand how work is organized. And it can navigate between related issues through the issue graph.

The hosted endpoint at mcp.linear.app/mcp means agents connect over HTTP rather than requiring a local process. Linear switched from the older SSE transport (/sse) to the streamable HTTP transport in February 2026, which improved reliability for long-running agent sessions. The endpoint handles authentication through the Authorization header, either with a Bearer token from a Personal API key or through OAuth.

The practical effect is that an agent working inside Claude Code or Devin can read a ticket, understand the requirements, write the implementation, update the ticket status when done, and add a comment linking to the PR, all without leaving the agent session. That loop, which used to require constant human interruption to handle the ticket side, runs without breaking focus.

Why Linear's API makes this work better than alternatives

The quality of an MCP server is largely a function of the quality of the API it wraps. Linear's GraphQL API is one of the better-designed APIs in the project management space. The schema is well-typed, responses are fast, and the data model is consistent across the full surface area (issues, projects, cycles, teams, users). Linear built the API for developers from the beginning, and that shows in everything from the TypeScript SDK to the rate limit handling.

Compare that to the situation with Jira. Jira's REST API reflects twenty years of accumulation. It is inconsistent across resource types, pagination is non-trivial, field schemas vary between Jira Cloud and Jira Server, and custom fields (which most real Jira instances use extensively) add another layer of variance that MCP implementations have to handle case by case. None of the Jira MCP servers available as of May 2026 are official. All of them are partial implementations with known gaps.

GitHub Issues MCP is a legitimate comparison. GitHub's API quality is high, the official MCP server is well-maintained, and GitHub Issues works well for development-centric teams that track work directly in repos. The difference is product focus. GitHub Issues is lightweight by design. Linear has proper priority levels, cycle tracking, project hierarchies, initiative management, and team-level workflows that reflect how engineering teams actually organize work at scale. For teams that have outgrown GitHub Issues, the feature depth matters.

Ticket-driven workflows in practice

The phrase "ticket-driven workflow" covers a specific pattern that has become common with autonomous agents. Instead of a human writing a full specification and handing it to an agent, the agent reads an existing ticket in Linear, interprets the requirements, executes the work, and reports back through the same ticket. The Linear MCP server supports every step of that loop.

Devin documented this pattern early. Devin can be pointed at a Linear workspace, assigned a ticket, and will complete the task while keeping the ticket status current throughout. When it finishes, the ticket reflects the actual work done and links to the output. The Linear MCP server is what makes that possible without custom integration work.

The same pattern works in Claude Code. An engineer opens a terminal, asks Claude Code to pick up the highest-priority open ticket in a given project, and Claude Code queries Linear through MCP, reads the requirements, writes the code, runs the tests, updates the ticket status, and leaves a comment describing what it did. The full cycle from assignment to completion runs without the engineer managing the handoffs manually.

For autonomous agents where the human is reviewing output rather than orchestrating each step, having the agent maintain accurate ticket state is what makes the workflow auditable. The history of what the agent did and decided lives in Linear alongside the ticket, not in a separate log file that gets lost.

Setup

The hosted path is the fastest. No installation required. In your MCP client config, add a server entry pointing at https://mcp.linear.app/mcp and include your Linear Personal API key as the Authorization header value. The key lives under Linear > Settings > API > Personal API keys and takes about thirty seconds to generate.

For Claude Code specifically, the config entry looks like this:

{
  "mcpServers": {
    "linear": {
      "url": "https://mcp.linear.app/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_LINEAR_API_KEY"
      }
    }
  }
}

For workspace-level access where multiple team members need agents to operate under their individual identities, OAuth is the cleaner path. Linear's OAuth flow issues tokens scoped to the authorizing user, so agent actions appear in Linear's audit trail attributed to the right person rather than to a shared service account. The OAuth setup requires registering an OAuth app in Linear's developer settings and handling the callback flow, which takes longer but is worth it for teams.

The self-hosted option is available through the open-source repository at github.com/linear/linear-mcp for teams that need data to stay on-premises or want to customize the tool set. Self-hosting adds an operational burden that the hosted endpoint doesn't. Most teams have no reason to take that route.

What agents can and cannot do

The tools available through Linear MCP as of May 2026 cover most of what a development team needs from a project management perspective:

Reading: list teams, list projects, list cycles, query issues with filters (status, priority, label, assignee, team, project, cycle), read a specific issue by ID, read issue comments, list users.

Writing: create issues, update issue fields (status, priority, assignee, labels, title, description), add comments.

What is missing: file attachments, custom field writes (reads are available but writes are limited), webhook management, and the full Linear initiatives layer. None of these gaps affect the core ticket-driven workflow, but teams that rely heavily on custom fields for their process should test that their specific fields are accessible before committing to agent workflows.

The February 2026 update added project milestone management and initiative creation through MCP, which expanded the server beyond pure issue tracking into higher-level planning. That update also added Linear resource loading via URL, which means an agent can receive a Linear issue URL and resolve it directly to structured data rather than requiring an issue ID.

Who Linear MCP is built for

The primary audience is engineering teams using Linear who are adding AI agents to their development workflow. If you already use Linear and you run Claude Code, Devin, Cursor, or a similar agent in your development setup, adding the Linear MCP server is a low-effort change with a real payoff. The agent gains context about what is prioritized, can update ticket state without human intervention, and produces work that connects back to the planning artifact that justified it.

Teams evaluating whether to move from Jira or GitHub Issues to Linear for agent compatibility have a legitimate reason to weight Linear more favorably. The difference in MCP server quality reflects a real difference in API design philosophy.

Smaller teams that track work in GitHub Issues and find that sufficient for their process should look at the GitHub MCP server first. The Linear MCP server solves a different tier of project management complexity. If your current tooling works and the team is not hitting its limits, the switch to Linear for MCP compatibility alone is not justified.

Linear MCP vs. alternatives

Jira MCP: No official server exists. Community implementations cover the main resources but are inconsistently maintained and vary in which Jira API versions they support. For teams that cannot leave Jira, a community server may be sufficient for read-heavy workflows. For write operations, gaps in schema handling cause failures that require debugging at the integration level rather than the agent level. If the choice is open, Linear MCP is more reliable.

GitHub Issues MCP: The GitHub MCP server is official, well-maintained, and covers Issues as part of a broader GitHub integration that includes PRs, code search, and repository management. For teams tracking work directly in GitHub repos, it is the better choice precisely because it covers more than just issues. Linear MCP is better when you want a dedicated project management layer with priority, cycles, and project organization that GitHub Issues does not provide.

Notion MCP: Notion is a general-purpose knowledge tool that can be configured as a project tracker, but the data model is flexible enough to be inconsistent across workspaces. A Notion MCP server that works for one team's setup may not work for another's. Linear's opinionated data model makes MCP integration more predictable.

For teams building agent workflows on top of a coding agent and want to see how Linear MCP fits the broader picture, the best AI agent for coding guide covers the full stack.

The bottom line

Linear MCP is the project-management MCP server to use if you have the choice. The hosted endpoint removes operational overhead. The GraphQL API quality makes tools reliable rather than brittle. The write capabilities close the loop on ticket-driven workflows without requiring agents to hand off to a human every time a status needs updating.

The limitations are real but narrow. Custom field writes are incomplete. Attachment support is absent. These are edge cases for most teams. The core issue lifecycle, including reading requirements, creating tickets, updating status, and adding comments, works cleanly and is what agent workflows actually need.

If your team is on Linear and running MCP-compatible agents, this is worth configuring today. It takes five minutes to set up and changes how agents interact with your planning process in a way that makes the whole workflow more auditable and less dependent on manual coordination.

Features

• List, search, and filter issues across teams and projects
• Create issues with full metadata (title, description, priority, labels, assignee)
• Update issue status, priority, and assignee in place
• Add comments to existing issues
• Query projects, initiatives, and cycles
• OAuth 2.0 and Personal API key authentication
• Hosted MCP endpoint at mcp.linear.app (no local server required)

How to set up the Linear MCP server

1. Generate a Personal API key in Linear under Settings > API
2. Add the server to your MCP client config pointing at https://mcp.linear.app/mcp with your API key as the Authorization header
3. Alternatively, use OAuth by following Linear's OAuth app flow for workspace-level access
4. Restart your MCP client and the Linear tools appear immediately