An interview with Linear’s COO puts agent-written tickets in the spotlight. Here’s how to test whether faster drafting makes intake cheaper without handing the agent control of the backlog.

A customer tells support that an export arrived empty. Under your old process, someone reads the report, checks for an existing issue, and writes up what the next team needs to know. Under the new one, an agent has a ticket ready before anyone opens the inbox. It looks like you saved a step. Then the receiving team asks which date range the customer selected, and support has to reopen the conversation. Where do you put that time on the rollout scorecard?

Latent Space’s interview summary for its episode with Linear COO Cristina Cordova says agents write more than half of tickets. The published excerpt leaves the ticket population unspecified. There’s a useful question here even without a reliable benchmark: when a ticket costs less to write, how do you know whether you made work easier to hand off or just easier to put in somebody else’s queue?

You can answer that with one request stream and a small pilot. Start by following the request rather than the draft. At each handoff, note what someone still has to find out, who spends time finding it out, and who gets to say that the team will act.

The interview’s authorship figure cannot tell you who admitted the work

The original interview’s published summary gives the more-than-half figure, but the available excerpt doesn’t identify the workspace or team, the counting period, or whether a human-approved draft and a directly filed ticket count the same way. It does not establish a company-wide rate. The same write-up says Linear started out building a better issue tracker and notes that CEO Karri Saarinen later published a post titled “Issue tracking is dead.” That juxtaposition makes the role of the ticket an interesting question. It doesn’t answer how Linear reviews its own intake. For your pilot, define the denominator that the interview excerpt leaves open: all incoming requests in one named stream during a specified period, including the ones that never become tickets.

Now take a real request and trace it from the inbox to the point where someone can work on it. Put four verbs on a page: notice, write, admit, commit. Noticing means deciding a message contains something your team might need to look at. Writing means capturing what happened. Admitting means deciding the issue belongs in the receiving team’s queue. Committing means deciding the team will act, possibly by a certain time. A person may do all four today without thinking of them as separate decisions. That’s precisely why you’ll want to label them before handing any of them to an agent.

For the empty export, the agent can preserve the report and identify a possible duplicate. A reviewer can decide whether the report really belongs with the existing issue. The receiving team can then decide whether to investigate now. Write each decision next to the person who owns it. If your team has a rule that admitting a ticket automatically assigns work, admission already carries some of the weight of a commitment. Put agent candidates somewhere else. As a check, show a sample ticket to the person who would receive it and ask what they think they’re supposed to do next. If they say they’d start investigating while you thought they’d merely review a suggestion, you’ve found a mismatch before you’ve put real requests through it. Fix that mismatch before assessing the quality of the prose.

A faster draft pays off only if review and rework stay cheap

Use the same incoming report to lay out the old handoff and the proposed one. Here’s an illustrative example, not a measured Linear result. A customer says a CSV export contained headers but no rows. They provide the export time and a screenshot, but the screenshot doesn’t show the date range they selected. With manual intake, suppose support spends eight minutes reading the conversation, checking for related work, and writing a ticket. Triage takes three minutes. The receiving team then spends two minutes asking support to obtain the missing date range before attempting to reproduce the issue. That’s 13 minutes of staff effort. Count the time waiting for the customer separately; it affects the outcome even if no one is actively working on the ticket.

In an agent-assisted version, suppose support spends two minutes opening and checking the draft, and triage spends four minutes verifying the source and deciding whether it matches an existing issue. The draft marks the missing date range, so triage asks for it before sending the ticket on, at a cost of two minutes. If the next team can use the resulting ticket without another clarification, the total is eight minutes. Now change one detail: the agent silently fills in a date range, triage accepts it, and the receiving team spends nine minutes chasing the wrong conditions and correcting the record. Even without the earlier clarification step, that version costs 15 minutes: two for support, four for triage, nine downstream. Drafting got faster in both versions. Only one saves effort.

For the pilot, require a link to the original report, a short description of what the requester actually observed, and a visible list of missing facts that could change the decision. A suspected duplicate should come with a reason the two reports appear to match and enough evidence for the reviewer to separate them. Don’t require a fully populated form at intake if filling every box would reward guessing. Instead, agree on which blanks can travel with a ticket and which ones need an answer first. Then check with the person who picks up the ticket. Ask what they had to correct, look up, or ask again. If they didn’t have to do any of those things, record that too. Otherwise your measurements will stop precisely where the cost becomes someone else’s problem.

Count the queue the receiving team actually has to work through

There’s a strong case for letting an agent surface requests people previously skipped: a quiet backlog isn’t much use if it stays quiet by losing important reports. But more coverage means more decisions for the receiving team. For a documented example outside Linear, Simon Willison’s account of the PostgreSQL 19 release attributes its later-than-usual arrival mainly to the volume of AI-reported vulnerabilities the team needed to address. That’s a different intake stream, not a trial of agent-drafted Linear tickets. Its relevance is the downstream work: even reports worth acting on can compete with work that was already scheduled.

For one stream of requests, keep a simple intake log. Start with the original messages, then mark which received a candidate and what happened next: accepted, linked to existing work, returned for clarification, or closed with a reason. Review some requests that didn’t get drafted. If you examine only the accepted tickets, you’ll miss both the requests the agent should have surfaced and the time reviewers spent on proposals they declined. Keep request and ticket counts separate. Three customers might describe one problem, while one customer might report two. You want to be able to follow each report to a decision without insisting that the totals match.

Compare the pilot against a baseline from the same kind of inbox. Total active staff minutes from initial reading through the first usable handoff. Separately track time to a reviewed decision and the age of the oldest undecided request. Ask the receiving team to flag extra investigation caused by an intake error, even if it turns up after the initial handoff. When workloads differ, look at routine requests and ambiguous requests separately so that an easy week doesn’t get mistaken for a better process.

Finally, look at what the extra coverage bought you. Sample newly surfaced requests and ask which ones the team would regret missing. If those requests justify additional review, spending more time on intake could be a reasonable choice. Call it better coverage, not a time saving. If the extra review mostly produces duplicate closures while the oldest undecided requests get older, narrow what the agent can submit. The goal is to choose which effort is worth paying for, not to make the authorship percentage go up.

Test where a draft lands before you let the agent file it

Use the Autonomy Spectrum to pick the smallest useful change. At the draft-only end, a person decides what to file and where. One step further, the agent can place a candidate in a review inbox. Further still, it can route certain candidates to a team that has agreed to receive them. Don’t move up the spectrum just because the draft sounds right. Test what happens to a sample item when it lands. Does someone get notified? Does the ticket appear in a planning view? Does the requester get a message that sounds like a promise? If you only watch the agent’s side of the handoff, all three could look like a successful filing.

Make the test specific to the setup you’ll use. In a separate agent product, goose’s published release notes record a fix for passing thinking levels to Gemini 4 and later. That’s primary documentation of a change in goose, not documentation of Linear’s features. The practical lesson for your test is to check what the configured workflow does rather than infer it from a setting. Use a harmless request, inspect the receiving view, and ask the reviewer to describe what action they believe the ticket calls for. Repeat the check after changing a rule that controls who sees candidates or what messages go out.

Keep priority, assignment, due dates, and messages that promise action with the people authorized to make those decisions during the pilot. A customer’s reporting deadline belongs in the draft as evidence of urgency. It is not a date your team has agreed to meet. Name a reviewer who can escalate an urgent report and a fallback for when that reviewer is unavailable. Give reviewers a quick way to return a candidate with a reason rather than quietly rewriting it. If several candidates arrive with unsupported urgency labels, that’s useful evidence about the rule you gave the agent.

If you can’t keep a filed candidate out of views that people treat as committed work, stop at draft-only. That still lets you test the clerical saving. The review queue is a permission boundary only if the people and workflows on the receiving side treat it as one.

Expand one intake rule at a time, with a way back

Start with a rule the receiving team can read in one sitting. Name the incoming stream, the evidence a draft must preserve, the destination, and the person who decides whether to accept it. For export reports, you might allow the agent to propose groups of similar reports, with the originals attached and uncertain matches marked for review. You might exclude requests that arrive without enough context to tell which export the customer means, while leaving those messages visible to support. That last part is important: excluding something from the agent’s remit shouldn’t make it disappear from the human workflow.

Recheck that rule when you change who can submit requests. In a separate product, Willison’s account of ChatPRD founder Claire Vo’s reporting describes groups abusing the product’s free trial for AI usage and other commercial purposes. It’s an observed deployment problem, though not a ticketing rollout or evidence of the same behavior at Linear. It gives you a reason to treat a channel with a different audience as a new pilot. A workflow you’ve tested on requests selected by support shouldn’t inherit the same permissions when you point it at a broader inbox. Keep the original stream available, track where candidates come from, and make it possible to stop automatic submission from the new channel without losing incoming reports.

At the end of your pilot, sit down with a reviewer and someone who receives accepted tickets. Compare total staff effort, queue delay, and the handoffs that needed another round of work. Review both a useful request the agent surfaced and a draft that created unnecessary effort, if your sample contains them. Decide which change you’d make based on the evidence: improve the source material, tighten the admission rule, or go back to draft-only. If the workflow earned an expansion, choose an adjacent stream with similar evidence and repeat the same checks rather than adding several inboxes at once.

The decision to expand should be one the receiving team can explain without referring to how many tickets the agent wrote. They should be able to say which requests now reach them in better shape, what the review costs, and who still has the authority to say yes.

/Sources

/Key Takeaways

  1. The published Linear interview excerpt reports an authorship share without defining the ticket population. Define your own pilot around incoming requests, including those that never become tickets.
  2. Track drafting, review, and downstream rework separately. Measure waiting time alongside active staff effort so a labor saving doesn’t hide a slower response.
  3. Give agents room to propose work and give named people the authority to admit, prioritize, or commit to it. Test what recipients see before expanding access.