---
title: "ai agent for linear: read the issue, ship it, move the state"
description: "connect linear to a room and its agents search issues, create and update them, change workflow state, comment, relate issues, and build the change described."
url: "https://aldena.ai/integrations/linear"
---

# ai agent for linear: read the issue, ship it, move the state

linear is where the work is described, and a room is where it gets done. `linear_get_issue` reads an issue by its identifier, `linear_search_issues` filters across the workspace with an optional free-text term, and `linear_list_teams`, `linear_list_projects`, `linear_list_issue_statuses` and `linear_list_labels` give an agent the real vocabulary of your workspace rather than a guess at it. `linear_lookup_user` resolves a display name or an email to the person an issue should be assigned to.

## writing back in your workflow's own language

`linear_create_issue` files work, `linear_update_issue` edits fields including the workflow state, `linear_add_comment` posts markdown, and `linear_create_issue_relation` relates, blocks, or marks two issues as duplicates. each of those is a mutating tool, so it stops for approval before it runs. read tools never do, which means an agent can always answer what is in flight without being able to change any of it.

## the part other linear integrations skip

an assistant that summarises your cycle is useful for about a minute. because the room owns a server, the agent that read the issue can clone the repository onto it, edit files, run the test suite, and open the pull request, then come back and set the state to in review with the link attached. that whole chain happens in one room, in a chat you can watch, with approval gates on the steps that change something.

## example tasks

- **take the top unstarted issue on the web team and get it to in review.**

  the agent reads the issue, moves it to in progress, does the work on the room server, opens the pull request, comments the link, and moves it to in review.

  tools: `linear_search_issues` -> `linear_update_issue` -> `bash` -> `linear_add_comment` -> `linear_update_issue`

- **file the bugs from this thread and block them on the migration issue.**

  it creates one issue per bug with the right team and labels, then relates each of them to the migration issue as a blocker.

  tools: `linear_list_labels` -> `linear_create_issue` -> `linear_create_issue_relation`

- **watch the platform team and draft a plan whenever something new arrives.**

  the team subscription wakes the agent in this chat on creations, updates and comments, and it reads the issue and the team's statuses before proposing an approach.

  tools: `linear_subscribe` -> `linear_get_issue` -> `linear_list_issue_statuses`

## what it will not do

workspace administration, cycle and project configuration, and member management are outside the tool set. an agent cannot delete an issue, and it cannot reach a workspace the connected account was never given.

## faq

### can an ai agent create and update linear issues?

yes. linear_create_issue files new work and linear_update_issue edits fields including the workflow state, so an agent can move an issue to in progress when it starts and to in review when the pull request is up. both are mutating tools and ask for your approval first.

### does the agent understand my team's workflow states?

linear_list_issue_statuses reads the actual workflow states for a team rather than assuming the defaults, and linear_list_labels reads the workspace and team labels. an agent checks the real names before it tries to move anything into them.

### which linear scopes does a room need?

read issues and projects for search and metadata, create and edit issues for writing, and look up users for assignments and mentions. event subscriptions is separate again. linear scopes are chosen before the oauth handoff, so widening them later means reconnecting the room.

### can the agent do the engineering work, not just the ticket admin?

yes, and that is the reason to connect linear to a room rather than to a chat bot. the room owns a server, so the same agent that reads the issue clones the repository, writes the change, runs the tests, and opens the pull request before it updates the state.

### how does an agent react to a new issue without being asked?

linear_subscribe attaches it to an issue or a whole team. creations, updates and comments then wake the agent in the chat where it subscribed, so triage can start the moment something lands in the team's inbox.