Cursor and Linear: How Coding Agents Work Inside Your Issue Tracker
The Cursor integration for Linear lets teams hand issues to coding agents the way they would to a teammate. A look at the workflow, the technical decisions behind it, the trust problem it addresses and the lessons for anyone building agent integrations.
Development teams already have plenty of capable tools. The bigger gains now come from wiring them together tightly. The Cursor integration for Linear is a good example: it lets a team hand an issue to a Cursor coding agent the same way they would assign it to a colleague, without leaving the place where the work is planned.
Why connect a coding agent to an issue tracker
Many teams already use Linear for planning and Cursor for writing code. The integration links the two at the point of highest leverage, inside Linear, where priorities are set and where the context for each task lives. Today a Cursor agent can pick up a coding task, open a pull request and report its progress back to the issue.
The payoff should grow over time. As models improve, as teams learn to write issues with an agent's needs in mind, and as more of the workflow is automated, it becomes realistic to imagine draft pull requests appearing before a human even opens an issue, or several issues being worked on in parallel in the background.
The design choices behind the integration were discussed publicly by Rohan Varma, the Cursor product manager who led the project, in a conversation with Linear. The sections below summarize the workflow, the technical decisions and the lessons that apply to anyone building similar integrations.
What the integration does
The core interaction is simple. Users can assign an issue to Cursor, mention Cursor in a comment, and ask follow-up questions in the same session. While the agent works, Linear shows its reasoning, the tools it calls and its running to-do list, so the issue becomes a live view of what the agent is doing.
Building trust in an unfamiliar workflow
For many developers, delegating work to a coding agent is still new. Reliability is improving quickly, but it is not perfect, and the integration was designed with that in mind. A key feature is the ability to jump from the issue into Cursor and open the agent's work alongside the code. From there, a developer can inspect what the agent changed, finish the job by hand or give feedback on its approach. Reviewing work in an IDE, where it is easy to navigate the codebase, makes it far easier to see where an agent went off track, and that visibility is what lets trust build over time.
Two sources of context
The two products are strong in complementary areas. Linear holds the product, customer and project context: why a task exists and what success looks like. Cursor holds the codebase, its history and the team's engineering conventions. Combined, they give the agent a much more complete starting point. It does not begin from scratch, which improves both the quality and the speed of its output.
Where the agent performs well today
Agents have long been effective on small changes that can be verified by pattern matching. They also do well on larger tasks when an experienced user supplies rich context, points to the right files and sketches the intended approach. Interestingly, they can be surprisingly useful in difficult territory too, such as targeted fixes in old, tangled parts of a codebase, where an agent can sometimes absorb context faster than a person can. The scope keeps widening as models improve, moving from small tasks to medium ones and, increasingly, to large and complex work with little back-and-forth.
Clearing the backlog nobody gets to
The most immediate effect is a lower barrier to starting work. In most teams, P2 and P3 issues sit untouched because they are not worth the context switch for an engineer. With an agent attached to the tracker, such issues can be scoped quickly and turned into review-ready draft pull requests without pulling anyone off their main work. Polish and quality fixes that usually get postponed finally have a path to completion.
The developer experience of building on Linear
Building on Linear's platform was described as straightforward overall. The new Agent API could be stood up in about a day. Frequent, direct communication between the two teams over Slack helped, and the Linear SDK with its auto-generated GraphQL types reduced the need to dig through documentation.
Designing for issues that may not exist
One design discussion centered on the Agent API's data model, specifically whether an issue ID would always be present. Linear anticipated future agents that work outside of issues, so Cursor wrote its code to tolerate a missing ID. The Cursor team, in turn, suggested making the "Open in Cursor" link more prominent: work usually starts in Linear but continues in the editor, and getting there should take one click.
What Is Cursor IDE Automation? How to Use the Next-Generation AI Agent Feature
Take AI Coding Productivity to the Top: A Guide to Creating .cursorrules & CLAUDE.md
The hard part: webhooks
The most difficult piece was webhook handling. Each developer needs their own running instance, which makes collaborative development awkward. When several people work on webhooks at once, the Linear test app can end up pointing at different laptops, and tunneling traffic back and forth becomes confusing. Better tooling for local, end-to-end testing would make this kind of integration noticeably easier to build.
Following Linear's agent guidelines
Linear publishes Agent Interaction Guidelines, and several of them shaped the integration. One question was how often an agent should comment on an issue. Posting an update at every step is tempting but quickly turns into noise. Another principle states that an agent cannot be held accountable, meaning final responsibility always rests with a human. That framing matters for how teams review agent output. The API's native support for showing an agent's thoughts and tool calls mapped neatly onto Cursor's own model, so exposing the agent's internal state in Linear took little effort.
How sessions simplified the design
Linear models agent work as sessions. Working with them was simple. Not being able to key everything off an issue adds a little complexity, and when no issue is present the agent can simply decline the request. On the other hand, sessions make it much easier for the agent to report back to the user. There is no need to decide whether to edit an existing comment or start a new thread, which keeps the API lean.
A shared taxonomy for issues
One improvement Cursor would like to see is a standard classification of issue types, such as bug, typo, feature, documentation, testing, tech debt and refactor. If the platform understood these categories, agents could make simpler decisions, and teams could attach policies to them automatically: which issues an agent may accept or should decline, and which model or budget to use for each type.
Rule-based delegation
A taxonomy would also move teams up the automation ladder. Picture rules that assign work automatically, along the lines of "in this project, give the agent every issue with this label sized small or below." That is a step toward a richer collaboration model, where people define the policy and agents pick up matching work as it arrives.
Agents that help plan
Planning is another promising direction. An agent could take a large issue, gather the relevant context and split it into smaller Linear issues. When an agent is not confident about a big task, it could break the work into sub-tasks it can handle and leave the rest for people.
Lessons for teams building agent integrations
The clearest advice concerns long-running work. The Linear API makes it easy to accept a task, queue it and post an update when it is done, which is enough for short jobs. For work that takes hours, periodic check-ins or streamed progress are essential, because users need to see that something is still happening. The tone of those updates matters as well. They should read like a new hire summarizing their work for a reviewer: concise, specific and easy to act on.
Getting started
- In Linear, assign an issue to
@Cursor, or mention@Cursorin a comment. - The agent accepts the task, works on it, opens a pull request and posts progress back to the issue.
- For longer tasks, keep periodic status updates enabled so reviewers can follow along.
Further reading
This week’s posts, in your inbox every Monday
A short summary of the posts published that week on AI, Claude Code, MCP and web development. No new posts, no email.
- One email a week
- No ads
- One-click unsubscribe
