Factory's Droid Now Turns Linear Tickets Into Pull Requests Autonomously

Factory has integrated its Droid coding agent with Linear, allowing teams to start an autonomous coding session by assigning an issue to Factory or mentioning @Factory in a comment. Droid gathers context from the issue, linked tickets, dependencies, and comments, then works in an isolated cloud environment.

The integration keeps delegation inside the existing issue workflow. Droid moves the ticket to In Progress, inspects the repository, implements a patch, runs tests, posts updates, and can open a pull request linked to the issue. Developers do not need to copy the ticket into a separate agent interface.

From assignment to pull request

Each delegated issue starts a session on preprovisioned remote compute. Factory applies organization-level settings configured by an administrator, giving sessions a consistent model, identity, toolset, and execution environment.

• Administrators choose the default model, reasoning level, instructions, plugins, service account, and compute configuration.
• A dedicated service account supplies Git credentials and access to configured connectors.
• Auto Model lets Factory Router select a model for the task; administrators can instead pin a model and reasoning level.
• Shared instructions determine whether Droid may inspect code, edit files, run tests, summarize results, and open a pull request.
• Progress and final results return to the Linear issue, preserving the ticket as the task record.

Repository permissions still define what Droid can inspect or change. Teams should give the service account access only to the repositories, branches, and external systems required for delegated work.

Tickets that produce usable patches

Droid builds its working context from the issue title, description, labels, comments, links, and dependencies. Effective tickets identify the repository, describe the expected behavior, name relevant files or services, and provide a verifiable definition of done.

A practical issue template

Repo: backend-api
Outcome: Add rate limiting to /v1/search
Limit: 100 requests per minute per API key
Verify: Add tests in tests/rate_limit_test.py
Success: New tests and the existing suite pass
Notes: Use the Redis client in lib/cache.py

Machine-checkable acceptance criteria make delegated tasks easier to review. Suitable work includes dependency updates, flaky-test repairs, contained refactors, and bug fixes with reproducible failures. Tasks that depend on undocumented architecture, product judgment, or access to several unconnected systems require more context and oversight.

Two Linear connections, different jobs

Factory offers delegation through Linear, Slack, Jira, and Microsoft Teams, with shared instructions, plugins, identity, and compute. These entry points let teams start work from the systems where they already track requests.

The organization-level Linear delegation app accepts issue assignments and @Factory mentions. A personal Linear connector has a narrower role: it exposes Linear tools to Droid during an existing session. Installing the personal connector alone will not enable issue delegation.

Access and rollout constraints

Configuring Delegations requires a Factory organization on the Teams plan or higher, plus the Manager or Owner role. The setup also requires permission to install apps in the Linear workspace and a service account for shared execution.

• Remote delegation is in Private Preview. Organizations must request access through their Factory account team and confirm eligibility for shared Linear execution.
• Access scope currently applies to everyone in the connected workspace rather than selected groups.
• Air-gapped environments are unsupported.
• Slack delegations receive context from the triggering mention only.
• Each Linear workspace, Slack workspace, or Jira site can connect to one Factory organization at a time.

Teams evaluating the integration should test repository permissions, branch protections, secret access, test commands, pull-request ownership, and failure handling before routing production work through it. Human review remains part of the workflow because Droid proposes code through a pull request rather than merging changes by default.

The ticket becomes the control plane

Linear serves as the prompt, queue, status surface, and audit trail for each delegated task. That design reduces the setup required to start an agent session and keeps implementation updates attached to the original request.

The model works best for bounded issues with complete context and objective checks. Ambiguous requirements, missing repository details, and hidden cross-service dependencies can lead to incomplete patches. Clear scope, least-privilege credentials, automated tests, and pull-request review provide the practical guardrails for using Droid on a backlog.