Senior / Staff Product Engineer

Coding sessions on mobile. Your coding session doesn't have to stop when you leave your desk. Use the Linear mobile app to review code changes, comment on specific lines, and iterate with Linear Agent. Open any diff and switch to the Changes tab to inspect the code. When you spot something to change, tap the relevant line to add it to your message to steer the coding session in the direction you want. Linear has also added section under My Issues | Assigned for your delegated issues. It shows the status of each coding session, and gives you a quick way back into active work. Download the Linear mobile app for iOS and Android. Guided Reviews are now generally available. Guided Reviews break diffs into focused sections with explainers on what changed and why. As part of general availability, they are now generated for larger pull requests, with a bigger context window and better latency. Guided Reviews are available on Business and Enterprise plans at no additional cost. Support for GitHub teams in reviews. You can now assign reviews to GitHub teams. Review requests assigned to your GitHub teams appear in a dedicated section of the Reviews inbox. Learn more in the docs. Signed commits for coding sessions. Coding sessions now support signed commits. Add your SSH or GPG key in Settings to enable signing. Workspace admins can also require users to upload a signing key before using coding sessions. GitHub Copilot for Linear. GitHub Copilot users can assign issues directly to Copilot's cloud agent from Linear. Copilot uses the issue context to work in its own development environment, open draft pull requests, and update the issue as it makes progress. Choose model and agent settings, set the base and working branches, then steer ongoing work through comments in Linear. To get started, install GitHub Copilot for Linear, or read the GitHub announcement for more details.

Graphs vs loops: the 2026 AI agent architecture debate explained. Introduction. Two product launches hit X on the same July day in 2026. The first was a DeepLearning.AI course on knowledge graphs, taught by Neo4j's Andreas Kollegger. The second was Linear's launch of Loops - a feature that lets their AI agent run recurring, autonomous tasks. The names collided. The replies split into two camps. And within 48 hours, the entire AI builder community was arguing about one question: should your agent's brain look like a graph or a loop? The answer is not what either side claimed. What is a loop architecture. A loop is the simplest possible agent pattern. It is a while-loop that feeds the agent's output back as its next input. The agent runs, produces something, checks if it is done, and either stops or runs again. while not done: result = agent.run(context) context = result done = check(result) This is how Claude Code's /loop works. It is how Codex Automations works. It is how every autonomous coding agent - Cursor, Copilot, OpenCode - operates under the hood. The agent gets a prompt, produces output, verifies it against a goal, and iterates. What loops do well: * Dead simple to implement. Three lines of pseudocode. * Works for any task. You do not need to know the structure of the problem beforehand. * Human-in-the-loop is natural. Insert a review step between iterations and you have a safety valve. * Self-correcting. The agent sees its own output and can fix mistakes in the next pass. What loops do poorly: * Drift. On long tasks, the agent forgets why it started and chases tangents. * Cost. Every iteration consumes tokens. A loop with no exit condition runs until your API budget is gone. * No parallelism. One agent, one thread, one thing at a time. * No state typing. The context blob grows. You cannot introspect what changed between iterations without diffing text. What is a graph architecture. A graph architecture replaces the single while-loop with a directed graph of nodes and edges. Each node is a discrete operation. Each edge is a conditional transition. The graph defines the shape of the workflow, and the agent traverses it. [Start] -> [Research] -> [Draft] -> [Review] | (fails) | (passes) v [Revise] -> [Review] | (passes) | v [Publish] This is how LangGraph structures agent workflows. It is how multi-agent systems - orchestrator-worker, debate, hierarchical - are wired together. What graphs do well: * Typed state. Each node declares what data it reads and writes. You can inspect state at any point. * Checkpointing. Pause the graph at any node. Resume later. Debug from the last checkpoint. * Parallelism. Branch at a node and run multiple agents simultaneously. * Governance. Approve transitions. Block paths. Enforce rules per edge. * Branching with clear conditions. One node can fan out to three different paths based on the output. What graphs do poorly: * Upfront design cost. You need to know the structure before you run it. This is the opposite of "just let the agent figure it out." * Rigidity. A graph with 40 nodes handles 40 scenarios. The 41st scenario breaks it. * Tooling overhead. LangGraph, Haystack, and similar graph frameworks add dependencies, learning curves, and code surface area. The third option: graph loop. The debate missed the most interesting architecture: a graph of loops. Each node in the graph contains its own loop. The graph defines the overall workflow. Each node runs autonomously within its boundaries. When a node completes, the graph routes output to the next node. Graph Level (deterministic): [Research Loop] -> [Draft Loop] -> [Review] Node Level (autonomous): Each node runs an inner loop: plan -> execute -> verify -> (retry | done) This is what production AI systems actually use. LangGraph supports this pattern natively. You define the graph structure for governance and parallelism, but each node runs a self-correcting loop for quality. * The graph prevents drift across the workflow * The loops ensure quality within each step * You get checkpointing and parallelism from the graph * You get self-correction and flexibility from the loops * Human approval gates slot in naturally between graph nodes The tradeoff: Complexity. You are now debugging two levels of control flow. If the outer graph has 5 nodes and each inner loop iterates 3-4 times, you burn 15-20 LLM calls per run. This is fine for high-value tasks (legal document review, medical report generation). It is expensive for routine tasks (categorize this email). When to use each. | Scenario | Architecture | Why | | Simple task, fixed output format | Loop | No upfront design needed | | Multi-step research with branching | Graph | Parallelism and state typing | | Code generation and review | Graph of Loops | Structure + self-correction | | High-volume classification | Loop | Cost-efficient, no state needed | | Compliance-governed workflow | Graph | Checkpointing and audit trails | | Open-ended exploration | Loop | Flexibility matters more than structure | The infrastructure angle. All three architectures run on the same hardware - but their requirements differ. A simple loop runs on a single GPU instance. One agent, one model call at a time. A 24 GB GPU handles this easily. A graph with parallel branches needs multiple GPUs or a high-throughput inference server like vLLM. You are dispatching 4-6 concurrent API calls. Queue depth matters. A graph of loops - the production pattern - combines both. Each node's inner loop executes sequentially. Multiple nodes run in parallel. At peak, you may have 8-12 concurrent LLM calls. This is where you need dedicated GPU infrastructure with low-latency inference and sufficient VRAM for batching. The architecture you pick determines your compute requirements. It is not just a design philosophy - it is a cost decision. The real answer. The graphs vs loops debate was never a binary choice. It is a spectrum. The simplest system is a loop. The most controllable system is a graph. The most effective system is a graph where each node is a loop. Start with a loop. It will get you to production faster than anything else. When you hit the limits - drift on long tasks, no parallelism, impossible to audit - add graph structure around the existing loops. Do not rewrite from scratch. Wrap the working system in a graph. This is what Linear did with Loops. They did not build a graph. They built the simplest, most accessible loop engine and made it work so well that it forced the entire industry to have this conversation. How servergurus helps. Graph loops, agent graphs, and autonomous coding loops all run on GPUs. Its bare metal GPU servers with NVIDIA H200 and L40S give you the VRAM and throughput to run graph-of-loops architectures at production scale. Its cloud GPU instances let you experiment with loop architectures at hourly rates before committing to dedicated hardware.