MCP Spotlight: Linear MCP Server — The Fast, Opinionated Project-Management Bridge Built on Linear's GraphQL API

Server: Linear MCP Server by Linear Transport: stdio (NPX) · Auth: Personal API Key or OAuth 2.0 API: Linear GraphQL API (the same one Linear's own UI uses) Coverage: Issues · Projects · Cycles · Teams · Initiatives · Documents · Comments · Labels · Roadmaps MCP Tracker: glama.ai/mcp/servers?query=linear Docs: linear.app/docs/mcp Changelog: linear.app/changelog

Linear has built a cult following among product engineering teams because of one thing: speed. The keyboard-first interface, the instant UI, the opinionated workflows — every interaction is designed to feel like the tool is moving at the speed of thought. The MCP server inherits that philosophy. It's a thin, focused bridge to Linear's GraphQL API that lets your agent create issues, update projects, comment on cycles, and triage backlogs at the same pace as a Linear power user.

This isn't a 100-tool generic API wrapper. It's the minimum viable surface for product workflows: find issues, create issues, update issues, comment, navigate teams and projects. The agent gets the high-leverage primitives, not the entire Linear API surface. The result is an integration that feels native to Linear — fast, opinionated, and built for the workflow the tool was designed for.

The Architecture: GraphQL Pass-Through

Linear's MCP server is built directly on the Linear GraphQL API — the same one Linear's own UI consumes. This is a significant architectural choice:

• No REST translation layer — the agent writes GraphQL or the MCP tools do the GraphQL for it
• Same schema as Linear UI — what the user sees in Linear, the agent sees through MCP
• Same data freshness — no eventual consistency, no stale cache, no sync lag
• Same permissions — Linear's existing RBAC applies; the agent acts as the API key holder

For teams that already use Linear heavily, this means: the agent behaves like a Linear power user with an API key. The mental model is "I can do in the API what I can do in the UI."

The Tool Surface

The MCP server exposes a focused set of tools for product workflows:

Tool Class	Examples	What It Does
Find	list_issues, search_issues, get_issue, get_my_issues, list_teams, list_projects, list_cycles, list_initiatives, list_roadmaps	Query Linear's workspace
Create	create_issue, create_project, create_comment, create_cycle, create_document	Add new objects
Update	update_issue (status, assignee, priority, labels, project, cycle, estimate, parent), update_project, update_comment	Modify existing objects
Subscribe	get_document, search_documents, list_users	Read team/user info, fetch Linear docs

The exact tool names vary by implementation (Linear's official server, community forks like jerhadf/linear-mcp-server, tacticlaunch/mcp-linear), but the pattern is the same: find, create, update, comment — the four primitives every product workflow needs.

The Power User Workflows

Linear's MCP server shines in the workflows where Linear is already strongest:

Issue triage at the speed of thought

"What's in the backlog for the 'API' team, sorted by priority and age?
Assign anything older than 30 days to the relevant team lead based on
labels, and add a 'needs-review' label to anything unassigned."

The agent runs list_issues for the API team, parses the backlog, applies assignment rules, updates labels, returns a summary. What used to take a 20-minute triage session takes one prompt.

Sprint planning

"Pull all issues in the current 'API' cycle that aren't started.
Group by assignee. For each unstarted issue assigned to me,
move it to 'In Progress' and add a comment that I'm picking it up."

The agent fetches the cycle, finds the unstarted issues, transitions them, comments on each. The cycle dashboard updates in real-time as the agent works.

Cross-team dependency tracking

"For each open issue in 'API' that's blocked, find the blocking issue
in other teams. Build a dependency graph and surface the bottlenecks."

Multi-team query, joined across projects, surfaced as a structured report.

Roadmap updates

"Draft a Q3 roadmap update based on what shipped in the last 30 days
and what's still in progress. Pull from the 'API' and 'Mobile' team
projects and the relevant initiatives."

The agent reads recent issue activity, drafts the update as a Linear document, and surfaces it for review.

Customer feedback → issue

"This Slack thread has 5 feature requests from enterprise customers.
For each one, create an issue in the relevant team project with the
right priority and link the source thread."

Parse the conversation, classify each request, create 5 issues with the right fields.

OAuth 2.0 and Personal API Keys

Linear's MCP server supports two auth modes:

Personal API Key (recommended for individuals)

# Get a key from https://linear.app/settings/api
{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": {
        "LINEAR_API_KEY": "${credentials.LINEAR_API_KEY}"
      }
    }
  }
}

Simple, scoped to the user, scoped to the workspaces the user has access to.

OAuth 2.0 (for multi-tenant SaaS agents)

For SaaS products integrating Linear on behalf of their users, OAuth 2.0 lets the user authorize a specific scope (read-only, read+write, full access) without sharing their API key. Linear's OAuth flow is standard — the user clicks "Authorize", the SaaS gets a refresh token, the SaaS acts on behalf of the user.

The OAuth scope (read, write, issues:create, etc.) controls what the MCP server can do. Combined with Facio's destructive-operation gating, this creates the same defense-in-depth model as the other platform MCP servers.

Linear's Opinionated Workflows Come Through MCP

Linear has strong opinions about how product work should flow:

• Cycles replace sprints — fixed-length planning periods with auto-rollover
• Projects group related issues toward a shared outcome
• Initiatives group projects across teams toward a company goal
• Triage is a special state — issues that need review before estimation
• Roadmaps show planned vs. in-progress vs. completed work

The MCP server exposes all of these. The agent can:

• Move issues through the standard Linear status flow (Backlog → Triage → Todo → In Progress → In Review → Done)
• Add issues to the current cycle, assign them, set priority, attach labels
• Group issues into projects, link projects to initiatives
• Read roadmap data, draft roadmap updates
• Comment on issues with Markdown formatting

The opinionated workflows are Linear's product moat. The MCP server lets the agent participate in them without learning a custom command language — the GraphQL pass-through means what works in Linear's UI works in the MCP.

Facio Integration

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": {
        "LINEAR_API_KEY": "${credentials.LINEAR_API_KEY}"
      }
    }
  }
}

Facio's audit trail captures every Linear MCP call: which team, which project, which issue, what action, what fields changed, what comment was added. For a regulated product team (healthcare, fintech, defense), this is the complete record: "Agent created issue API-1234 at 14:32 UTC, assigned to alice@centerbit.co, priority High, project 'Q3 Auth Redesign'."

For HITL workflows, the tool annotations map to gate requirements:

Tool Class	Severity	Suggested Gate
list_*, get_*, search_*	Read	None — autonomous
create_comment, update_comment	Write, low risk	Soft confirm
create_issue, create_project	Write, contextual	Soft confirm (review the title and body)
update_issue (status, assignee)	Write, contextual	Soft confirm for status transitions on critical issues
update_issue (delete)	Write, destructive	Hard confirm (rare in Linear)
archive_project, archive_team	Write, destructive	Hard confirm

The update_issue tool with status transitions deserves special attention. Linear's whole value prop is the smooth status flow, and the agent moving issues through it is one of the highest-leverage automations. Facio can be configured to allow autonomous status transitions for issues assigned to the agent itself (the agent is doing its own work), and to require soft confirmation for transitions on issues assigned to other humans (the agent is influencing other people's work).

For teams with multiple Linear workspaces (separate workspace per product line, per customer, per region), the pattern is one MCP server per workspace, each with its own API key. The agent switches context per workspace, the audit trail is per-workspace, and the HITL gating is per-workspace.

Quickstart

# 1. Get a Linear API key
#    https://linear.app/settings/api

# 2. Install the MCP server
npm install -g @linear/mcp-server

# 3. Configure your MCP client
{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": {
        "LINEAR_API_KEY": "lin_api_..."
      }
    }
  }
}

# 4. First prompts
# "What's in my team's backlog for this cycle? Group by priority and assignee."
# "Create a bug ticket for the OAuth flow breaking on Safari, assign to the Mobile team, priority High"
# "Pull all issues I closed this week and draft a Friday update for the team channel"
# "Move all my 'In Review' PRs to 'Done' that have been merged in the last 24 hours"
# "What initiatives are at risk this quarter based on the project status updates?"

Use Cases

Daily standup synthesis: "For each team member, what did they close yesterday, what's in progress today, and what are they blocked on?" Pulls issues by assignee, drafts the standup.

Weekly executive summary: "Summarize what shipped this week across all teams. Group by initiative. Include customer-impacting changes." Pulls closed issues, links to projects, drafts the executive update.

Triage queue management: "Look at the triage queue. For each unassigned issue, suggest the right assignee based on the issue's labels and component, then assign it. Add a triage comment explaining the assignment."

Sprint health checks: "For each active cycle, what's the burndown rate? Which cycles are at risk of not completing their planned work?" Pulls cycle data, calculates burndown, surfaces the at-risk cycles.

Cross-project dependency tracking: "Find all issues in the 'API' and 'Mobile' projects that reference each other. Build the dependency graph and surface the bottlenecks."

Customer feedback → issues: "Read this Zendesk ticket thread. For each feature request, create a Linear issue in the right team project with the right priority and label."

Quarterly planning prep: "For each initiative we own, what's the current state? List the projects, the cycles, and the key milestones. Draft a Q3 readiness report."

Post-mortem workflow: "An incident happened in 'api-gateway' yesterday. Find all related issues, the Slack thread, the runbook, and the on-call. Draft a post-mortem document in Linear."

Roadmap presentations: "Pull all projects grouped by initiative. For each, what's the status, the target date, and the key milestones? Generate a roadmap slide outline."

Linear docs as agent memory: "Read our team's 'Engineering Practices' document in Linear. Summarize the key points and apply them to my next code review." Cross-document synthesis for agent context.

Bottom Line

Linear's MCP server is the fast, opinionated, GraphQL-native bridge that brings Linear's keyboard-first philosophy to AI agents. Focused tool surface, opinionated workflows, GraphQL pass-through, OAuth 2.0, and a developer experience that feels like Linear itself.

For product engineering teams using Linear, this is the missing layer that turns "agent helps with product work" from a fragile Zapier integration into a real conversational surface. The agent creates issues, transitions them through cycles, drafts roadmap updates, and writes documents — at the same pace as a Linear power user.

For the broader MCP ecosystem, the Linear pattern is the design lesson every "opinionated tool" MCP server should study. Don't try to expose the entire API. Expose the core workflow primitives — find, create, update, comment — and let the agent compose them. The opinionated workflows of the host tool are the value; the MCP server's job is to let the agent participate in them.

npx -y @linear/mcp-server and your agent has Linear.

---

MCP Spotlight is a series covering servers that give AI agents real capabilities. Every server is evaluated for design focus, ecosystem fit, and integration fit with Facio's HITL-first agent runtime.