MCP Spotlight: Linear MCP Server — The Official Issue-Tracking Bridge With Initiatives, Project Milestones, Code Intelligence, and the Engineering-Workflow Default for Agents
Server: Linear MCP Server by Linear License: MIT (open source SDK) · Tools: ~40 (issues, projects, cycles, initiatives, milestones, comments, customers, attachments) Coverage: Teams · Issues · Projects · Cycles · Initiatives · Project Milestones · Updates · Comments · Customers · Attachments · Search Transport: stdio (NPX) · Auth: Personal API Key, OAuth 2.0 Companion: Linear Agent + Code Intelligence (Linear's own agent layer) Docs: linear.app/docs/mcp · developers.linear.app MCP Tracker: glama.ai/mcp/servers/linear
Every software team tracks work somewhere. Linear is the issue-tracking system of choice for thousands of high-performance engineering teams — the one Vercel, Cursor, Replit, Ramp, and other category leaders use for project management. Every meaningful agent workflow that touches engineering work — issue triage, sprint planning, project updates, status reports, customer-feedback routing — eventually needs Linear.
The naive "wrap Linear's GraphQL API as 200+ MCP tools" approach bloats the context window past usability. The "give the agent raw GraphQL" approach dumps the entire schema on the model. The "ship a generic curl wrapper" approach forces the agent to guess field names.
The official Linear MCP Server is the bridge that resolves this. ~40 focused tools covering the full engineering-workflow surface — issues, projects, cycles, initiatives, project milestones, updates, comments, customers — with the new Initiatives + Project Milestones addition (February 2026) bringing Linear's project-management story to parity with Linear's web app. MIT-licensed, official Linear-maintained. Built on Linear's GraphQL API — the same one Linear's own UI uses.
This is the issue-tracking + project-management default for engineering agents in 2026.
The Architecture: Engineering-Workflow Tools
The Linear MCP Server's tool surface is organized around how engineering teams actually track work:
| Category | Tools | Purpose |
|---|---|---|
| Issues | ~15 tools: list, get, create, update, delete, archive, assign, subscribe, link, add_label | Issue lifecycle |
| Projects | ~8 tools: list, get, create, update, delete, add_member, add_team | Project lifecycle |
| Cycles | ~5 tools: list, get, create, update, add_issue | Sprint / cycle management |
| Initiatives | ~3 tools: list, get, create, update | Cross-project strategic themes |
| Project Milestones | ~3 tools: list, get, create, update | Project timeline markers |
| Updates | ~3 tools: create_project_update, list_project_updates, get_project_update | Standup-style status reports |
| Comments | ~3 tools: list, create, update | Conversation on issues/projects |
| Customers | ~2 tools: list, get | Customer-feedback-to-issue linking |
| Search | ~2 tools: search_issues, search_projects | Full-text discovery |
| Teams & Users | ~3 tools: list_teams, get_user, list_users | Workspace navigation |
The tool surface is focused. The agent gets the high-leverage primitives — issues, projects, cycles, initiatives, milestones — and composes them into engineering workflows.
The Killer Feature: Initiatives + Project Milestones (Feb 2026)
The February 2026 release of the Linear MCP server added Initiatives and Project Milestones — the two pieces that bring Linear's MCP surface to parity with Linear's web app.
Initiatives: Strategic themes across projects
User: "Show me everything related to our Q3 'Enterprise Readiness' initiative."
Agent:
1. list_initiatives(filter="name contains 'Enterprise Readiness'")
→ Returns the initiative
2. list_projects(filter="initiativeId = abc123")
→ Returns all projects under that initiative
3. For each project, list_project_milestones
→ Returns the milestones with target dates
4. For each milestone, list_issues(filter="milestoneId = ...")
→ Returns the issues tagged to the milestone
5. Returns a complete cross-project view
Initiatives are the strategic layer — they group related projects under a common theme. For a CTO or VP of Engineering tracking "Q3 Enterprise Readiness" across multiple projects (Auth rework, SOC2 audit, multi-region deployment, RBAC), Initiatives provide the rollup view.
The MCP surface exposes this directly: the agent navigates from initiative → projects → milestones → issues. The full strategic hierarchy is one tree in the agent's mental model.
Project Milestones: Timeline markers within projects
create_project_milestone(
project_id="proj_123",
name="Auth migration complete",
target_date="2026-09-30",
description="All customers migrated to new auth flow"
)
→ Returns the milestone
Milestones are the tactical layer — concrete timeline markers within a single project. For agents managing project status ("are we on track to launch in Q3?"), milestones are the data points.
The combination — Initiatives above Projects, Milestones within Projects, Issues within Milestones — gives the agent a four-level hierarchy to navigate. Linear's model is the cleanest project-management hierarchy in the industry; the MCP server exposes it cleanly.
The Issue Lifecycle: The Core Use Case
Issues are the heartbeat of engineering work. The MCP server exposes the full lifecycle:
User: "Triage this week's new issues and create Linear tickets for each."
Agent:
1. list_issues(filter="createdAt > 7 days ago, state = 'Triage'")
→ Returns 12 new issues
2. For each issue:
a. get_issue(id) → full context, comments, related PRs
b. analyze the content (sequential-thinking MCP)
c. update_issue(id, state="In Progress", assignee="...",
priority="...", estimate="...")
3. Returns the triage report
For issue creation:
create_issue(
team_id="team_abc",
title="Add 2FA to all user accounts",
description="...",
priority=1, // Urgent
label_ids=["security", "compliance"],
estimate=5,
cycle_id="cycle_q3_w3"
)
→ Returns the created issue with ID
The agent can also link issues:
link_issues(issue_id="issue_1", related_issue_id="issue_2", type="blocks")
→ Returns the link
For PR-issue linking, the GitHub MCP server can sync GitHub PRs to Linear issues (via Linear's existing GitHub integration). The two MCP servers compose: GitHub for code, Linear for tracking, with bidirectional linking.
Projects + Cycles: Sprint Management
For sprint / cycle management:
User: "Plan our next cycle: assign these 8 issues to it, balanced across the team."
Agent:
1. create_cycle(name="Cycle 23", team_id="team_abc",
starts_at="2026-07-15", ends_at="2026-07-29")
2. For each of the 8 issues:
update_issue(issue_id, cycle_id="cycle_23")
3. For each team member, count issues assigned
4. If unbalanced, reassign
5. Returns the cycle plan
For project updates (Linear's "standup on a page"):
create_project_update(
project_id="proj_123",
body="Auth migration is on track. 4 of 6 milestones complete. Next: SSO provider rollout.",
health="onTrack" // onTrack, atRisk, offTrack
)
→ Posts the update visible to stakeholders
Project updates are the executive-summary layer. The agent can draft them from the data: read the issues, read the milestones, summarize the progress, post the update. What used to take a project manager 30 minutes takes the agent 30 seconds.
Customers + Customer-Feedback Routing
Linear's Customer Requests feature links external customer feedback to internal issues. The MCP server exposes this:
list_customers(filter="name contains 'Acme'")
→ Returns customer records
create_customer_issue(
customer_id="cust_abc",
title="Acme needs bulk export to CSV",
description="Reported via support ticket #1234",
priority=2,
area="product"
)
→ Creates an issue linked to the customer
For product teams that collect feedback across many channels (support tickets, sales calls, emails, Slack), the agent can:
- Read the feedback from each channel (via the relevant MCP server)
- Group by feature area
- Create or link Linear issues
- Tag with the requesting customer
- Surface the most-requested items
The agent is the feedback aggregation layer between customer channels and engineering work.
The Search Tools
For finding the right issue / project in a large workspace:
search_issues(
query="payment",
filter="state = 'In Progress', priority <= 2"
)
→ Returns matching issues, sorted by relevance
Linear's search is fast, full-text, and respects the user's permissions. The agent can search for "anything related to payment" and find the relevant issues across all the teams the user has access to.
Facio Integration
{
"mcpServers": {
"linear": {
"command": "npx",
"args": ["-y", "@linear/mcp"],
"env": {
"LINEAR_API_KEY": "${credentials.LINEAR_API_KEY}"
}
}
}
}
Facio's audit trail captures every Linear MCP call with the tool, the action, the issue/project ID, the parameters, and the result. For a regulated team (SOC2, ISO 27001), this is the complete engineering-workflow record: "Agent at 14:32 UTC created issue 'ENG-1234' in team 'API', assigned to Alice, priority 2, cycle 'Cycle 23'."
For HITL workflows, the tool annotations map to gate requirements:
| Tool | Severity | Suggested Gate |
|---|---|---|
list_*, get_*, search_* | Read | None — autonomous |
create_comment, add_label | Write, low risk | Soft confirm |
create_issue (in Triage state) | Write, contextual | Soft confirm |
update_issue (assignee, priority, state) | Write, contextual | Soft confirm |
create_project, create_initiative | Write, structural | Hard confirm |
delete_issue, delete_project, delete_initiative | Write, destructive | Hard confirm + reason required |
create_project_update (visible to stakeholders) | Write, contextual | Hard confirm (broadcast update) |
link_issues, unlink_issues | Write, contextual | Soft confirm |
The delete_issue and delete_project tools deserve special attention — they're destructive, they're reversible in the UI (Linear keeps a soft-delete archive), but in agent-driven workflows they should require explicit confirmation.
For multi-workspace setups (one Linear workspace per team, per product, per customer), the pattern is one MCP server per workspace with its own API key. The agent switches context per workspace, the audit trail is per-workspace, the HITL gating is per-workspace.
For OAuth 2.0 (recommended for SaaS-embedded agents), the user authorizes the agent to act on their Linear account. The same defense-in-depth model as the other platforms applies.
Quickstart
# 1. Get a Linear API key
# https://linear.app/settings/api
# 2. Install the MCP server
npm install -g @linear/mcp
# 3. Configure your MCP client
{
"mcpServers": {
"linear": {
"command": "npx",
"args": ["-y", "@linear/mcp"],
"env": {
"LINEAR_API_KEY": "lin_api_..."
}
}
}
}
# 4. First prompts
# "Show me all open issues assigned to me, sorted by priority"
# "Create an issue in team 'API': 'Add rate limiting to /api/auth', priority 2"
# "Plan the next cycle: assign these 8 issues, balanced across the team"
# "Generate a project update for our 'Auth Migration' project"
# "Show me everything related to our 'Enterprise Readiness' initiative"
Use Cases
Sprint planning: "Plan our next cycle. Take the top 12 unassigned issues, balance across the team based on capacity, and assign them to the cycle." Issue prioritization + cycle assignment + load balancing.
Standup automation: "Generate our daily standup. For each team member, summarize what they completed yesterday and what's in progress today." Cross-user aggregation → structured standup.
Triage automation: "Triage the new issues from the last 7 days. Categorize by area, assign priority, suggest assignees based on code ownership." Multi-issue batch processing.
Status reports: "Generate a weekly status report for our 'Auth Migration' project. Include progress, blockers, and next steps." Project update generation.
Customer feedback routing: "Take the customer feedback from Intercom this week, group by feature area, and create Linear issues for each top-requested item." Multi-source aggregation + Linear issue creation.
Release coordination: "For each milestone in our 'v2.0' project, list the open issues and their status. Flag anything that's overdue." Milestone → issue rollup with status checks.
Cross-project reporting: "Show me the progress across all projects under our 'Enterprise Readiness' initiative." Initiative → projects → milestones → issues rollup.
Code-PR linking: "For each open Linear issue in 'In Progress' state, check if there's a linked GitHub PR and report the status." Linear ↔ GitHub cross-tool correlation.
Issue cleanup: "Find all issues in 'Backlog' state with no activity in 90 days. Suggest archiving them." Stale-issue detection.
Roadmap drafting: "Based on the top 20 customer feature requests this quarter, draft a roadmap with prioritization and rough estimates." Cross-source synthesis → structured roadmap.
Cycle retrospective: "For the just-completed cycle, analyze: what got done, what slipped, what surprised us. Generate a retrospective doc." Cycle → issue analysis → retrospective.
Team load balancing: "Show me the issue load per team member. Identify anyone with >2x the average load, and propose rebalancing." Cross-user load analysis.
Initiative tracking: "Update the 'Enterprise Readiness' initiative with this week's progress: 4 milestones complete, 2 in progress, 1 blocked." Initiative status update.
Customer support linking: "Link the support ticket #1234 to the Linear issue ENG-567 for the customer 'Acme'." Cross-tool issue linking.
Sprint health checks: "Daily during the cycle, check the burndown. Flag if we're behind pace." Cycle health monitoring.
Bug triage: "When a new Sentry issue comes in with severity high, create a Linear issue in team 'API', assign to on-call, priority 1, linked back to Sentry." Sentry → Linear automation.
Onboarding docs: "Generate an onboarding doc from our recent 'Engineering Practices' issues and projects." Linear → documentation generation.
Quarterly review: "For the past quarter, summarize: completed issues, cycle velocity, top contributors, blocked items." Quarterly aggregation.
Cross-team coordination: "For each team's active cycles, list the issues that depend on another team's work." Cross-team dependency analysis.
The Engineering-Workflow Default
The Linear MCP Server is the issue-tracking + project-management default for engineering agents in 2026. ~40 focused tools, full Initiative + Milestone support (Feb 2026), MIT-licensed, official Linear-maintained, OAuth 2.0 + Personal API Key support.
For any agent that participates in engineering work — sprint planning, triage, status reporting, customer feedback routing, release coordination — this is the bridge. The agent reads issues, creates new ones, updates state, plans cycles, posts project updates, links to customer requests. All through Linear's clean model, all with the team's existing permissions.
For the broader MCP ecosystem, the Linear pattern is the design lesson every "workflow-tracking" MCP server should copy. The right primitive for an engineering team is the primitive the team already uses. Linear's hierarchy — Initiatives → Projects → Milestones → Cycles → Issues — is the mental model engineering teams have built. The MCP surface mirrors it exactly.
npx -y @linear/mcp with LINEAR_API_KEY=lin_api_... and your agent has Linear.
MCP Spotlight is a series covering servers that give AI agents real capabilities. Every server is evaluated for design clarity, ecosystem impact, and integration fit with Facio's HITL-first agent runtime.