You're building a feature. Your AI coding tool needs to know the feature’s requirements and scope, so you copy-paste everything from your project management platform, like Jira, Linear, or GitHub Projects. Later, you switch back to that platform to update the issue status. Then back to your editor. Then back to the issue to check dependencies. Then back to your editor. Sound familiar?
The Model Context Protocol (MCP) offers a solution to this context-switching problem. MCP is an open standard that lets AI tools connect directly to your other applications and services.
Think of it this way: instead of manually feeding context to your AI agent, an MCP bridges the AI with a specific external tool. Now your AI agent can communicate directly with that resource’s API.
Today, official MCP servers are available for popular tools like Figma, Linear, Supabase, and more.
The Linear MCP is the official MCP server for Linear's project management platform. It gives AI tools direct access to your Linear workspace data, such as issues, projects, teams, comments, and workflow states. In the video above, Fusion uses the Linear MCP to grab the requirements for a new feature, build it, and then update the Linear issue with the completed status.
You can ask the Linear MCP things like "What issues are assigned to me this sprint?" or "Show me blocked tickets in the frontend project," and get live data back. The Linear MCP can also write data. Your AI agent can now create issues, update statuses, and add comments on your behalf.
The Linear team built this server specifically to bridge the gap between project management and AI-powered development. Instead of treating Linear as a separate tool you check occasionally, it becomes part of your AI's working context.
The Linear MCP fixes several time-wasting patterns that slow down development teams:
Copy-paste friction adds up. Need to reference an issue number? Copy it. Are the requirements unclear? Paste the acceptance criteria. Want to update the status? More switching. Every manual transfer is a small tax on your productivity.
Context switching kills momentum. You're deep in code, hit a blocker, and need to check Linear for details. Tab switch, log in, navigate, find the issue, read comments, switch back. Your flow is broken, and you've lost 2-3 minutes of mental context.
Stale information leads to wrong decisions. You tell your AI about a bug fix from last week, not knowing someone already resolved it this morning. Or you're working on a feature that got deprioritized yesterday. Without live data, you're operating on outdated assumptions.
The Linear MCP turns these friction points into non-issues. Your AI tool becomes project-aware by default.
The installation process varies by platform, but the core concept is the same: you're connecting to Linear's official remote MCP server at https://mcp.linear.app/sse.
Fusion includes the Linear MCP, so it works out of the box.
- Navigate to the
MCP serverstab in Fusion - Press the
Connectbutton inside the Linear tile and authorize access to your workspace.
- Open Claude Desktop settings
- Navigate to the
Connectorstab - Select Linear from the available connectors
- Follow the authentication prompts to connect your Linear workspace
For detailed setup instructions, see Linear's official MCP server documentation.
Cursor offers multiple setup methods. The quickest way is to select Linear from their list of trusted MCP servers.
You can also add the configuration manually:
- Press
Ctrl/Cmd + Shift + Pto open the command palette - Type "Open MCP Settings" and select it
- Enter the Linear server configuration into the file:
{
"mcpServers": {
"Linear": {
"url": "<https://mcp.linear.app/sse>"
}
}
}Refer to Cursor's MCP documentation and Linear's Cursor integration guide for complete setup instructions.
VS Code 1.102+ includes native MCP support with several installation options:
- Direct installation: Visit the curated MCP server list and press
Installto automatically add servers - Workspace settings: Add
.vscode/mcp.jsonto share configurations with your team - User settings: Configure globally via
MCP: Open User Configuration - Automatic discovery: Enable autodiscovery to detect MCP servers from other tools.
Use this configuration format in .vscode/mcp.json:
{
"context_servers": {
"linear": {
"command": {
"path": "npx",
"args": ["-y", "mcp-remote", "<https://mcp.linear.app/sse>"],
"env": {}
},
"settings": {}
}
}
}You can view installed servers using the MCP: Show Installed Servers command. See VS Code's MCP documentation for details.
The Linear MCP server uses OAuth authentication, which requires no API key management or environment variables. When you first use the connection, the authentication happens through your browser.
Once authentication completes, test the connection with some basic Linear queries. Here are a few:
- "Show me my assigned issues in Linear"
- "What issues are in progress in our current sprint?"
- "List all open bugs in the frontend project"
Expected Response:
If the integration works, your AI tool will return real data from your Linear workspace. You should see actual issue titles, assignees, statuses, and project information.
What You Get Access To:
The Linear MCP server can perform all sorts of actions. Here are some common tasks and related prompts:
- Issue search and filtering. "Find and summarize issues with the label
frontendthat haven't been updated in the last week." - Issue creation and updates. "Create a new issue for the login bug. Give it high priority and assign it to the backend team." "Move this issue to
In Reviewand add the labelneeds-testing." - Status and label management. "Change all issues in the
Ready for QAcolumn toIn Testingstatus." "Add theurgentlabel to allP0issues in the mobile project." - Documentation access. "Pull up the project requirements document for the new checkout flow."
- Sprint and project queries. "What issues are planned for the current sprint?" "Show me the progress on the Q4 roadmap project and which issues are at risk."
Fusion takes a unique approach to the Linear MCP. Instead of treating Linear as a separate data source, Fusion integrates project management directly into visual development workflows.
What works well: Easiest to set up and includes a visual development platform that other AI solutions can't match. While Claude Desktop, Cursor, and VS Code generate code, Fusion's visual editor also lets you see and modify UI components in real-time as the AI builds them. Their no-code layer unlocks development for PMs and designers.
With Fusion, you can share a Linear ticket URL and watch the AI: write code to resolve the issue, ship a PR to GitHub with a fix, and then update the Linear ticket. You can also visually edit, style, and refine your UIs along the way; no switching between code and preview modes.
The editor understands your design system and lets you drag, drop, and modify components while maintaining clean code output. Business context from Linear flows directly into visual development decisions, creating a smooth workflow from project requirements to pixel-perfect interfaces to production deployment.
Limitations: No desktop client (yet), although there is a strong VS Code extension. Fusion’s visual development platform won’t work with non-JS web frameworks like Django or Rails (yet).
Claude Desktop offers a straightforward Linear MCP experience. Once configured, you can ask natural language questions about your Linear data and get immediate responses.
What works well: Direct conversation flow, complex queries across multiple projects, and detailed issue analysis. Claude excels at understanding context from your Linear workspace and providing thoughtful responses about project status and priorities.
Limitations: Claude Desktop is primarily a chat interface. While great for project insights and planning, it doesn't integrate with your actual development environment or provide visual project management capabilities.
Cursor brings the Linear MCP directly into your code editor, creating a more integrated development experience.
What works well: Inline Linear queries while coding, automatic issue reference in commits, and project-aware code suggestions. You can ask about blocking issues while looking at the actual code that needs changes.
Limitations: Cursor focuses on code generation and editing, so linear integration feels more like a helpful sidebar than a core workflow component. It is limited mainly to developers.
Windsurf positions itself as the first AI agent-powered IDE, and its Linear MCP integration reflects that philosophy. For complete setup instructions, see Linear's Windsurf integration documentation.
What works well: Windsurf treats the Linear MCP as part of its agent workflow. The AI can autonomously check linear issues, understand project context, and make development decisions based on current sprint priorities, creating a more proactive development experience.
Limitations: Still primarily code-focused. While Windsurf can understand Linear context better than traditional editors, it doesn't provide visual project management or team collaboration features beyond what Linear already offers.
VS Code's approach to Linear MCP varies depending on which AI extension you're using. The experience ranges from basic chat integration to more sophisticated workflow automation.
What works well: Familiar VS Code environment with your existing extensions and workflows. Linear MCP becomes another tool in your development toolkit rather than requiring a new platform.
Limitations: Fragmented experience across different AI extensions. Setup complexity increases when coordinating multiple extensions, and the Linear integration quality depends heavily on which AI extension you choose.
Try Fusion's Linear MCP integration to see how project management and visual development work together, or stick with your current AI platform and add Linear context to your existing workflow.
The context-switching days are over. The question now is how deeply you want to integrate your project management and development processes.
Frequently Asked Questions About the Linear MCP Server
What is the Linear MCP server?
The Linear MCP server is Linear's official Model Context Protocol integration that gives AI coding tools direct, live access to your Linear workspace. Instead of manually copying issue details into your AI tool, the MCP lets the AI query your Linear data directly — reading issues, projects, team assignments, sprint status, and comments, and writing back updates like status changes, new issues, and comments. It connects to Linear's remote server at https://mcp.linear.app/sse.
What problem does the Linear MCP server solve for developers?
Three compounding friction points: copy-paste overhead from manually transferring issue context into AI tools, context switching that breaks coding flow every time you need to check or update Linear, and stale information from operating on ticket details that may have changed since you last looked. The MCP makes your AI tool project-aware by default — it pulls live Linear data rather than working from whatever you remembered to paste in.
How do I install the Linear MCP server in Cursor?
The quickest method is selecting Linear from Cursor's list of trusted MCP servers. You can also add it manually: open the command palette with Ctrl/Cmd+Shift+P, type "Open MCP Settings," and add the Linear server configuration with the URL https://mcp.linear.app/sse. Full setup details are available in Cursor's MCP documentation and Linear's Cursor integration guide.
How do I set up the Linear MCP server in VS Code?
VS Code 1.102+ includes native MCP support. The easiest method is visiting the curated MCP server list and clicking Install to add it automatically. You can also configure it per-workspace by adding a .vscode/mcp.json file — useful for sharing the configuration with your team. The configuration uses npx mcp-remote to connect to the Linear SSE endpoint.
Does the Linear MCP server require an API key?
No. The Linear MCP uses OAuth authentication, which means no API key management or environment variables to configure. Authentication happens through your browser the first time you connect. This makes setup simpler and more secure than manually managing API credentials.
What can the Linear MCP server actually do — read only or read and write?
Both. On the read side, it can search and filter issues, query sprint and project status, retrieve project documentation, and surface blocked or at-risk tickets. On the write side, it can create new issues, update statuses, add labels, reassign tickets, and post comments — all on your behalf through your AI tool. So an AI agent can complete a task, update the Linear ticket to reflect the new status, and leave a comment, all without you switching tabs.
What is the easiest way to set up the Linear MCP server?
Through Builder.io's Fusion, which includes the Linear MCP out of the box. Setup is two steps: navigate to the MCP servers tab in Fusion, click Connect on the Linear tile, and authorize access to your workspace. No configuration files or manual JSON editing required.
How does the Linear MCP work differently in Cursor vs. Claude Desktop vs. Fusion?
In Cursor, Linear data is accessible inline while you code, making it useful for project-aware code suggestions and checking blocking issues without leaving the editor — but it's code-focused and not deeply integrated into the development workflow. In Claude Desktop, it provides a clean natural language interface for querying and analyzing Linear data, but doesn't connect to your actual development environment. In Fusion, Linear is integrated directly into a visual development workflow — you can share a Linear ticket URL and watch the AI write code, ship a PR, and update the ticket status, while also visually editing UI components in real time.
How do I test that the Linear MCP server is working after setup?
Run a few basic natural language queries in your AI tool: "Show me my assigned issues in Linear," "What issues are in progress in our current sprint?" or "List all open bugs in the frontend project." If the integration is working, you'll get back real data from your Linear workspace — actual issue titles, assignees, statuses, and project details — rather than an error or a generic response.
What are the limitations of the Linear MCP server in AI coding tools?
Most AI coding tools that support the Linear MCP are primarily code-focused, so the Linear integration tends to feel like a helpful sidebar rather than a deeply embedded workflow. Claude Desktop can query and analyze Linear data well but doesn't connect to your development environment. Cursor and Windsurf provide in-editor access but don't offer visual project management capabilities. The Linear MCP also only works with Linear — teams on Jira or GitHub Projects would need different MCP integrations for similar functionality.
