Linear Ticket Attributes That Predict Agent Success
Agents need precise tickets to produce reviewable code.

When an AI agent is the one picking up a Linear ticket, the ticket is no longer a note passed between people who share context. It is the entire input: the only channel through which a problem statement, a boundary, and a definition of done reach the system that will write the code. Linear describes itself as "the product development system for teams and agents," built for workflows that run from drafting a PRD to pushing a PR, and that framing makes a quiet but important claim: agents are now assignees in the same sense a teammate is, not a convenience layered on top of human work.
That changes what a ticket's weaknesses cost. A human assignee who hits a vague ticket will usually ask a question before writing a line of code. An agent does not pause to ask; it guesses, fills gaps with assumptions the model finds plausible, or produces a diff that reflects the ambiguity it was handed, literally and without complaint. A vague ticket produces a vague PR. A ticket with hidden scope produces a diff nobody can review with confidence. A ticket with no acceptance criteria produces an argument at review time about whether the work is finished. And because the same ticket drives the specification, the plan, the implementation, and the final PR, any weakness written into it at the start does not stay contained. It appears in every stage that follows and compounds in the thing a reviewer finally has to approve or reject.
Description quality: problem statement, evidence, and desired outcome
The foundation under every other ticket attribute is the description, and the description does its job when it states the problem, the evidence behind it, who is affected, and what outcome would count as fixed. A description built this way hands the agent a bounded task. Leave any of those four pieces out, and the agent inherits an open-ended assignment it will interpret however the model finds most plausible, which is rarely the interpretation the person who filed the ticket had in mind.
Consider the difference between a ticket that says "search feels broken" and one that says users are abandoning search after a specific action, backed by a cluster of support messages logged over a short window, affecting a named segment of users, with a stated outcome of what "fixed" looks like. The first is a symptom with no evidence, no scope, and no way to know when to stop. An agent assigned to it will explore the codebase until it lands on a guess or runs out of session budget trying, while the second version names a concrete claim the agent can check its work against.
This is not a hypothetical failure. The Jan IngenHousz Institute's open-jii project documented it directly in a GitHub issue filed in September 2026, numbered 2085: ten recently written agent tickets came back unreadable, forcing the team to enforce a minimum prose and structure standard as a gate before any ticket could be assigned to an agent. A description without a problem statement, evidence, and a stated outcome gives an agent nothing to anchor to, and no amount of model capability fixes that on the agent's side of the handoff.
Explicit, verifiable acceptance criteria
A good description tells an agent what the task is. Acceptance criteria tell it, and the human reviewing its output, when the task is done. This is the single attribute practitioners point to most often as the line between a ticket an agent can finish cleanly and one that ends in a dispute at review time, because even a well-described problem leaves open the question of what "solved" means in practice.
When acceptance criteria exist only in someone's head rather than written into the issue, the agent has nothing to be graded against. It will stop when its own internal sense of completeness is satisfied, which does not reliably match what the person who filed the ticket wanted. That produces the same conflict a vague description produces, just one step later in the process: a PR lands, and the reviewer and the ticket author discover they disagree about whether it does what was asked.
The format most often recommended for writing criteria follows a simple pattern borrowed from behavior-driven development: given a precondition, when an action happens, then a specific outcome follows. This "Gherkin" structure reads naturally to a human and parses cleanly for a machine, which is why agents tend to handle it well. The format itself is not the point. What matters is that it forces the criteria to be observable and bounded: "onboarding works" tells nobody anything concrete, while "given a new user completes step 3, when they reach the dashboard, then the welcome modal appears exactly once" can be checked by someone who has never opened the code.
The strongest objection to this approach is that acceptance criteria can swell a ticket past the point of usefulness, especially once a template invites teams to pile in rationale, a record of rejected alternatives, and notes on how something will be measured. That material has value, so it belongs in a separate document, a PRD, linked from the ticket. Criteria work because they stay observable and bounded. The moment they also try to carry the full argument for why the work matters, they stop functioning as a stopping condition and turn into a second description.
Scope definition: in and out
A ticket can describe the right problem and carry precise acceptance criteria and still go wrong if nobody states where the task ends. An unstated boundary reads to an agent as permission to extend the work in whatever direction seems locally reasonable, and an agent has no way to flag that its own reasonable-looking extension might violate an assumption somewhere else in the system. Out-of-scope is a constraint that catches a category of error the agent cannot catch on its own.
This is where tribal knowledge becomes a real liability. A fix that looks complete and correct within the service it touches can break an assumption three services away, one that nobody wrote down because every human on the team already knew it. An agent has no access to what lives only in people's heads. Writing an explicit out-of-scope line into the ticket is the mechanism by which that unwritten knowledge becomes available to a system that can only read what is on the page.
Some work remains a poor fit for agent delegation no matter how well the ticket is written, because changes that touch architecture or cross-service contracts resist having their scope made explicit enough to be safe: the relevant boundaries are often too distributed to list. The right move in those cases is either to cut the ticket down into a narrower, genuinely bounded sub-task, or to keep the work assigned to a person. Scope signals are not just useful to the agent doing the work, either. Machine learning models can already predict a ticket's likely resolution time, the share of comments that will turn technical, how many subject matter experts a task is likely to need, and a tiered complexity rating from L1 to L3, which means scope information embedded in ticket structure is legible to automated systems well beyond the one assigned to the work. And a ticket with scope left unstated produces an unreviewable diff even when the underlying code is correct, because a reviewer cannot approve a PR whose boundaries cannot be reconstructed from the ticket that spawned it.
A description built this way hands the agent a bounded task.
File and code path references as executable precision
Scope defines how much work a ticket should produce. Naming the specific file, flag, or symbol defines where that work should happen, and it is the most concrete form specificity can take. A ticket that names the right file turns "find the relevant code" into "make this change," which is the difference between a session that starts producing useful output immediately and one that spends most of its time orienting itself inside a codebase it has never seen before.
The agentic triage pattern built on Linear's MCP shows this in practice. The agent searches the codebase for related symbols, then posts a comment naming which files are involved before it suggests a priority level. The file references are not a side note in that workflow; they are the basis for everything the agent recommends afterward. A reviewer reading a PR checks the problem statement, the acceptance criteria, and the file anchors together, and dropping any one of the three weakens the signal even when the other two are solid.
Not every ticket can name a file, and that is a fair objection. A feature ticket or an exploratory task may not have a known entry point in the code. For those, the equivalent attribute is a pointer to the relevant module, the service boundary in question, or the section of a PRD that defines the work. The precision looks different, but the underlying principle holds regardless of what form it takes: name the most specific anchor available, and the agent's work gets measurably easier to start and easier to check.
Priority signals and labels: the attributes agents use to triage at scale
Everything up to this point concerns a single ticket and a single agent session. Priority and labels operate at a different level: they govern which tickets get picked up at all, and in what order, across an entire queue. Get those wrong and the damage is not confined to one bad outcome. It spreads across every ticket competing for the same attention.
Handing an agent the ability to set its own priorities without commercial context invites a specific failure: the loudest complaint in a queue is not always the one that matters most to the business, and an agent reading ticket text alone has no way to know the difference between urgent and merely vocal. Priority has to carry judgment that comes from outside what is written in the issue. Linear's AI tooling already suggests labels, projects, assignees, teams, and related issues as part of the workflow, and custom labels applied consistently turn into filters that make automated routing dependable. Applied inconsistently or left at their defaults, the same labels make routing unreliable in ways that are hard to detect until a ticket surfaces in the wrong queue.
A team running agentic triage tracks every case where the agent's suggested priority disagrees with what a human ultimately assigns, and feeds that gap back into an evaluation suite on a weekly basis. That treats triage accuracy as something to measure and improve on a recurring basis, because priority and label quality degrade on their own if nobody is watching them, the same way code quality degrades without review.
How poor ticket attributes compound when agents work at volume

At scale, weak ticket attributes compound into a structural drag on the whole development process, because what wastes one agent session multiplies across a queue. A single vague ticket wastes one agent session. A queue full of them generates a backlog of PRs that cannot be reviewed quickly, because the correction work that should have happened at the ticket stage gets pushed downstream into the review stage instead, where it is slower and more expensive to fix.
Poor ticket structure does not just make an agent slower. It invalidates the output outright: a vague description does not produce a PR that needs a few minor tweaks, it produces a PR that cannot be reviewed as written, full stop on the substance if not the phrasing. For a well-specified bug report, an agent can return a working diff before a reviewer finishes a cup of coffee. For a vague one, the person steering the agent and re-explaining the task ends up spending more time than they would have spent simply writing the fix by hand. That is not a ticket costing someone an extra hour. That is a session with negative return on the time invested.
The open-jii case makes the same point at the scale of a full queue. GitHub issue 2085 reported that 44% of open tickets in that system had no type assigned at all, on top of the ten unreadable agent-written tickets already noted. The fix the team put in place was not a note asking people to write better tickets going forward; it was a six-label facet system paired with two quality gates, built to enforce a minimum structure before any ticket could reach an agent. That is a system-level remediation, which is the right scale of fix once the problem has moved from "one bad ticket" to "a queue that cannot be trusted."
Linear's own 2026 usage data points at the same pattern from a different angle: as more work routes through agents, the time engineers spend creating, triaging, and commenting on tickets has gone up. More coordination becomes necessary precisely because more of the work depends on context that used to live in a hallway conversation and now has to be written into the ticket instead. That coordination overhead is the price of underspecified context, paid in engineering hours.
Where over-specification and agent limitations set the real ceiling
None of this argues that more detail in a ticket is always better. Acceptance criteria that try to carry a full rationale, a list of rejected alternatives, and a measurement plan stop being bounded and start reading like a second document grafted onto the first, which slows down the human writing the ticket without making the agent's job any clearer. The fix described earlier, keeping rationale in a linked PRD rather than inside the criteria themselves, exists precisely because more text is not the same thing as more precision.
There is also a category of work where no amount of ticket quality closes the gap. Tickets that touch architecture or cross-service contracts resist having their scope written down completely enough to be safe for an agent to act on alone, because the relevant constraints are often scattered across systems and spoken agreements that no single ticket can fully capture. The honest response to that limitation is to narrow the ticket into a smaller, genuinely boundable task, or to leave the work with a human, rather than to keep adding detail to a ticket in the hope that enough specification will eventually substitute for judgment it cannot carry.
As agent capability on real-world computer tasks has improved, the gap between what an agent could do and what it actually delivers increasingly traces back to the ticket. That shift matters because it changes where teams should put their effort. Better models will keep arriving on their own schedule. Better tickets are available immediately, and they are the lever a team actually controls.
Sources
- Linear
Provided Linear's self-description as 'the product development system for teams and agents' and context for how the platform positions itself for agentic workflows.
- How teams build
Supplied Linear's 2026 usage data showing that as more work routes through agents, engineers spend more time creating, triaging, and commenting on tickets.
- How we built Triage Intelligence
Described Linear's AI triage tooling that suggests labels, projects, assignees, teams, and related issues as part of the workflow.
- Triage new issues by investigating bugs ...
Described the agentic triage pattern where an agent searches the codebase for related symbols and posts a comment naming which files are involved before suggesting a priority level.