Hands Off Development

Connecting Linear Tickets and GitHub Issues to Cloud Agent Dispatch Without Custom Middleware

Cloud agents can execute tickets directly through Linear and GitHub without custom integrations.

· 8 min read
Cover illustration for “Connecting Linear Tickets and GitHub Issues to Cloud Agent Dispatch Without Custom Middleware”
Cloud Agent Environments · November 7, 2026 · 8 min read · 1,748 words

Migrating engineering teams from local to cloud coding agents starts with making tickets executable. Linear and GitHub Issues provide built-in assignment and execution controls that can connect planned work to hosted agents. The decisive configuration lives in the issue brief, repository rules, and review gates, while the harness determines which dispatch paths are available.

Why issue trackers became execution surfaces for autonomous code

A ticket once depended on a developer to translate it into an agent session. The developer read the request, opened the repository, started the agent, pasted context, and later linked the pull request back to the issue. Cloud agents shorten that handoff by accepting work from the tracker.

That shift gives issue structure a direct role in implementation. Acceptance criteria, affected files, branch choices, and testable completion conditions guide the agent’s first pass so a human does not have to fill in the missing context. Both trackers already expose native dispatch mechanics, although their triggers, routing controls, and harness support are not interchangeable.

The four native dispatch paths Linear exposes without custom middleware

Assignee routing begins with workspace permissions. An admin chooses which teams an agent can access, after which members of those teams can delegate issues to it. Delegation separates the agent’s implementation task from human ownership of the result.

Comment mentions provide a direct task channel. An @Codex comment starts a cloud chat, and naming a repository overrides the suggested environment. An @Devin comment supplies the task directly, while mentioning GitHub Copilot can steer an active session. The exact behavior depends on the integration. A mention is therefore useful for explicit delegation, but it is not a uniform command across agents.

Labels provide routing and, for some integrations, behavior selection. Cursor resolves repositories through [repo=owner/repo] in the issue or comments, then the issue’s “repo” label group, the project’s “repo” label group, and finally the dashboard default. Devin can start a named skill through a synced skill label. These mechanics are integration-specific. Linear’s agent documentation lists assignment and mentions as ways to interact with agents, with no separate category for label automation.

Triage rules provide the unattended path on Business and Enterprise plans. They can delegate incoming issues to agents, with filters such as labels, creators, or other properties. Linear’s coding sessions documentation also describes Loops that run agent behaviors when an issue arrives in Triage. Direct assignment to Claude Code remains unavailable. Teams that want to use that engine without a custom webhook relay can use Linear coding sessions, which run Claude Code or Codex under the hood.

The four native dispatch paths GitHub Issues exposes without custom middleware

Assignee routing to Copilot starts a repository-based implementation workflow. The agent researches the code, makes a plan, creates a branch, writes and pushes commits, and runs tests and linters in its environment. It then opens a draft pull request and requests review. Completion appears in the issue’s activity feed with a link to the pull request.

It also says Copilot will not react to subsequent issue comments. The issue thread is therefore not an always-live control channel. Copilot supports mid-run comment steering, but teams cannot count on another comment on the assigned issue to redirect it.

Linear’s documentation establishes Business and Enterprise triage rules, including agent delegation and Triage Intelligence. Those controls are documented as Linear dispatch paths, while Copilot can receive work from either tracker.

Teams can control execution by selecting a model, using a custom repository agent, and setting base and working branches. Only people with repository write access can trigger cloud work. GitHub Issues also provides sub-issues, issue types, dependencies, and large-scale Projects, while structured YAML issue forms support intake. Together these features make a substantial dispatch surface, but they do not establish four independent launch mechanisms.

Where the real configuration work lives: the issue brief, not the integration settings

A configured integration can launch an agent without giving it enough information to produce useful work. Settings establish access and routing, but the issue defines the intended change. Those are separate jobs. An agent can follow an incomplete brief faithfully and still produce a pull request that misses the author’s intent.

Repository guidance supplies the durable engineering rules that should not be repeated in every ticket. Branch policy, local checks, and rules for who owns review belong there, while the issue describes the change to make. Templates make that division practical. Draft pull requests then let people inspect the work without suggesting it is ready for production.

The practical template begins with desired behavior, distinguished from a possible implementation. It names the files or product surfaces in scope and states what must remain unchanged. A testable definition of done supplies the endpoint. Branch and model preferences complete the brief where defaults are insufficient. Issue-writing discipline becomes part of the runtime because these fields constrain what the agent attempts and shape how a person understands the backlog.

What the sandboxed environments behind these paths actually do

Dispatch chooses the work, while the environment sets what can be done. For unattended tasks, isolation is only one consideration. Package installation, service execution, verification, and persistence after a laptop closes depend on the environment.

Snapshot and resume capabilities let Copilot pick up work without rebuilding context. This differs from a local execution fence. It provides local governance and is included with Copilot at no additional cost.

Linear coding sessions use the workspace’s GitHub integration, so repositories must be available through that connection. Sessions use the Claude Code or Codex setup the team already has. Billing is a separate planning consideration. Linear’s coding sessions documentation describes a prepaid workspace pool of AI credits, with model tokens billed at provider-published rates without markup and sandbox runtime charged per 20-minute block as of October 2026. Dispatch volume therefore affects both model consumption and runtime charges.

Harness capabilities mapped to dispatch scenarios: Copilot, Cursor, Codex, and Claude Code

Copilot fits teams seeking repository-centered controls and a direct draft-pull-request workflow. It supports dispatch from both Linear and GitHub Issues, with model selection, custom agents, branch settings, and session steering. Its write-access gate limits who can initiate cloud work. That combination makes it a strong fit where execution permissions and review already revolve around the repository.

Cursor fits teams that work on several changes at once. Its repository-priority chain makes Linear issues and project labels useful routing inputs, while Builds, introduced in August 2026, preconfigures cloud environments to reduce per-run setup. Parallel agents, introduced in October 2025, operate on separate git worktrees simultaneously. Separate worktrees support concurrent work without requiring a single shared working tree. Usage-based pricing is also part of the Cloud Agent setup for Linear.

Codex fits teams that want progress visible in Linear. It posts updates to the issue and finishes with a summary and a link to the completed task in Codex cloud. Pull request creation remains a human step. The engineer opens that task to review changes and create the pull request, while a repository named in the initiating mention can override the suggested environment. Paid ChatGPT plans support the integration, though Enterprise workspaces may require admin enablement.

Claude Code requires a different migration decision. Teams seeking a no-middleware route for Claude Code must use Linear coding sessions because direct Linear assignment is unavailable. Teams can also use a custom webhook relay, but that is outside what this article covers. For teams moving Claude Code off developer laptops, that choice sets how they dispatch work before they get to issue templates or automation rules.

What breaks when dispatch runs without the right guardrails

Weak issues lead to weak pull requests faster when dispatch is automatic. Too few tests and no review policies make that problem worse because more work flows through the same delivery system. Review capacity does not increase with generation speed. Teams dispatching many tickets concurrently can move the constraint from coding to the merge queue.

Human review therefore shifts toward checking whether the change solves the right problem and whether its test evidence can be trusted. Reviewers must also assess maintenance and security debt that may not be obvious in the diff. Automation does not remove those obligations. Teams still need SAST/SCA integration in pull request workflows, dependency verification, and human review of security-critical paths, along with clear limits on what agents may change.

Google’s DORA 2024 report found that teams that used AI tools more had lower delivery stability and lower throughput. Lower-performing teams saw most of the gains, while top-performing teams improved less. That finding challenges any simple equation between more generated code and better delivery. It gives teams a reason to treat migration as a delivery-system change that includes a faster way to start coding.

The guardrails start with draft pull requests, protected branches, and required checks that keep CI and human review in place before merge. Teams should start by dispatching small tasks with clear limits, including validation tasks, reproducible bug fixes, and test coverage tied to known files. Templates should enforce the brief format consistently. Clear policies for each repository and type of work should then say which tasks can use unattended triage-rule dispatch and which need a human trigger. These controls address intake, execution scope, and integration rather than relying on the sandbox to solve every risk.

Choosing between Linear and GitHub Issues as the dispatch surface for your team

GitHub Issues is free with every repository and tightly connected to pull requests, with sub-issues, types, dependencies, and Projects supporting planning near the code. Linear is built for planning, with keyboard shortcuts, a command palette, and dense views. The choice is organizational before it is technical. Moving dispatch into the existing planning surface avoids treating agent adoption as a reason to relocate intent unnecessarily.

Harness choice then narrows the practical options. Copilot supports both trackers, with GitHub Issues offering the tighter pull request connection. Linear provides documented routing for Cursor and progress reporting for Codex, while equivalent GitHub Issues dispatch through those harnesses is not established by the supplied documentation. Claude Code points to Linear coding sessions for the native route. Teams that plan to use unattended Linear delegation should also check whether they qualify for Business or Enterprise before building around triage rules.

The migration decision should therefore combine planning location, harness support, execution environment, and review capacity. None can substitute for the others. A team with clear issue templates, protected branches, required checks, and scoped dispatch policies has the foundations to use either tracker responsibly. The remaining integration work connects those foundations to an agent.

Sources

  1. Coding sessions
  2. Linear Integration: Assign issues to Claude Code to trigger cloud agent sessions · Issue #12925 · anthropics/claude-code · GitHub
  3. Agents Integrations

More in Cloud Agent Environments