How to Connect Devin AI to Linear for Ticket Automation and Playbooks

Assigning software bugs to autonomous coding agents often stalls when the agent lacks repository context, misses reproduction assets, or requires developers to copy issue descriptions into isolated chat prompts. Connecting Devin AI directly to Linear resolves this gap by turning issue tracking events into fully provisioned development sessions that deliver code pull requests without human context copying.

The Devin AI Linear integration connects Linear issue tracking to Devin's autonomous development sessions, converting tickets and comments into automated code PRs using synced playbook labels. When connected, Devin gains direct access to native Linear tools using your organization's OAuth connection credentials. This native architecture bypasses third-party MCP authentication overhead, removing the requirement to configure, host, or rotate API tokens for an external Linear model context protocol server.

The integration establishes a bidirectional feedback channel inside Linear's agent session interface. Rather than treating issue tracking as a dumb webhook destination, Devin interacts with tickets through dedicated session components:

• Real-time activity feed: Devin posts ongoing execution updates directly to the Linear ticket, including terminal commands executed, files modified, and intermediate progress notes.
• Plan tracking: Devin translates its internal task checklist into Linear's plan UI, allowing engineering leads to observe plan status and completed sub-tasks at a glance.
• Follow-up message threading: Developers can reply directly within the Linear agent session thread to refine implementation guidelines, request additional unit tests, or adjust architectural choices.
• Stop controls: Team members can trigger a stop signal in Linear to pause or sleep Devin on a specific task if requirements change mid-session.
• Automatic pull request linking: When Devin finishes coding and pushes a branch, the resulting GitHub or GitLab pull request link attaches automatically to the ticket conversation.

Devin supports 3 trigger methods: ticket assignment, playbook labels, and @mention comments. By configuring these entry points, engineering teams can route routine bug triage, complex feature planning, and targeted refactoring directly from their daily project boards.

Setting up the integration requires connecting your Linear workspace within Devin's organization settings and defining team-level permissions. This setup ensures that Devin only monitors designated queues and runs sessions with appropriate repository access.

Follow these steps to complete the initial setup:

1. In your Devin web console at app.devin.ai, navigate to Settings > Connections > Linear and click Connect.
2. Review the permission scopes in Linear and select the specific Linear teams Devin can access.
3. Configure synced playbook labels by selecting the macros (such as !plan or !implement) you want exposed in Linear.
4. Link your personal Linear user account in the user connection section so sessions attribute correctly.
5. Test the connection by creating a test ticket in an authorized team and applying a synced playbook label.

Authorizing Organization and Team Permissions

During the OAuth authorization flow, Linear prompts you to select which teams Devin can view. Restricting access to specific engineering teams prevents Devin from listening to unrelated issues in design, marketing, or human resources teams. You can modify team access at any point by visiting Linear's internal Application settings.

Connecting Personal User Accounts for Attribution

In addition to the organization-level OAuth bridge, individual team members should link their personal Linear accounts within Devin's connection settings. Personal account linking allows Devin to identify which human engineer triggered a session through an assignment, comment, or label. Session logs and pull request descriptions then carry the appropriate user attribution, simplifying code reviews and branch management.

Enterprise Linear Team Mapping

For enterprise deployments managing multiple Devin organizations, administrators must configure Linear team mapping in Devin organization settings. This mapping pairs distinct Linear engineering teams with specific Devin organizations, ensuring that enterprise billing allocations, repository secrets, and knowledge bases remain strictly separated across business units.

Devin playbooks define structured instructions, testing steps, and execution guidelines for specific development patterns. The Linear integration exposes these playbooks directly inside Linear through synced playbook labels, enabling developers to control agent behavior without writing custom prompts.

How Synced Playbook Labels Work

When you add a playbook to your synced list in Devin settings, its designated macro becomes available as a tag under the "Devin Playbooks" label group in Linear. For instance, creating a playbook with the macro !plan creates a matching label in Linear. Applying that label to an issue instructs Devin to ingest the ticket specifications, explore the repository codebase, and output an architectural plan without writing code or modifying files.

Devin relies on a default playbook for assignments where no explicit label macro is provided. By default, newly connected organizations use the !plan playbook. This safety mechanism prevents Devin from making unreviewed code changes when someone inadvertently assigns an issue without specifying implementation instructions.

Linear Issue Event Flow:
(Ticket Created / Updated)
           │
           ▼
(Trigger Evaluation) ──► Check: Assignment, Label Macro, or @mention
           │
           ▼
(Edge Detection) ──────► Fire only on state transition (e.g., Todo -> In Progress)
           │
           ▼
(Session Launch) ──────► Execute Default Playbook (!plan) or Specified Macro (!implement)

The Three Primary Trigger Methods

Engineering teams activate Devin through three distinct interaction models:

• Ticket assignment: Assigning an issue to the Devin user in Linear starts a session using your designated default playbook.
• Adding a playbook label: Applying labels like !plan, !implement, !triage, or !review starts a session using the matching playbook macro instructions.
• @mentioning Devin in ticket comments: Mentioning @Devin in an issue comment initiates a session that consumes the comment text as a direct prompt, bypassing playbook templates.

Edge Detection in Automation Triggers

Devin automations use edge detection to evaluate trigger conditions. Edge detection means automations only fire when an issue transitions from non-matching to matching conditions. For example, an automation configured to trigger when a ticket reaches the "In Progress" status with a bug label fires only at the exact moment the status changes or the label is applied. Existing tickets that already sit in "In Progress" with the label do not spawn redundant sessions, protecting teams from accidental session loops.

Equip Devin AI with Persistent Workspace Storage

Give Devin and your engineering team a shared workspace for large reproduction files, specification documents, and versioned assets. Every organization begins with a 14-day free trial.

Start 14-Day Trial

Competitor guides focus almost exclusively on processing plain-text descriptions in ticket fields. In real software development, reproducing a complex defect requires far more than a short text summary. Developers must attach core dumps, network HAR files, test database snapshots, reproduction video captures, and comprehensive architectural specifications.

Linear tickets are optimized for tracking tasks, not hosting massive binary assets or multi-gigabyte reproduction files. Devin also operates inside isolated cloud sandboxes during code execution. While this sandbox model guarantees security, it is ephemeral: once Devin completes a run and disconnects, the sandbox filesystem is destroyed.

Engineering teams often consider generic storage options to bridge this gap:

• Local developer disks: Fast for manual testing, but inaccessible to remote cloud agents like Devin.
• Amazon S3 buckets: Reliable for raw object storage, but lacking granular workspace collaboration, document indexing, or live audit trails for mixed agent and human teams.
• Traditional consumer cloud drives: Built for manual desktop synchronization, but fragile when queried programmatically by autonomous agents.

To solve this persistence challenge, development teams connect Devin to Fast.io shared workspaces. Fast.io functions as an intelligent workspace where humans and autonomous AI agents read, write, and manage project context together.

Key Fast.io capabilities that support Devin Linear workflows include:

• Remote MCP server access: Fast.io provides a consolidated MCP toolset accessible over Streamable HTTP at https://mcp.fast.io/mcp (or https://mcp.fast.io/mcp/key with Bearer authentication) and legacy SSE at https://mcp.fast.io/sse. Devin can query project files, fetch reproduction data, and store diagnostic logs programmatically without custom storage code. Onboarding guidelines for agents are documented at https://fast.io/llms.txt, with full tooling reference available at the Fast.io MCP server guide.
• Intelligence Mode: Enabling Intelligence Mode indexes workspace files for semantic search and citation-backed document retrieval. When Devin receives a Linear ticket referencing a legacy service, it runs hybrid search across the workspace to retrieve exact specification snippets and design context.
• Metadata Views: Complex feature tickets often include unstructured requirement files. Using Metadata Views, teams describe desired data fields in plain language, and the system extracts structured schemas (including Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time) into filterable tables.
• Collaborative Notes: Real-time markdown notes allow engineers and agents to co-edit technical specifications simultaneously. Devin can read initial issue constraints from a shared note and append reproduction steps during execution.
• Per-file version history: Every file in Fast.io maintains complete version history. If an agent modifies a configuration script or test fixture incorrectly, developers can revert the file to its previous state immediately.
• Append-only audit log: The workspace audit log records every read, write, and share operation performed by both human developers and autonomous agents, ensuring transparency across development cycles.
• Workspace ownership transfer: When an agent provisions a project workspace for an external client or new department, it can hand over administrative ownership to a human stakeholder while retaining operational permissions.
• Transparent subscription model: Every organization starts with a 14-day free trial, which requires a credit card. | Plans are Starter at $29/mo, Business at $99/mo, and Growth at $299/mo, providing scalable storage and team collaboration seats. Learn more on the Fast.io pricing page.

By linking Linear tickets to persistent Fast.io workspaces, developers provide Devin with the exact reproduction assets, API contracts, and testing fixtures required to resolve complex issues autonomously.

Deploying Devin into an active Linear workflow requires operational guardrails. Without defined compute budgets and clear PR review standards, automated ticket triggers can quickly overwhelm engineering review queues or consume unnecessary resources.

Sizing and Compute Budget Controls

Devin measures execution work in Agent Compute Units (ACUs), which cover active code generation, shell commands, and browser testing. Devin AI pricing ranges from the $20/month Core plan, which provides pay-as-you-go compute units for individual developers, while team plans provide dedicated monthly ACU allotments for concurrent multi-repository automation.

To prevent runaway spending on high-volume Linear queues:

• Set per-session ACU limits: Configure maximum compute thresholds on automation triggers so an intractable bug does not exhaust budget in a loop.
• Establish invocation caps: Limit the number of sessions an automation can spawn within an hour (for example, capping triggers at 5 runs per hour) to absorb unexpected ticket bursts.
• Scope network policies: Restrict the external domains Devin can contact during execution to trusted package registries, API endpoints, and corporate repositories.

Managing the Pull Request Lifecycle

When Devin completes work on a Linear ticket, it pushes a git branch and opens a pull request. To maintain a disciplined engineering workflow, follow these lifecycle practices:

• Ticket status progression: Configure automations to move Linear tickets to "In Review" once a PR is submitted, signaling that human review is required before merging.
• Review feedback via Linear threads: If the pull request requires modifications, post instructions in the Linear agent session thread. Devin picks up follow-up comments and pushes updated commits to the existing branch.
• Resolving and closing tickets: Avoid letting Devin mark tickets as "Done" or "Closed" autonomously. Require human engineers to approve the pull request, verify continuous integration checks, and allow Linear's native git integration to close the issue upon merge.

By establishing clear boundaries between autonomous drafting and human code review, engineering organizations turn Linear into a reliable control center for agentic development.