Linear expands its agent from planning into code execution

Linear is pushing its AI agent deeper into the software development workflow with a new set of features designed to move work from issue tracking into implementation and review. The company on Wednesday introduced coding sessions, automated triage and Diffs, saying the additions complete a loop that connects product context, code changes and pull request review inside the same system.

The update reflects a broader shift in AI tools for software teams. Many agents can already help individual developers, but Linear is positioning its agent as a shared team capability that can work from the context already stored in issues, discussions and connected tools.

From issue to pull request

The centerpiece of the launch is coding sessions. With the new workflow, a user can delegate an issue directly to Linear Agent, ask it to fix a problem, or mention it from Slack or Teams. The agent then reads the issue and related discussion, examines the codebase, proposes an approach, writes the code and opens a pull request.

Linear says the process runs in the cloud and uses frontier models along with tools such as Claude Code or Codex. The company says the point is to avoid the manual step where an engineer must gather context from Linear, restate it in another coding environment, monitor progress and then bring the result back for review.

The company describes the session as shared across the organization rather than tied to one person. Team members can follow along, contribute background, adjust the direction or take over if needed.

Automated triage starts the workflow sooner

Linear is also leaning on automation to start the process earlier. The company said many bugs and requests already enter the system through email, Slack or other channels and become issues in triage. With automated triage, teams can tag Linear Agent as soon as an issue is triaged.

Once triggered, the agent can investigate the problem by reading the codebase through Linear’s Code Intelligence feature and using surrounding issue context, including customer reports and internal discussion. It can also connect with tools like Sentry or Datadog to help narrow down the cause.

If the agent reaches a clear conclusion, it can launch a coding session, make the fix, open a pull request and notify an engineer for review. Linear says this allows more work to begin as soon as the issue arrives, rather than waiting for a person to pick it up.

Review stays in Linear with Diffs

The final stage is code review. Linear’s Diffs feature gives users a way to inspect changes and review pull requests without leaving the platform. The company says structural diffing and AI-assisted review help explain what changed and point reviewers toward the most important parts of the patch.

That keeps the code review tied to the original issue and discussion that produced the change, preserving the thread of context from report to implementation. Linear says the agent can remain involved through review, answer questions, make changes and continue iterating until the code is ready to merge.

A workflow Linear says it already uses internally

Linear says the approach is already in use inside the company. It said nearly 700 pull requests were merged by the agent in the past month, though it noted those changes were not limited to bug fixes.

The company framed the launch as part of a longer-term goal of making software development more autonomous. It pointed to customers including Ramp and Coinbase as examples of teams that have built agent workflows around Linear’s API and agent tools. Ramp said it uses a system that writes a majority of the pull requests it merges, while Coinbase has described Linear as a place where agents gather context before starting work.

For now, Linear is giving teams a way to decide how much of that process runs automatically. Users can begin with triage and let the workflow run to a draft pull request, or they can start with a single issue and hand control to the agent from there. The company says the broader aim is to make product development run on a shared context layer that grows with every loop.