The gap between issue tracking and actual coding has always been a pain point for development teams. You spot a bug in Linear, switch to your code editor, hunt down the problem, fix it, create a PR, and then remember to update the issue. This context switching kills productivity and breaks your flow.
Cursor’s integration with Linear changes this completely. You can now delegate coding tasks directly from Linear issues to Cursor’s background agents, creating a seamless bridge between planning and execution.
What are Cursor and Linear #
Cursor is an AI-powered code editor that goes beyond simple code completion. Its background agents can autonomously work on entire features, fix bugs, and even respond to user feedback - all while you focus on other tasks. These agents understand your codebase context and can make substantial progress without constant supervision.
Linear has become the go-to issue tracker for modern development teams. Its clean interface and powerful automation features help teams organize work efficiently. But until now, the handoff from Linear issues to actual coding remained manual.
The integration connects these tools so Cursor agents can work directly on Linear issues. When you assign an issue to @Cursor, a background agent analyzes the context, understands the requirements, and starts working on a solution.
Setting up the integration #
Before you can delegate issues to Cursor agents, an admin needs to establish the connection. Here’s what’s required:
Prerequisites #
- Cursor Pro or Ultra plan - Background agents aren’t available on the free tier
- Admin access to your Cursor team dashboard
- Linear workspace with appropriate permissions
Connection process #
The setup takes just a few minutes:
-
Navigate to integrations: Go to the Cursor dashboard and find the Linear section
-
Authorize connection: Click “Connect to Linear” and authenticate with your Linear account. Cursor will request permission to access your Linear workspace
-
Configure repositories: Select which code repositories Cursor agents can access when working on Linear issues. This ensures agents only work within approved codebases
-
Enable background agents: From the background agents section, install the agent capability to your workspace
Once connected, team members can start delegating work without additional setup. The integration works across Linear’s web interface, mobile app, and any connected tools.
Using the delegation workflow #
With the integration active, delegating work to Cursor becomes as simple as mentioning a teammate. Here are the two main patterns:
Direct assignment #
The most straightforward approach is assigning issues directly to @Cursor. In Linear’s assignee dropdown, you’ll see “Cursor” as an option alongside your team members.
When you assign an issue to Cursor:
- The agent immediately analyzes the issue title, description, and comments
- It pulls in linked references, related issues, and any attached files for context
- A background agent spins up and begins working on the task
- You get status updates in Linear as the agent makes progress
Comment mentions #
You can also trigger agents by mentioning @Cursor in comments. This pattern works well for:
- Adding new requirements to existing issues
- Requesting specific approaches or fixes
- Getting agent input on implementation details
Example comment: “@Cursor can you implement the user authentication flow described above? Make sure to include error handling for invalid credentials.”
Progress tracking #
Once an agent starts working, you can monitor progress across multiple surfaces:
- In Linear: Status updates appear as comments, showing what the agent is analyzing and implementing
- Cursor web app: Detailed logs show agent reasoning, code changes, and decision points
- Your IDE: If you open the same repository, you can see the agent’s work in real-time
The unified view keeps everyone aligned whether they primarily use Linear for project management or spend most time in the code editor.
Advanced configuration and automation #
Teams handling high volumes of issues can automate the delegation process entirely. Cursor’s triaging rules eliminate manual assignment for common scenarios.
Automatic triaging rules #
Create rules that automatically assign specific types of issues to Cursor agents. The Cursor team uses this for all product bugs and user feedback, immediately routing issues to agents without human intervention.
Common triaging patterns:
- Bug reports with “urgent” label → Auto-assign to Cursor
- Issues tagged “good-first-issue” → Route to junior developers or agents
- User feedback containing error logs → Immediate agent analysis
Repository configuration #
Fine-tune which repositories agents can access per issue type. This prevents agents from making changes to sensitive codebases while allowing broad access for routine fixes.
Configuration example:
[repo=frontend,labels=ui-bug] → Allow agent access
[repo=auth-service,labels=security] → Require human approval
[repo=data-pipeline] → Block agent access
Background agent monitoring #
The Cursor dashboard provides detailed insight into agent activity:
- Active agents and their current tasks
- Resource usage across your team’s agents
- Success rates for different types of issues
- Cost tracking for agent compute time
This visibility helps teams optimize their automation rules and identify patterns where agents excel or struggle.
Pull request automation #
When agents complete tasks, they automatically:
- Create pull requests with descriptive titles and detailed descriptions
- Link PRs back to Linear issues for easy tracking
- Request appropriate reviewers based on code ownership rules
- Update issue status to “In Review” or custom workflow states
The PR descriptions include agent reasoning, implementation choices, and any assumptions made during development.
Real-world usage examples and best practices #
The Cursor team manages thousands of Linear issues using their own integration. Here’s how they structure their workflow:
Bug triage automation #
Every product bug gets automatically assigned to a Cursor agent with repository access. The agent:
- Analyzes error logs and reproduction steps
- Identifies the root cause in the codebase
- Implements a fix with appropriate test coverage
- Creates a PR for team review
This pattern handles routine bugs without human intervention, freeing developers for complex architectural work.
Feature implementation #
For well-defined features, agents can handle the complete implementation:
Issue: "Add dark mode toggle to user settings"
Agent workflow:
1. Analyze existing theme system
2. Create toggle component
3. Wire up state management
4. Update CSS variables
5. Add persistence to localStorage
6. Create tests for theme switching
User feedback processing #
Customer feedback often requires immediate attention. Agents can:
- Reproduce reported issues using provided steps
- Investigate related code to understand the problem
- Draft initial responses for the support team
- Implement quick fixes for obvious problems
Best practices for effective delegation #
Write clear issue descriptions: Agents work best with specific requirements, acceptance criteria, and context about user impact.
Include relevant code pointers: If you suspect which files need changes, mention them in the issue description.
Provide reproduction steps: For bugs, detailed reproduction steps help agents understand the problem quickly.
Set appropriate labels: Use consistent labeling so triaging rules can route issues effectively.
Review agent work promptly: Agents learn from feedback, so quick PR reviews improve future performance.
The integration transforms Linear from a tracking tool into an active participant in your development workflow. Instead of issues sitting in backlogs, they become triggers for immediate action.
Teams report significant productivity gains, especially for routine maintenance tasks and well-defined features. Developers can focus on complex problems while agents handle the implementation details.
The key is starting simple - connect the integration, try delegating a few straightforward issues, and gradually expand automation as you build confidence in the agent capabilities.