5 Rules for Building AI Agents That Work in Production | Nan Yu & Jacob Shumway

频道: Peter Yang
视频: https://www.youtube.com/watch?v=4mKtJzfGj0U
原文语言: en
统计: 共 122 轮 · Peter 44 · Jacob 22 · Nan 47 · Nan Yu 1 · Peter Yang 1

[0:00]

The models are really smart, but we're just not using them enough. If you overprompt these things, you're more likely than not going to make it worse.

模型其实非常聪明，只是我们远远没把它们用够。你要是给它堆太多 prompt，多半反而会把效果搞砸。

[0:07]

Give it as little instruction as possible. Give it the tools to load context. Don't give it context.

指令给得越少越好。给它能自己去加载 context 的 tool，而不是直接把 context 喂给它。

[0:13] Peter

Here's all the context. Just figure out what the right thing is. Write the issue and work on it. Linear made the issue. Took 6 minutes and then it gave us a PR that we click run. You have [music] to really break down what is the actual workflow that your users want to do. Computers can do a lot of work for us. So let's get rid of all the work we don't want to do and give it to computers. All right. Hey everyone. Today I'm really excited to welcome Naan and Jacob from Lineer do a special episode. We're going to do a deep dive on how to build a production agent end to end and how it actually works and we're going to use Linear's own agent as an example to keep the discussion concrete and real. So welcome guys. Yeah, good to be here. All right. So why don't we start at the super high level. Can you kind of demystify this whole agent thing? What does the explain like on five version of what an agent is?

「这就是全部 context，你自己判断该做什么。」写好 issue，然后直接开工。issue 是 Linear 自己建的，花了 6 分钟，然后它给了我们一个 PR，我们点一下就能跑。你必须真正拆清楚：你的用户到底想走完一条什么样的工作流。计算机能替我们干很多活，那就把所有我们不想干的活都甩掉，交给计算机。好，大家好。今天特别高兴请到 Linear 的 Nan 和 Jacob，来做一期特别节目。我们要从头到尾深挖一下：一个能上生产环境的 agent 到底该怎么造、实际是怎么跑起来的，并且拿 Linear 自家的 agent 当例子，把讨论落到实处。欢迎两位。—— 很高兴来。好，那我们先从最高层面聊起。你们能不能先给 agent 这件事祛个魅？用五岁小孩都能听懂的方式讲讲，agent 到底是什么？

[0:59] Jacob

Yeah, sure. Um, I can answer that one. So, at a high level, an agent is really just calling an LLM in a loop. Um, normally when you call an LLM, you're going to give it one question, you're get one answer back. But we want agents to be really autonomous and be able to accomplish more complex tasks. So, typically what you'll do is you'll define a goal, some milestone for the agent to hit, and you'll give it tools that allow it to build its own context, and then just run it in a loop. Question, answer, question, answer. On each turn, it's going to call tools, pull context in, and eventually it's going to hit a point where it has enough information to consider the goal accomplished. It'll it'll like synthesize this final response and send it back.

行，这个我来答。往大了说，agent 其实就是把 LLM 放进一个循环里反复调用。平常你调 LLM，是问一个问题、拿一个答案。但我们希望 agent 足够自主，能搞定更复杂的任务。所以通常的做法是：你定一个目标、一个让 agent 去够的里程碑，再给它一批 tool，让它自己去搭建 context，然后就让它在循环里跑——问、答、问、答。每一轮它都会调 tool、把 context 拉进来，跑到某一步，它掌握的信息够了、认为目标达成了，就会把最终答案综合出来返回给你。

[1:40] Peter

Got it. Okay, that that makes sense. Yeah, it's it's basically a model using tools running on a loop. That's kind of that's kind of like the one.

懂了，这个讲得很清楚。说白了就是一个模型带着 tool 在循环里跑——大概就是这么回事。

[1:47] Peter

Yeah. Okay, cool.

嗯，好，明白了。

[1:49] Peter

Um Okay, then let's talk about the linear agent. Maybe now you can show us like the initial idea behind this thing and then like now what it's kind of evolving to.

那我们来聊聊 Linear Agent。要不你们先讲讲这东西最早的想法是什么，然后再说说现在它演变成了什么样。

[1:57] Nan

Yeah. Yeah. I I think you know I I I think it's actually pretty interesting to expand on Jacob's answer a little bit, right? Because you know you we you we asked the question and I I think that that is like the the correct sort of technical definition. You know, you're asking engineers what they're going to say. Um, but I also think that when we talk about agents like colloquially, you know, we think of them as like products, right? It's like it's like a packaging of some sort of uh AI loop plus some other stuff. And I think ultimately these things are like a bunch of different subsystems that are all, you know, interacting and then there's like one facade, right? It could be a chatbot or something like that that that kind of fronts all of it. So, you know, you if even if you think of like the the desktop agents people use, there's they have all sorts of stuff built into them like schedulers and uh and and these these other sort of like side uh you know, tertiary kind of features or they're all kind of part of the agent as a product too, right? So, I I think we kind also have to think about it from that perspective.

对。我觉得可以在 Jacob 的答案上再稍微展开一点。你问的这个问题，他给的是那个正确的技术定义——你问工程师，他们就会这么答。但我觉得我们日常说 agent 的时候，脑子里想的其实是产品：它是把某种 AI 循环，再加上一堆别的东西，打包在一起。说到底这些东西是一堆互相协作的子系统，外面套了一层门面——可能是个聊天界面之类的，把底下所有东西都挡在后面。所以你看大家在用的那些桌面端 agent，里面塞了各种东西，比如调度器，还有一堆边角料功能，这些同样是「作为产品的 agent」的一部分。所以我觉得我们也得从这个角度去理解它。

[2:52] Peter

True. True. Yeah. Yeah. Sure. Do you think about all this when you had the initial idea or like what is your initial spec or

有道理。那你们最初有这个想法的时候，就已经想到这些了吗？还是说一开始有份什么 spec？

[2:58] Nan

Yeah. Yeah. Sure. So, I I'll show you right now. I was working with Jacob the other day. I'm like I dug this up. This is a memo I wrote in like if you look it's like the second half of uh 2025, right? So it's like not that long ago in human time, but in like AI time it's it's you know ancient history. Um and and I I think on on here, you know, you'll you'll see like there's a lot of focus that we had on like like computers can do a lot of work for us. So let's get rid of all the work we don't want to do and give it to computers, right? Like that that's like the central sort of central thesis of this thing. And uh it's you know and we kind of structured this idea about um you know before we really had this sort of technical idea in our head. We had this idea about like there's some kind of triggering event and there's some context that happens and you have instructions and it kind of loops on on actions and then and ends with some kind of result. Right? So like we we we already had this sort of concept but I I think what we uh we were just we we weren't like ambitious enough like we did we didn't think it could do like really interesting things. were like, "Hey, let's give, you know, let's create this agent thing." We call it, you know, we gave it a really like robotic name. It's like robotic program manager with the idea, right? And and just give it the boring stuff, right?

有，我现在就给你看。前几天我跟 Jacob 一起把它翻出来了——这是我写的一份 memo，你看时间，大概是 2025 年下半年。按人类的时间算没过多久，但按 AI 的时间算，已经是远古史了。你在这上面能看到，我们当时的重心是：计算机能替我们干很多活，那就把所有我们不想干的活都甩给计算机。这就是整份东西的核心论点。我们当时其实还没形成什么技术方案，只是先有了一个结构上的雏形：有某种触发事件，有一段相应的 context，有一套指令，然后它在一连串 action 上循环，最后给出某种结果。这个概念我们早就有了，但我觉得我们当时不够有野心——我们没想过它能做出多有意思的事。我们的想法就是：诶，咱们搞个 agent 吧。名字起得特别机器人，叫「robotic program manager」，思路就是把那些无聊的活丢给它。

[4:08] Nan

And and I I think that what what we what's changed, right, about how we think about it today, right, which, you know, we're in the second half of 2026, so it's literally just a year later. Uh is that we we don't think of just giving it the boring stuff. Sure, you're going to give the boring stuff, but also there's it opens up a lot of like the creative possibilities, right? Where where you can do it interactively and and uh and and it could be a big force augment for like interesting work, right? Not just not just the boring stuff.

而今天我们的想法变了。现在是 2026 年下半年，也就整整过了一年。变化在于，我们不再只想着把无聊的活丢给它。无聊的活当然还是要给，但它同时打开了很多创造性的可能——你可以跟它交互式地一起干活，它能成为有意思的工作的强力放大器，而不只是处理杂活。

[4:33] Peter

I don't want to offend anyone, but I feel like um technical program manager is like one of the most boring jobs do. You're literally just [laughter] like managing spreadsheets, trying to track tickets and stuff, right? So So this is what the agent started with, right? But but now it can do now it kind of serve multiple hats kind of do end to end product development, right?

我不想得罪谁，但我总觉得技术项目经理大概是最无聊的岗位之一。你基本上就是在管表格、追 ticket 之类的。所以这个 agent 最早就是从这儿起步的，但现在它已经能身兼多职，甚至端到端地做产品开发了？

[4:50] Nan

Yeah. Yeah. Exactly. And and and depending on you know what you use it for and the context that you kind of put into it. It can do all sorts of very you know creative things that we at that point we just like didn't even think was uh a reasonable thing to expect, right? And things have moved very quickly.

对，没错。而且取决于你拿它干什么、你往里放什么 context，它能做出各种非常有创造性的事——这些在当时我们根本觉得不该指望。事情推进得太快了。

[5:05] Peter

So I'm really curious what your process is. So you wrote this memo back in uh third quarter and then uh Jacob just build it in a couple days or what was the [laughter] process? Yeah. That was the process.

我特别好奇你们的流程。你在第三季度写了这份 memo，然后 Jacob 花几天就把它做出来了？流程就是这样？—— 对，就是这么个流程。

[5:16] Peter

Yeah. What was the next step to to actually build this thing to prototype it or like play with it?

那下一步具体是怎么把这东西做出来的？先做原型，还是先拿来玩玩看？

[5:20] Nan

Yeah.

嗯。

[5:21] Nan

Jake, what was it the first version of this that we actually built from here?

Jake，我们从这份 memo 出发，真正做出来的第一版是什么样的？

[5:25] Jacob

The first version was was really prototypy. It was like we were calling the LLM from the front end directly

第一版特别原型气，我们是直接从前端调 LLM 的。

[5:33] Jacob

and it was just flagged internal and we like we gave it access. We have our command menu with all our actions. We gave it access to those as tools and we're just like let's see what this can do. It was It was really hacky.

而且只挂了个内部开关。我们有个命令菜单，里面是我们所有的操作，我们就把这些操作当成 tool 给了它，然后想看看它能干出点什么来。做法真挺糙的。

[5:44] Peter

Mhm.

嗯哼。

[5:45] Peter

This episode is brought to you by Oceans. I hired someone through Oceans for podcast post-production a few months back and can't imagine running the podcast without [music] his help. He's proactive, picks up new tools fast, and uses AI to compound everything that he ships. Oceans doesn't just [music] place assistants, they place operators. The talent is AI fluent and delivers the same output as a senior US hire at 3 to [music] 5x less cost. They reject 99% of applicants. So the person who lands on your team is already operating from day one. If you're scaling and need marketing, [music] ops, finance, or EA help, I highly recommend giving Oceans a try. Check it out at oceansalent.com/ [music] Peter. Now back to our episode.

本期节目由 Oceans 赞助。几个月前我通过 Oceans 招了一个人做播客后期，现在已经离不开他了。他很主动，上手新工具很快，还会用 AI 把每次交付的成果不断叠加放大。Oceans 不只是给你派个助理，它派的是能独当一面的操盘手。他们的人才都懂 AI，产出水平跟美国本土的资深员工相当，成本却低 3 到 5 倍。他们会刷掉 99% 的申请者，所以最终进你团队的那个人，第一天就能直接干活。如果你正在扩张，需要市场、运营、财务或行政助理方面的支持，我强烈推荐你试试 Oceans。访问 oceanstalent.com/Peter 了解详情。好，我们回到节目。

[6:25] Peter

Right now you can like, you know, push code, you can manage tickets, ingest stuff, but like what were some of the initial use cases that kind of popped out that that like, you know, you wanted to prioritize first?

现在它已经能提交代码、管 ticket、吸收各种材料了。但最早冒出来的那些用例里，哪些是你们想优先做的？

[6:34] Jacob

I think it it was simple things. I think creating issues like it's such a simple thing but I think that was one that surfaced really early is useful actually [snorts] writing documents that sort of thing.

我觉得都是些很简单的事。比如创建 issue，听上去特别简单，但这是很早就浮出来、而且确实有用的一个。还有写文档之类的。

[6:45] Nan

Yeah. I I I think one of the first like real um use cases that we knew about that we knew people wanted to do was they would have uh you know this is again this is like maybe even before everyone had uh you know automatic note takers for everything right like people were still like handwriting notes and things like that. they were like, "Hey, I I I hand I I wrote some notes on the sales call and they they said a bunch of stuff. Can I just dump this in there and just extract out, you know, like the issues that we need to build, right, for this or the bugs that were reported or or those kinds of things, right?" So, like it it was that, you know, that that was the very basic operation that we're like, "Okay, if we let's get that because like I know that's valuable. People have directly asked for that. That's something that we felt, you know, in our own workflows. So, if we can get something working that can achieve that, like that's a that's a reasonable starting point, right? For us, it's it's we didn't even know if it was going to be uh we're going to have a chatter interface, right? We're like like there there's some place to just dump a bunch of text and maybe, you know, maybe it's just like a a text field or something like that and you you just hit submit and it goes, right? So maybe maybe it looks more like that. So I I think it was it was very open-ended, right, when we when we first started, which is also why we don't have like a super robust spec for it, right? Like we didn't go into this thinking that we knew exactly what we needed to build. We just we're just like here's some experiments that some directions we could try and let's just do it.

对。我觉得我们最早知道、也确实知道大家想要的真实用例之一是这样的：那还是在人人都用自动记录工具之前，大家还在手写笔记的年代。他们会说：诶，我在一通销售电话里手写了一些笔记，对方提了一堆事，我能不能把这些整个丢进去，然后把该做的 issue、报上来的 bug 之类的抽出来？这就是最基础的那个操作。我们当时想，好，那先把这个做出来，因为我知道它有价值，有人直接提过这个需求，我们自己的工作流里也确实有这个痛点。所以只要能做出个东西把这件事完成，那就是个合理的起点。我们那会儿甚至不确定要不要做成聊天界面，只是觉得得有个地方能把一大段文字丢进去，可能就是一个文本框之类的，你点提交，它就跑起来。说不定长得更像那样。所以最开始其实非常开放，这也是为什么我们没有一份特别完备的 spec——我们进这件事的时候，并不觉得自己清楚该造什么。我们只是说：这儿有几个实验、几个可以试的方向，那就动手做吧。

[8:01] Peter

Yeah. So you launched it on Slack or something for people to use internally.

所以你们是先在 Slack 上放出来，给内部同事用？

[8:04] Nan

Yeah. So the the the first production version of this we we launched uh sort of secretly right without like really telling anybody that uh because we we already had a Slack integration and Slack you could always mention bots right we everyone knows you know like things like donut and things like that where you know it's it's all very procedural and like they're like these different Slack bots. Uh so you could mention linear before and you know it give you like a form or something like that and uh we we just like silently hooked it up to this right we're just like okay we're just going to do it and then if anyone discovers it by app mentioning in linear they can start talking with it and then you know they can they can do whatever they want and and a lot of uh like a lot of usages for it emerged that we didn't even expect and like that that was and like we we sort of had the inkling that that's what would happen right is that people would do things and like the obvious thing would would be something like hey linear make an issue to and then you would describe it in a natural language and it would do it. But people started realizing that because they could read the context, they could just say something like linear do the right thing or like look at what we just did, right?

对。第一个生产版本我们是偷偷上的，基本没跟任何人说。因为我们本来就有 Slack 集成，而 Slack 里一直可以 @ 各种 bot——大家都知道 Donut 那类机器人，都是很流程化的东西。以前你在 Slack 里 @ Linear，它会给你弹个表单之类的。我们就悄悄把它接到了这套 agent 上，心想：行，就这么干，谁要是 @ 了 Linear 发现了，就可以直接跟它对话，然后爱干嘛干嘛。结果冒出来很多我们完全没预料到的用法。当时我们其实隐约觉得会这样：最显而易见的用法是「Linear，帮我建一个 issue，内容是……」，然后你用自然语言描述，它就照做。但大家开始意识到，既然它能读到 context，那干脆就说一句「Linear，看着办」，或者「你看一下我们刚才干了啥」。

[9:05] Nan

Or just like something extreme, you know, you can be super lazy,

或者更极端一点，你可以懒到极致。

[9:08] Nan

right? Like people will be like, oh, I just say at linear and then upwards pointing finger emoji, right? Like it's like they they do those kinds of things and then linear will just

有人就直接 @Linear，后面跟一个向上指的手指 emoji。他们就这么玩，然后 Linear 就会……

[9:15] Nan

reason through like what happened? Like I I know how to create issues. it looks like there's some issues name so I'm just going to make some issues and then and then tell the user that I did that right so like it it this kind of like behavior was actually very emergent and and we we didn't expect it to be able to do this

……自己推理：刚才发生了什么？我知道怎么建 issue，看起来这里有几个 issue 的名字，那我就建几个 issue，然后告诉用户我建好了。所以这类行为其实是涌现出来的，我们完全没料到它能做到这一步。

[9:29] Peter

interesting okay so just so understand you built this thing and and like kind of get the model you made the model aware of all the internal APIs that has or something people can use the UI for the model can also do

有意思。我确认一下我的理解：你们做出这东西之后，相当于让模型知道了内部所有的 API——凡是人能在 UI 上做的事，模型也都能做？

[9:39] Peter

and they just kind of let it loose let loose for people to try

然后你们就直接把它放出去，让大家随便试。

[9:42] Nan

yeah effectively I mean I think Jake we could probably talk about like you know we tried certain techniques at first and then we sort of landed on on a version of it that have now

基本上是这样。我觉得这段 Jake 可以聊聊——我们一开始试过几种不同的做法，最后才收敛到现在这个版本。

[9:50] Jacob

we tried to give it essentially just like everything you can do in linear which is a lot of different actions um across all the different surface and we ran into just like context issues and hallucination uh we tried things like let's give it our graphql schema and see if it can write queries um and that that didn't work really well and we kind of ended up on a skills type of setup where

我们最早是想把 Linear 里能做的所有事情全都给它——那是横跨各个界面的一大堆动作。结果直接撞上了 context 爆掉和幻觉的问题。我们也试过把 GraphQL schema 丢给它，看它能不能自己写 query，效果也不理想。兜兜转转，最后落在了一套 skills 式的架构上。

[10:11] Jacob

we we give it the act the ability a tool essentially to load skills and then it based on the request it'll just load up the different skills that it needs and that comes with a set of tools and instructions around that.

我们给它一个专门的 tool，让它有能力去加载 skill。它会根据请求自己判断需要哪些 skill 并加载进来，而每个 skill 自带一组配套的 tool 和使用说明。

[10:24] Peter

The skills are defined by you guys like create ticket skill or like you know

这些 skill 是你们自己定义的？比如「创建 ticket」这种 skill？

[10:29] Jacob

because we we have opinions on how different things work. You know, if you're writing an issue, how do you think about setting a priority and how do you think about writing the description? So, we encode all of that in these skills.

对，因为我们对很多事情该怎么做是有自己主张的。比如你要写一个 issue，优先级该怎么定？描述该怎么写？我们把这些全都编码进了这些 skill 里。

[10:39] Peter

Got it. Okay, that makes sense. Okay.

明白了，这讲得通。

[10:40] Nan

Yeah, I I I think that that's you know when you when you have a native agent like this, right? Like people talk a lot about like, hey, they build a CLI or they build MCP or something like that and it comes with a bunch of skills for how to use it. When you build a native agent, you can go bug wild with this, right? You you could have hundreds of these things and because you have dynamic loading and you have control over how everything works. Like you can have a very smooth and opinionated way of how it uses your app. And I I think that this is one of the big advantages of having a native agent, right? It's like it's like you can you can just bring you can just treat it like a like a power user of the app. there's no there's no uh variance right in in in doing that. So I think that that's that's what we that's where we ended up and then because it can just you know run a loop and decide what tool calls to make and stuff like that. It it all of this emergent behavior about just being super lazy when you app mention it. It'll just figure out the right thing to do just kind of came out.

我觉得，当你做的是这种原生 agent 的时候——大家经常讨论的是，有人做了个 CLI，或者做了个 MCP，再配上一堆 skill 教你怎么用它。但当你做的是原生 agent，你可以彻底放开了折腾：你可以有上百个这样的东西，因为你有动态加载，整套运行机制也都在你自己手里。你能让它以一种非常顺滑、非常有主张的方式来使用你的产品。我觉得这正是原生 agent 的一大优势——你可以直接把它当成这个 app 的资深重度用户来用，中间不会有任何走样。所以我们最后就停在了这个方案上。再加上它能自己跑循环、自己决定调用哪些 tool，于是就冒出来一堆涌现出来的行为：你在 app 里 @ 它的时候可以特别偷懒，它自己就能想明白该做什么，这些都是自然长出来的。

[11:29] Peter

Can you guys show us well the product is pretty polished now but can you guys show us some examples of like tagging linear in Slack in different channels and see see what it does?

你们能给我们演示一下吗？我知道现在产品已经打磨得挺完整了，但能不能给我们看几个例子，比如在 Slack 的不同频道里 @ Linear，看看它会做什么？

[11:38] Nan

This is a conversation we just had. there's some behavior that you know I'm like look this looks a little weird and I I so like here here's the pattern right it's like it's very natural we have a conversation in Slack and I'm like tagging our designer Yan and Jacob right and and about maybe some suggestions about what we can do here and we're we're trading

这是我们刚刚才发生的一段对话。里面有些行为我当时看着还觉得有点怪。这个模式很典型、也很自然：我们在 Slack 里聊天，我 @ 了我们的设计师 Yan 和 Jacob，讨论这块可以怎么改，大家来回抛想法。

[11:55] Nan

ideas right it's not like we have some exact sense of what we want to do right now right like we're like hey like this feels bad here maybe I'll try these things and then you know designer like kind of gives his opinion here and then I I try to clarify right? You were like kind of finding where you know where the actual problem is. Um and you know Jacob uh you know raises a uh an objection and I'm like look we can just here here's my how we want to address that objection. So like we're like finding the truth so to speak and you know at the end of the day like the message is just like just do it right like at linear create [laughter] issue for me I'm going to just I want to hold on to it and then just and then now that linear can write code just just do a pass like I I'll take a look at what you did right like previously it was just make an issue for me but here's all the context just figure out what the right thing is like we we argued about a bunch of stuff we came we ended up somewhere

就是在互相碰想法，并不是说我们当下已经很确切地知道要做什么。更像是「这里感觉不太对，也许可以试试这几个方向」，然后设计师给出他的看法，我再澄清一下——其实是在一点点找出真正的问题到底在哪。然后 Jacob 提了个反对意见，我说「行，我打算这么解决这个问题」。所以我们是在「找真相」的过程里。而到最后，那条消息其实就一句话：直接干吧——@Linear，帮我建个 issue（笑）。我想把这件事留住、不让它跑掉。而且现在 Linear 已经能写代码了，那就顺手做一版，我回头看看你做成什么样。以前只是「帮我建个 issue」，但现在是：这里是全部的上下文，你自己想明白正确的做法是什么。我们刚才争论了一堆，最后落到了某个结论上。

[12:50] Nan

so like figure out what somewhere is and then write the issue Now it's write the issue and work on it. So then linear uh you know made the issue there's a decision you know and then it's um it's assigne is Jacob and it delegated to itself right and then uh that was 18 minutes ago it took six minutes and then it can gave us a PR that we can click through right so like this was the whole sort of loop of of here's an idea and then we talked about it and we figured out you know hopefully where we got to and then linear sus it all out and then and then made a PR

所以就是：你自己搞清楚那个「结论」是什么，然后把 issue 写出来。现在不光是写 issue，还要顺手把活干掉。于是 Linear 建好了 issue，里面记下了那个决策，负责人是 Jacob，然后它把任务委派给了自己。这是 18 分钟前的事，它花了 6 分钟，最后给出一个我们可以点进去看的 PR。所以整个闭环就是：先有一个想法，我们聊一聊，大致达成共识，然后 Linear 把这些理清楚，最后开出一个 PR。

[13:22] Peter

interesting and then and then now you can just go in here and like play with it and see if it's actually a good idea or not, right?

有意思。然后你就可以直接进去玩一玩，看看这个想法到底靠不靠谱。

[13:26] Nan

Yeah, you can play with it and see if it's a good idea or not. And and importantly, right, like because it's part of like the linear system, like this is in Jacob's backlog, like it's in his, you know, status to-do, right? So, it's in his personal backlog, like he doesn't lose track of it. You know, if if it was just stuck in Slack, it would just be like, you know, you have more chats and then all of a sudden you just lose track of it and then, you know, you would,

对，你可以进去试试看它是不是个好主意。而且很重要的一点是：因为它本身就是 Linear 系统的一部分，这个东西现在就在 Jacob 的 backlog 里，状态是 To-do，在他的个人 backlog 里，他不会把它弄丢。如果这事儿只停留在 Slack 里，消息越来越多，一转眼就找不着了，然后你就只能——

[13:46] Nan

you know, kind of cross your fingers with search or hope that someone remembers it or something like that, right? So like the actual tracking like aspect of this is still matters, right? You you know because you have it in an organized backlog that's in the right project and everything. So that's that's that's that's the ultimate result, right? When you think about like what is linear's goal, its goal is to like put a ticket in the right place and also, you know, accomplish the task and and uh maybe this is actually kind of interesting. It is like an interesting product principle. So even though linear actually did a work, it's assigned to Jacob. Is is it like a principle like every agent has to be tied to a human? the the the vast majority of them are right like there's going to be situations where um you know it's it's really you know the the system effectively invokes itself right if like you know if you're if you instrumented like a data dog or something like that there was an alarm that tripped and it threw a you know put a bug into the system and then linear try to solve it like there's not no one really touches it until the very end.

——只能靠搜索碰运气，或者指望有人还记得。所以「追踪」这件事本身依然重要：它躺在一个有组织的 backlog 里，归在正确的 project 下面。这才是最终真正的结果。你想想 Linear 的目标是什么——把 ticket 放到正确的位置，同时还要把活干完。说到这儿其实有个挺有意思的产品原则：虽然活是 Linear 干的，但这个 issue 是分配给 Jacob 的。这是一条原则吗，每个 agent 都必须挂在一个人身上？绝大多数情况是这样。当然也有些场景是系统自己触发自己：比如你接了 Datadog 这类东西，某个告警被触发，往系统里丢进一个 bug，然后 Linear 去尝试解决，一直到最后一步之前都没人碰过它。

[14:37] Nan

So at that point you're relying on the agent to figure out who should review the code right all the way there. this is you know for something like this like someone made a decision to like do this right in this case it was Jacob who's like okay cool I think we have enough information now let's let's work on this right so like that that way he he he he has a handle to it and it's attributed to him

到那种时候，你就得完全依赖 agent 自己判断该找谁来 review 代码，全程都是它在推进。但像刚才这个例子，是有人明确做了决定要往前走——这次是 Jacob，他觉得「好，信息够了，我们来做这个」。这样他就握着这件事的把手，责任也归到他身上。

[14:56] Peter

got it okay what kind of information and context can this agent access uh like obviously all the tickets in line can read slack and stuff or like you hook up to you know gone and every everything else yeah

明白了。那这个 agent 能拿到哪些信息和 context？显然 Linear 里所有的 ticket 它都能看，它还能读 Slack 之类的吗？还是说你们还给它接了一堆别的东西？

[15:08] Nan

uh yeah so this this was this context was just from slack from this thread, right? So, it can read Slack and and I I think a lot of the

对，刚才那个例子里的 context 就只来自 Slack，来自那个 thread。所以它能读 Slack。我觉得很多——

[15:16] Nan

a lot of the benefit comes from stitching all this together,

——很多价值其实来自把这些东西串起来。

[15:19] Nan

right? Like Slack by itself isn't enough. But if you combine Slack with the ability to read your codebase with the ability to read like you know your project description and your other tickets and stuff like that, then all of a sudden you can do something, right? Because like what could have happened here was uh you know we we we you know we made the issue and said, "Oh, looks like I found someone else who actually did this already, right? There's there's actually an open PR that exists in the system." like it would have told us that that's what happened, right? So because it has access to all that stuff. It doesn't just like you know bulldoze its way through this. It like it knows it's aware of everything else in the system.

光靠 Slack 是不够的。但如果你把 Slack，加上读代码库的能力，再加上读 project 描述和其他 ticket 的能力结合起来，突然之间它就真能干事了。比如刚才那个场景，完全可能是另一种结果：它在建 issue 的时候发现「看起来已经有人做过这件事了，系统里已经有一个开着的 PR」，那它就会直接告诉我们。正因为它能访问所有这些信息，它不会一头闷着往前硬推，而是对系统里其他正在发生的事情有感知。

[15:50] Jacob

Got it. Okay. So let's just go back to the early like when you stealth launched this agent in Slack, right? Like so people probably started using it and started getting some feedback. Was the product was just like a simple basic prompt and some tools that was the product very complicated back then or is it pretty simple? How do you improve it? Um, at that point it it was it technically had the ability to do a lot of different things, but it wasn't really good at it yet. I don't think we'd arrived on our skill architecture yet, which unlocked a lot of things. Um, the primary thing people were using it for was just creating issues. Um, so we actually optimized pretty heavily around that. We created a small little router and for 80% of these use case, we routed to a specific subprompt that was just for creating issues like highly optimized for that. Um, so that's what most of our usage was in the really early days.

明白了。那我们回到最早——你们在 Slack 里偷偷上线这个 agent 的时候，应该就有人开始用、开始给反馈了。当时产品是什么形态？就是一个简单的 prompt 加几个 tool？那会儿的产品很复杂，还是挺简单的？你们后来是怎么把它做好的？那个阶段它技术上已经能做不少事了，但都还做得不够好。我觉得我们当时还没找到 skill 架构，而正是这套架构后来解锁了很多东西。那时候大家主要拿它来创建 issue，所以我们围绕这一点做了非常重的优化：我们做了一个很小的 router，80% 的用例会被路由到一个专门用于创建 issue 的子 prompt，针对这个场景做了高度优化。最早期我们绝大部分用量都是这个。

[16:38] Peter

So the structure of the product was like there's like a main prompt that maybe tells the agent what it can do and stuff and then it it kind of routes to like subprompts, right? Is that it?

所以产品的结构是：有一个主 prompt，大致告诉 agent 它能做什么，然后它再路由到不同的子 prompt？是这样吗？

[16:46] Jacob

Yeah. Yeah. Yeah. Or there's there's a really small model that runs a router and that will send it to either this like big model main prompt that can do anything and has access to all these tools or these specific use cases like creating an issue.

对对对。或者说，是有一个很小的模型在跑这个 router，由它决定：是把请求交给那个什么都能做、挂着所有 tool 的大模型主 prompt，还是交给创建 issue 这种专门场景。

[16:59] Peter

Oh, interesting. Okay. So there's a best practice saying that like when you're prototyping an agent, you should use the best model available just to see what it's capable of, but it sounds like you guys actually use a mix of different models for different tasks.

有意思。有一条常见的最佳实践是：做 agent 原型的时候先用手上最强的模型，看看它能力的上限在哪。但听起来你们其实是不同任务混用不同的模型？

[17:12] Jacob

We do, but I would say we follow that best practice for the most part. Uh we tend to throw the biggest model on it until we know that it's working well. We build out some eval. We have a good idea of like what success criteria looks like and then you can start to optimize the model down because you have a really good framework in place to like make sure it's still meet. Ideally, you want to use the smallest model for the job, right?

确实混用，但我觉得我们大体上还是遵循那条最佳实践的。我们通常先把最大的模型怼上去，直到确认这条路真的走得通；然后搭好 eval，对「什么算成功」有清晰的判断标准，这时候才开始往下压模型规格——因为你已经有一套很好的框架，能保证降下来之后它依然达标。理想状态是：能干成这活的最小模型，就用那个。

[17:32] Peter

Yeah. Because Yeah. You want to save save money, right? You [laughter]

对，毕竟能省钱嘛（笑）。

[17:36] Peter

Yeah. Okay. So, so then um it's like very iterative. Like in the beginning, you probably don't have a ton of eval set up like automated evals and stuff.

好。所以整个过程非常迭代。一开始你们大概也没有多少 eval，尤其是自动化的那种。

[17:43] Jacob

Yeah.

对。

[17:44]

Yeah.

嗯。

[17:44] Peter

Got it. Just to make this pretty concrete, like uh let's take the create ticket thing, right? You probably have some emails for did they actually create a ticket or not or like is the ticket useful or how do you evaluate how good it is?

明白了。我们说得具体一点吧，就拿创建 ticket 这件事来说。你们应该会有一些 eval，判断它到底有没有真的把 ticket 建出来，或者建出来的 ticket 有没有用？你们是怎么评估它做得好不好的？

[17:54] Jacob

Yeah. Um, yeah, I mean, yeah, pretty much. We have eval. A lot of it comes from just iterating and using it. So, a user will use it in a way that isn't as expected. We'll add that to our data set for our eval. Um, but we try to have a mix of like objective and then more subjective measures.

对，基本上就是这样。我们有 evals。很多都是在不断迭代、实际用起来之后攒出来的——用户用出了我们没预料到的方式，我们就把这个 case 加进 eval 的数据集里。不过我们会刻意混着来：一部分是客观指标，一部分是偏主观的。

[18:13] Peter

Objective and sub. Okay. So, objective is like uh deterministically do this thing or not.

客观和主观。好。所以客观就是那种确定性的——这件事到底做没做到。

[18:18] Jacob

Yeah, exactly. If the user says in progress, make sure it always adds the status in progress. that's really deterministic. And then there's more subjective things like did you structure the description in a in a good way? Did you extract the the right information that should be the title into the title field?

对，没错。用户说了 in progress，那就得保证它每次都把状态设成 in progress，这是完全确定性的。然后还有更主观的部分，比如：描述的结构组织得好不好？该进标题的那部分信息，你有没有提取到 title 字段里？

[18:34] Peter

How do you evaluate like is that like a yes no thing or is it like a scoring?

这种你们怎么评？是 yes/no，还是打分制？

[18:39] Jacob

Yeah, it's it's LLM as a judge. So we'll we'll yeah again we build out this data set over time. Then we just have a a scoring type of LLM that's like did this extract the right information? this is what it should be pretty much.

用的是 LLM as a judge。同样是慢慢把这个数据集攒起来，然后用一个负责打分的 LLM 去判断：它有没有提取对信息？基本就是拿它跟“本来应该是什么样”去比。

[18:54] Peter

And then and then I don't know I don't have a ton of experience doing this stuff but like I I feel like you have to you have this element as a judge which sounds really fancy but you have to look at the judge and be like hey is this actually judging it correctly or not? It's actually pretty manual, right?

那……我自己在这块没什么经验，但我感觉，你有了 LLM as a judge——这说法听着挺唬人的——你还是得回过头去看这个 judge 本身判得对不对吧？其实还是挺手工的，对吧？

[19:07] Jacob

Yeah. And we we actually try to use those less often for that reason. I think I think eval are most successful when you're ensuring consistency somewhere that consistency is important. But consistency is not always important for agents. They can have a lot of variance in how they respond to things. Um, and you really don't want to have too many emails around that because then it just false signals.

对。也正因为这个原因，我们其实用得比较少。我觉得 eval 最有价值的地方，是在那些“一致性很重要”的地方去保证一致性。但对 agent 来说，一致性并不总是重要的——它回应问题的方式本来就允许有很大的变化空间。所以你不该在这种地方堆太多 eval，不然全是假信号。

[19:29]

Okay. Interesting. Okay. So, you started with uh creating a manage tickets and then uh what are some other use cases that you you decided to support before I I don't remember when the thing was first launched but like before the first launch. So I I think the the the way that you should think about this is that like there's a because it's especially because it's like um very purpose specific. There's like this power law of like use cases, right? Like if you think about like what the purpose of linear is, it's like you're you're trying to structure uh the intention of the of the company,

好，有意思。那你们是先从“管理 ticket”开始的，之后在第一次正式发布之前——我不太记得它最早是什么时候上线的——你们还决定支持哪些用例？……我觉得应该这么理解：正因为它的目的性特别强，用例是有幂律分布的。你想想 Linear 是干什么的——它是要把公司的意图结构化下来。

[20:02] Nan

right? Like you you have ideas, you have meetings, you have Slack conversations, you have whatever, right? Discussions. And at some point you make a decision. And we're, you know, we were originally like a system of record to codify those decisions. So like if you if you just like look at the distribution like the vast majority of um how people use linear like the agent, right, is like codify decisions. Like I had this this you know free form conversation with a customer. They they complained about a few things. Let's extract what those things are and figure out what what to do with them. or um you know the the sort of thing that we demoed uh or or even like hey we changed our opinion about something right we we we had a we had a big meeting about something just like pull the notes and like we changed so many opinions about this uh the spec of this project or something like that just go and update all this so that all the the marketers and stuff like that don't get false information. So [snorts] all those are the those are like the motions right that are are fairly common but like ultimately this is powered by you know Frontier LLMs right you can do anything you can do anything that you want right and like like what you know I I I've used things I've used it for things like being an interview grader we have like a document in in one of our uh teams that's like here's the criteria for you know how we want to evaluate someone's like interview process or whatever it is and because I have the granola MCP connected to my linear agent right I can just be like, hey, that last interview I just had, could you just quickly give me a score on how we go against this rubric, right? So, I don't have to like read through all the notes and remember it's like a starting point.

对吧？你有想法，你开会，你在 Slack 上聊，各种各样的讨论。到某个点上你做出了一个决定。而我们最早就是一个 system of record，把这些决定固化下来。所以你去看分布就会发现，绝大多数人是怎么用 Linear agent 的？就是固化决定。比如我跟一个客户做了一次很开放的聊天，他们抱怨了几件事，那就把这几件事提取出来，再想想拿它们怎么办。或者像我们刚才 demo 的那种。再或者是“我们改主意了”——开了个重要的会，你去把会议记录拉出来，我们对这个项目 spec 的很多判断都变了，那就一次性把相关内容全部更新掉，免得做市场之类的同事拿到的是过时信息。这些都是比较常见的动作。但说到底，它背后是 Frontier LLM，你想干什么都可以。比如我自己就拿它当过面试打分器：我们某个团队里有一份文档，写着我们评估候选人面试表现的标准；因为我把 Granola 的 MCP 接到了 Linear agent 上，我就可以直接说，我刚结束的那场面试，你能不能照着这份 rubric 快速给我打个分？这样我不用把笔记从头读一遍、再费劲回忆，它至少给了我一个起点。

[21:33] Nan

So, there's like a lot of things that you can uh you can utilize it for as long as you have uh the context somewhere.

所以只要 context 在某个地方拿得到，你能用它干的事非常多。

[21:39] Peter

Got it. Okay. When you guys launched Lar agent, it wasn't like uh here's the use cases that actually pass all the eval focus on those use cases in the marketing, but like I guess the user can do other things too if they want to because it's just like a LM, right? Is that Yeah.

明白。所以你们发布 Linear agent 的时候，并不是说“这几个用例通过了所有 eval，营销就只讲这几个”，而是用户想干别的也随意，因为它本来就是个 LLM，对吧？

[21:54] Nan

I I I I think the the the way the way that the way to think about it is like

我觉得，应该这么去理解——

[21:59] Nan

it's it's almost like what's the biggest problem in applied AI right now, right? The biggest problem is not the agents aren't smart enough, right? The the problem is not the models are not advanced enough. The problem is uh there's like you know people talk about like a capability overhang or like a capacity overhang or something like that which is like the models are really smart but we're just not using them enough. And and so like where where we're all the evalu that we have are focused on they're focused on like are you uh almost like you know when when the user says something they actually want to accomplish a task. Did you did you figure that out? Right? Because you could here's a here's an opportunity you can really help them accomplish something like you know did you did you understand that that's what they wanted you to do or like were you a little bit too eager and you went on and and and did something like that was way too expensive and annoying when the user didn't want that. Right? Like so so we we have things where um you know for example in the Slack integration when like you're having a conversation with the agent and you ask a follow-up question, right? And the agent thinks they can answer it. There's a whole internal process that goes through like I think I can answer this question.

这几乎等于在问：applied AI 现在最大的问题是什么？最大的问题不是 agent 不够聪明，也不是模型不够先进。问题在于——就是大家常说的 capability overhang、capacity overhang 之类的——模型已经很聪明了，是我们用得不够。所以我们所有 eval 的焦点都在这一点上：用户说了一句话，他其实是想完成某个任务，你有没有听懂？因为这里有个机会，你本来真的能帮他把事办成——你到底有没有理解他想让你做的是这件事？还是说你太积极了，跑去做了一堆用户根本没要、又贵又烦人的事？所以我们会做这类判断。举个例子，Slack 集成里，你正在跟 agent 对话，你追问了一个问题，agent 觉得自己能答。内部会走一整套流程去判断：我觉得我能回答这个问题，

[23:01] Nan

Should I interject and and and that's that's the so the events are are really focused around those kinds of like ergonomic type of uh you know type of moments

那我该不该插一句话？所以我们的 eval 真正围绕的，就是这种“使用手感”层面的时刻。

[23:10] Peter

and after the product is live or even during dog fooding uh is there some sort of feedback loop after the agent response I can do a thumbs up or thumbs down or something like some feedback so you can get con constant feedback.

那产品上线之后，或者哪怕还在 dogfooding 阶段，agent 回复完之后有没有反馈闭环？比如我能点个赞或者点个踩、给点反馈，让你们能持续拿到信号。

[23:21] Nan

Yeah. Yeah. Totally. And that that's that's been very useful, right? A lot of our evals are effectively derived from those moments where someone goes like this behaved in a weird way or a stupid way like let me tell you why. And then and then eventually that itself becomes an eval.

有，当然有。而且特别有用。我们很多 eval 其实就是从这些时刻里长出来的——有人说“它这次的反应很奇怪”或者“很蠢，我跟你说说为什么”，最后这条本身就变成了一个 eval。

[23:36] Nan

Um and Jacob, you probably know like a couple of these like the the funnier earlier ones, right?

Jacob，早期那几个比较搞笑的例子，你应该都记得吧？

[23:40]

Yeah. Yeah. We've had we've had a ton of these. Like we had we had a user like call the agent dude once and then the agent was like, "Oh, okay. I'm not going to respond to you because that was like you're not being formal with me. Um, so we we've had a lot of interesting use cases where we've had to really just like dial these things into a really really narrow zone. I feel like um like you don't have to show the prompt, but like I feel like when you write the prompts and skills, you got to be a little bit maybe it's more line around principles and how they should think versus like hey you should make sure this is 140 characters longer like very specific kind of right like you don't want to restrict it too much right in terms of what it can do.

对对，这种我们遇到过一大堆。有个用户管 agent 叫“dude（老兄）”，结果 agent 回他：哦，那我不回复你了，因为你对我不够正式。所以我们碰到过很多有意思的情况，得把这些东西一点点调进一个非常非常窄的区间里。……我感觉——你们不用把 prompt 给我看——但我感觉你写 prompt 和 skill 的时候，得更多是写原则、写它该怎么思考，而不是“你必须保证这段是 140 个字符”这种特别具体的要求，对吧？你不想把它限制得太死，得给它留出能发挥的空间。

[24:16] Jacob

Yeah, totally. And you also just want to like give it as little instruction as possible to be honest. Give it the tools to load context. Don't give it context I think is like a a principle we found important.

完全同意。而且说实话，你要尽可能少给它指令。给它能加载 context 的工具，而不是直接把 context 喂给它——这是我们摸出来的一条挺重要的原则。

[24:28] Peter

Interesting. Because if you just give it too many instructions, it'll just like overfit on software.

有意思。因为指令给太多，它就会过拟合到那些指令上。

[24:33] Jacob

Yeah. And it may not need that. And then it may overemphasize on certain things that actually aren't important for that task. Um they're they're just smart enough to get what they need if you give it a really good defined goal.

对，而且它可能根本不需要那些东西。它还会过度强调某些对当前任务其实不重要的点。只要你给它一个定义清楚的目标，它们已经足够聪明，能自己去把需要的东西找齐。

[24:44] Peter

Oh. because they can just like do searches and stuff and figure out themselves.

哦，因为它可以自己去搜索之类的，自己搞明白。

[24:46] Jacob

Yeah. Give it tools to load skills, give it tools to load guidance, you know, different things like that and it can build its own context.

对。给它加载 skill 的工具、加载指引的工具，诸如此类，它能自己把 context 搭起来。

[24:53]

Got it. Interesting. It's kind of funny like it's kind of because you probably get a bunch of feedback about the agent and then you probably have a something the agent ingest the feedback and synthesize it. So it's almost like the agent's improving itself, right? It's like a loop. [laughter] Yeah, we have a mechanism where the agent can report um essentially functionality it can't do. So if the user asks it to do something it doesn't have a tool for it, it's going to call a tool and report that back to us and then we autoingjust that into you know go check if there's already an issue for this. If so add it there. If not create a new issue. So we have like a constantly streaming

明白，有意思。这事儿挺好玩的——你们大概会收到一堆关于 agent 的反馈，然后可能又让 agent 去消化这些反馈、做归纳。那几乎等于 agent 在自我改进，形成一个闭环，对吧？……对，我们有个机制，让 agent 可以上报它做不了的功能。如果用户让它做某件事、它却没有对应的 tool，它就会调一个 tool 把这件事报回给我们，我们再自动接进流程：先去看是不是已经有对应的 issue，有就补充上去，没有就新建一个。所以我们那边有一条源源不断的

[25:28] Peter

nice

不错。

[25:29] Jacob

set of issues coming in around what we can do.

issue 流进来，全都是关于我们还做不到什么的。

[25:31]

Dude, do you remember like offhand like what's the craziest thing the user like a user asks agent to do? crazy things. Um I I think in general like we're actually okay with the user asking, you know, as long as there's not like safety concerns or like that sort of thing. We're okay with if you want the agent to write you a poem, that's fine. Let it write you a poem. Um so we we give it quite a bit of freedom in that regard. Um I think trying to lock it down too much can can end up in a frustrating situation.

老兄，你还记不记得，用户让 agent 干过的最离谱的事是什么？……离谱的事啊。我觉得总体上，只要不涉及安全之类的问题，用户想让它干什么我们其实都能接受。你要 agent 给你写首诗，那就写呗，没问题。所以这方面我们给了它相当大的自由度。我觉得管得太死，最后反而会变成一种让人很挫败的体验。

[26:01] Nan

Got it. Okay. I I think when it when it comes to like you know the the range of things that people ask linear agent to do it's it's interesting right because it because it's like explicitly like for work right it's associated with your with your workspace and your your development team and stuff like that like people don't tend to go on wild adventures but there are things which surprise us right like uh a lot of people use it for translation so they'll they'll get feedback from customers or something like that in in a language they don't speak and they'll just they'll just straight up just ask it for translation or even set up an automation to be like if something ever you know we we have a lot of customers in France. So if we ever get a a intercom ticket that comes in in French, just translate it for me before you when you file an issue against it or something like that, right? So like there's a lot of those sorts of uh creative sort of use cases. They're very on topic, you know, but like we never thought that that would be a thing that people would do necessarily, right? Like that that was they didn't even cross their minds that that was a a possible uh a possible thing.

明白。我觉得，从大家会让 Linear agent 做的事情范围来看，挺有意思的——因为它明确是为工作服务的，跟你的 workspace、你的研发团队绑在一起，所以大家不太会跑去玩那些天马行空的东西。但确实有些事让我们挺意外，比如很多人拿它做翻译：他们收到的客户反馈是自己不懂的语言，就直接让它翻；甚至干脆设一条自动化——我们在法国有很多客户，所以只要来了一条法语的 Intercom ticket，在建 issue 之前先给我翻译好。这类很有创意的用法其实不少。它们都很切题，但我们从来没想到大家会这么用，压根没进过我们的脑子，没意识到这居然是能干的事。

[27:02] Peter

Got it. Okay. Yeah. Yeah. Yeah. I I think just like put the product in people's hands and then they'll figure out like new use cases will appear and they can figure out which part to improve.

明白。是啊，我觉得就是先把产品交到大家手里，新的用例自然会冒出来，你们再判断该往哪儿改进。

[27:10] Peter

Yeah. All right. Well, let me ask you like some product questions about the agent then. So like I I think before this before linear agent came out, linear was a platform for like you you can tag like cursor agent and some other agents on here, right? What was the philosophy behind actually kind of going off and building your own agent?

对。好，那我再问几个关于这个 agent 的产品问题。我印象里在 Linear agent 出来之前，Linear 更像一个平台——你可以在上面 @ Cursor agent 之类的其他 agent，对吧？那你们后来决定自己下场做一个 agent，背后的思路是什么？

[27:25] Nan

Yeah, I I think the um you know assigning issues to agents was like kind of what you're referring to, right? And then you can and you can add mention them in in in like comments and stuff like that. Uh and I I think that we wanted to be able to support the entire software development life cycle intent like ultimately that's what you know that that that's where we we saw our own sort of expertise right in in terms of how we can have very good opinions that you can adopt for your for your team. Um and uh and you know having intelligence and having an AI system uh there to take action was a way to actually uh execute on those things right because we we you know before like if you think about like the the you know the the olden days like we would like write you know guides right we'd write like something like the linear method about how you how you ought to think about your software development process and uh so a lot of in you know what we saw uh with uh you know with with models capabilities right is is basically the ability for us to be like actually you don't just have to read it and then execute on this playbook that we're giving you. You can just have linear itself execute the playbook. So like I think ultimately that's that's where that's what we saw.

对，你说的应该是把 issue 指派给 agent 这件事吧？另外你也可以在评论里 @ 它们。我们想做到的是覆盖整个软件开发生命周期——说到底这才是我们真正的专长所在：我们对流程有很强的观点，而这些观点是你的团队可以直接拿去用的。而有了智能、有了一个能真正动手的 AI 系统，这些观点才谈得上被执行。你想想以前，我们能做的就是写指南，比如写一份 Linear Method，告诉你应该怎么思考自己的软件开发流程。模型能力起来之后我们看到的是：你不用先读一遍、再自己照着这套 playbook 执行，可以直接让 Linear 本身来执行这套 playbook。我觉得这就是我们看到的机会。

[28:34] Nan

So so you know specific agents that we add to the system they'll they'll do parts of that. They'll write the code or maybe they'll they'll do the root cause analysis or something like that for for bug reports. Uh but you know none of them really took the whole process end to end like we wanted to.

我们接进系统里的那些具体 agent，各自只做其中一段——有的写代码，有的针对 bug 报告做根因分析。但没有一个像我们期望的那样，把整个流程从头到尾走完。

[28:48] Peter

Yeah, that makes sense. I I I I always think like the the AI handles the middle 80% and then the humans in the first 10% and last 10% and maybe maybe we're almost at or maybe we're already at a point where you know we we can just tell we can tell linear agent like here's some user problems here's like a high level idea of a solution like go figure out and then go put a PR up and then I'll review it even for like bigger features right

有道理。我一直觉得是 AI 干中间那 80%，人负责最前面的 10% 和最后的 10%。而且可能我们已经快到、甚至已经到了这么一个点：你可以直接告诉 Linear Agent，这是用户遇到的一些问题，这是解法的大致思路，你去搞清楚，然后提个 PR，我来 review——哪怕是比较大的功能也行，对吧？

[29:10] Nan

yeah yeah I mean what you're what you're talking about like I I've heard people say something like AI is a it's not an endto-end solution it's a middle's middle solution right it's kind of what you're what you're talking about and and and and you know right now like maybe humans handle the first 10% last 10% but like at some point maybe it's like the first 0.1% and the last touch right it's like you know the middle just get it's going to get bigger until it basically reaches the limits of the edges right so like that's kind of what we're also uh seeing right like we we're assuming that that's going to happen so we want to build like a system right that facilitates that

对。你说的这个，我听过有人这么讲：AI 不是端到端的方案，而是「中间段」的方案，差不多就是你的意思。现在可能人还负责头 10% 和尾 10%，但到某个时候，可能就只剩最前面的 0.1% 和最后收个尾了。中间那段会越来越大，一直大到几乎顶到两头的边界。我们也是这么看的——我们假设这件事一定会发生，所以想搭一套能承载它的系统。

[29:41] Peter

I don't know dude so so so Jacob have you like have you been following discords around loops and goals and stuff like that are you like doing all that stuff you let it run.

我也说不好。Jacob，你有在关注最近关于 loop、goal 这些的讨论吗？你自己在玩这些吗，就是放手让它一直跑？

[29:50] Jacob

Yeah, we're definitely experimenting with that internally. I mean, there's definitely cost trade-offs you have to consider once you you get into these long runninging agents. Um, and I but I think models are getting really close to where that's a really interesting thing. Yeah, on one hand like not exactly like I said like if you upload a linear method in the markdown file and then the agent will actually read through it and like actually try to follow it, right? But on the other hand, I feel like it's so good at producing markdown files and all this stuff by itself. And then usually it's pretty long. Sometimes I I don't even read it anymore. I I like, [laughter] okay, you make a plan, go for it. Like just just do it. And then and then I look at the final output.

有，我们内部肯定在试。不过一旦跑这种长时间运行的 agent，成本上的取舍是绕不开的。但我觉得模型已经很接近能把这件事做得很有意思的程度了。一方面吧，也不完全像我刚说的那样——你把 Linear Method 传成一个 markdown 文件，agent 确实会读完、也真的会照着做；但另一方面，我觉得它自己产 markdown 文件这类东西太在行了，而且通常写得特别长，有时候我干脆不看了。就那种，行吧，你做个计划，去干吧，我最后只看结果。

[30:25] Jacob

And I'm I'm like really paranoid that like it'll just end up as like, you know, as more and more agent produced markdown files end up in the re repo and like I don't read any of it,

我特别怕的就是，最后越来越多 agent 生成的 markdown 文件堆进 repo 里，而我一个都不看。

[30:33] Peter

it just turns to slop, dude. That that's what happened.

那就全成 slop 了，哥们儿。现实就是这样。

[30:39] Nan

Yeah. Yeah. And I I I I think like like you know as people use AI systems they they they start feeling these things as well. And then like you know a lot of times people oh you know skill issue or something like that they were like well you should just read your things you should like tell it not to produce slap. like yes but like like we it comes back to the main problem of like what are the defaults and and I think one of the one of the opportunities we saw for you know for introducing AI into linear as a system rather because like there's an there's an alternate way of the universe where we just say like we have an MCP uh you know MCP server and they just use whatever to to connect to linear and then that's it right like we don't have like a native agent doing anything

对对。我觉得人们用 AI 系统用久了，也会慢慢有同样的感受。很多时候会有人说这是「使用者水平问题」，说你自己该去读啊，该告诉它别产垃圾啊。话没错，但这又回到那个核心问题：默认值是什么？这也是我们把 AI 做进 Linear、做成系统一部分所看到的机会之一。因为还存在另一种平行宇宙的做法：我们只提供一个 MCP server，你爱用什么客户端连 Linear 就用什么，就完了——没有原生 agent 做任何事。

[31:15] Nan

um but I think having a native agent lets us uh you know imbue our you know opinions about what good product management looks like, right? And what it looks like is not producing endless markdown documents that you that are unreadable and full of extraneous detail, right? Like like where you know we can we can we can make some determinations about uh how the process ought to run in the in the best case.

但我觉得，有一个原生 agent，才能让我们把自己对「什么才是好的产品管理」的观点灌进去。而好的产品管理，绝不是产出一堆没法读、塞满无关细节的 markdown 文档。我们可以对这套流程在最理想情况下该怎么跑，做出一些判断和取舍。

[31:38] Peter

I see. I see that that's a really good Yeah, because if you just build an MCP just a bunch of tools that people can use then they might go off the rails but like the agent actually has a bunch of skills and instructions to kind of imbue linear's values and product process right

懂了，这点特别好。因为如果你只做一个 MCP、只给一堆工具让人随便用，他们可能就跑偏了；而 agent 本身带着一堆 skill 和 instruction，等于把 Linear 的价值观和产品流程注入进去了，对吧？

[31:51] Nan

exactly

正是。

[31:52] Peter

that makes sense yeah cool when you guys decided this thing was ready to ship like kari has high bar right so when you guys and this thing like people are using it for all kinds of stuff so how do you decide if this thing is ready to go

有道理。那你们当初是怎么判断这东西可以发了的？Karri 的标准可是很高的。而且大家会拿它干各种各样的事，你们怎么确定它可以上线了？

[32:03] Nan

what was it like from the engineering side Jacob I I could talk about the product side but what was the what did it look like from from the back end.

Jacob，工程这边是什么感觉？产品那边我可以讲，但后端那边当时是什么情况？

[32:09] Jacob

It felt like we released it early, not too early, but I think we kind of leaned on the side of like it's pretty good. Let's put it out there and get more data for how to improve it more. I think we could have worked on it internally forever honestly to make it perfect. Um it with something subjective like this, it's it's harder to get to that like perfect spot. And so I think we hit a point where like we just need to ship it.

感觉我们发得挺早的，不算太早，但我们确实偏向于「已经挺不错了，先放出去，拿更多数据再继续改」。老实说，这东西留在内部可以打磨到天荒地老都完美不了。像这种主观性很强的东西，很难到达那个所谓「完美」的点。所以到某个时候我们就觉得，就得发了。

[32:33] Nan

Yeah, got it. How about you not from the pro side? Yeah, I I think from the product side, you know, if you if you think about shipping products that have like that have like a UI, right, the UI effectively limits what you can do with it, right? It's like a very UIdriven feature or whatever. And uh so you can have some definition of quality that's based on eliminating everything that you didn't intend in the first place. I think for something like this, we had like core hero use cases that were like we these are the things we're going to demo. These are things we think are going to add a lot of value and they're a good like first way for people to use the agent,

明白。你呢，从产品这边看是怎样的？——我觉得从产品角度看，如果你发的是那种有 UI 的功能，UI 本身就框住了它能干什么，对吧？它是一个非常 UI 驱动的功能。这种情况下，质量的定义可以是：把所有你原本没打算让它发生的事都消灭掉。但像这种东西，我们的做法是先定几个核心的招牌用例——就是我们要拿去 demo 的那些，我们认为能带来很大价值、也最适合大家上手用 agent 的那些场景。

[33:09] Nan

right? And if we make those rock solid, then the other stuff it's like look, there's going to be a variance in in reliability and things like that because it's just the nature of this kind of uh you know, this kind of tool and this kind of technology and we're okay with that, right? But as long as like the the the hot paths uh that that we're advocating for are are you know are solid and we believe in them, then I think that that's the bar for quality that we're looking at.

只要把这几个做到扎实可靠，剩下的就是：行，可靠性上肯定会有波动，这就是这类工具、这类技术的本性，我们接受这一点。但只要我们主推的那几条热路径是稳的、我们自己也信得过，那我觉得这就是我们看的质量标准。

[33:31] Peter

Okay. the stuff that you know like create a ticket, manage tickets, create a PR like that kind of stuff like that that you highlight in the market marketing as long as those are good.

明白，就是建 ticket、管 ticket、提 PR 这类你们在市场宣传里主打的场景，只要这些够好就行。

[33:38] Nan

Yeah. Yeah. Exactly. Because those are things are like like those are you know those have those are in the warranty so to speak, right?

对，没错。因为这些可以说是「在保修范围内」的。

[33:44] Peter

Yeah. Got it. Okay, that makes sense. Okay. So, so I guess just to like kind of wrap up a little bit, I'm I'm sure a lot of companies are thinking through this right now. Should they just build like an MCP or should they build a native agent or like you know if you build all this stuff then people don't even use your website anymore. Then like what do you do? Like do you have any advice for uh builders or companies or think about whether just to even build their own agent or not?

懂了，有道理。那我们稍微收个尾——我相信现在很多公司都在纠结这个问题：到底做个 MCP 就够了，还是要做一个原生 agent？而且你把这些都做了，用户可能连你的网站都不上了，那又怎么办？对那些在犹豫要不要自己做 agent 的开发者或公司，你有什么建议？

[34:07] Nan

Yeah, I mean my advice is like like what what you know really you have to really break down what is the actual workflow that that your users want to do, right? Like and and a lot of times it's it's like super multi-step, right? Like no one no one like sits down at their desk and oneshots their whole job. Like that that's not that doesn't happen, right? So it it's it's it's an entire process that goes into end and then like where are the natural places where uh where you want to hook into that where where it makes sense to uh to hook into that and and I think that that's really where um you know like we said like you know linear agent as a as a collection of as a collection of subsystems right like a lot of them are about figuring out where the right entry points are because the the most obvious thing is like look there's a there's an inapp chatbot you can have a chatbot right and then People will point at that be like, "Oh, that's the agent." It's like, "Well, that's that's that's one way to interact with the agent." It's necessary because if you want to do any kind of like follow-ups or you want to do any sort of like multi-turn processes, you have to have some surface to to do that. But that's not where the entry points are.

我的建议是，你得把用户真正想完成的工作流拆开看清楚。很多时候它是超级多步骤的——没有人往桌前一坐，一次就把一整天的活儿一把梭做完，这不可能。它是一个从头到尾的完整过程。然后就要看：哪些地方是天然的切入点，在哪里挂进去才说得通。我觉得这才是关键。就像我们说的，Linear Agent 是一堆子系统的集合，其中很多工作其实就是在找正确的入口在哪。因为最显而易见的做法是：做个应用内 chatbot，然后大家一指——哦，这就是那个 agent。其实那只是跟 agent 交互的一种方式而已。它是必须的，你要做追问、要跑多轮流程，就得有个地方承载。但入口并不在那儿。

[35:07] Nan

The entry points are in the discussion that you're having in Slack or in your meeting debrief or when you're writing a project update and you're trying to do the research, right? Those are the those are the the on-ramps

入口在你 Slack 里正在进行的那场讨论里，在你的会议纪要里，在你写项目进展、正在做调研的那一刻。那些才是真正的上车口。

[35:18] Nan

to like utilize the intelligence. So if you if you give people good on-ramps, right, the the uh the sort of interactive chat, that's that's the follow-up, right? That and that covers like the long tale of things that people want to do. So I I think that's what you kind of have to do for for um for domain specific agents, right? Like because otherwise you you're deal with this problem, which is like, you know, why wouldn't I use quad or chatbt or something like that for this uh instead of your sort of native agent?

——上车去用这份智能。只要你给人足够好的入口，那种交互式聊天就变成后续追问的地方，它覆盖的是长尾需求。我觉得做垂直领域的 agent，大致就得这么干。否则你就会撞上那个问题：我干嘛不直接用 Claude 或者 ChatGPT 来干这事，而要用你那个原生 agent？

[35:42] Peter

Yeah. So it's almost Yeah. I I think like an agent is almost like a employee and then like employee doesn't only work in one app, right? You should talk to them from like, you know, Slack or wherever you guys work, you know?

对。我觉得 agent 有点像一个员工，而员工不会只在一个 app 里干活，对吧？你应该能在 Slack 或者你们平时办公的任何地方找他说话。

[35:55] Nan

Yeah. I I think I think everyone's kind of moving that direction now, right, with especially with the latest releases uh that that everyone's kind of putting out.

对，我觉得现在大家都在往这个方向走，尤其看各家最近放出来的那些东西。

[36:02] Peter

Do you think Kyrie like chef chat has a tier when like um if if like everyone's using linear through the through the agent or the MCP instead of like all all the beautiful buttons and the UI that exists?

你觉得 Karri 会不会有点心疼？就是如果大家都通过 agent 或者 MCP 来用 Linear，而不是用那些做得那么漂亮的按钮和界面。

[36:13] Nan

Honestly, no. I I I I don't I don't think I don't think he minds at uh minds at all. And like I think you know linear is like also very um naturally like a multiplayer system. So different players are going to use it in different ways, right? Like we we have like for example a lot of uh you know customer support agents, right? People right who are doing customer support will um use linear by escalating things out of Zenesk or intercom, right? And like that's their entire linear surface usage is is there's there's a there's some controls in the in the plug-in at intercom for them to escalate and pick a template or describe the issue or whatever it is, right? Like that's and that's it. that's their linear usage, but it's it's very valuable because that's the input stream for everyone else to actually do their work.

老实说，不会。我觉得他一点都不介意。而且 Linear 本身天然就是个多人协作的系统，不同角色的人用法本来就不一样。比如做客服的同事，他们用 Linear 的方式就是从 Zendesk 或 Intercom 里把问题升级过来。他们跟 Linear 打交道的全部界面，就是 Intercom 插件里的那几个控件——升级、挑个模板、描述一下问题，就这些，这就是他们全部的 Linear 使用量。但这非常有价值，因为这是其他所有人开展工作的输入流。

[36:53] Peter

Yeah, that's a good point. Yeah. So, I guess because Kari talks about being like opinionated about the product, right? But like I guess you need to let people use it from what whatever workflow or service they they want, you know? You can't be too opinionated. Yeah.

这点说得好。Karri 一直讲产品要有观点、要 opinionated，但我理解你还是得让大家从他们习惯的工作流或者工具里进来，不能太一意孤行，对吧。

[37:04] Nan

Yeah. Yeah. Exactly.

对，正是这样。

[37:05] Nan

Yeah. Cool. All right, guys. Well, I mean, uh I guess what what what's next for Linear Agent? Where can people want to learn more about it? uh what's next is you know I think we're we're we're definitely introducing some aspects of proactivity and uh and and sort of longer running memory right those are those are the two areas where you know we're really kind of focused on um if you think about like uh like let's say you're you're you're building like a project at your company and that project can last it could be a very short project over in a few days or it could like last a whole quarter and you know the agent should be very well aware of everything that happened throughout the lifetime of that project and be able to kind of naturally push it forward, right? There's a lot of different moments where you have to coordinate people, you have to make sure that, you know, documents are kept up to date and all those kinds of things. And that's where we we want that to just be something you can take for granted.

好的。那最后，Linear Agent 接下来会做什么？想了解更多的人可以去哪里看？——接下来我们重点在两块：一是加入一些主动性（proactivity），二是更长期的记忆。你想想，比如你在公司里做一个项目，它可能几天就结束，也可能持续一整个季度。agent 应该对这个项目整个生命周期里发生过的一切都了如指掌，并且能很自然地推着它往前走。中间有很多时刻是需要协调人的，需要确保文档一直是最新的，诸如此类。我们希望这些事变成你可以理所当然依赖的东西。

[37:55] Nan Yu

Yeah. Like I I run a project in linear. I can take for granted that it's wellrun, right? Like that's that's the that's the goal that we're looking for.

对。就像我在 Linear 里跑一个项目，我可以默认它就是被管理得很好的，对吧？那就是——那就是我们追求的目标。

[38:02] Peter Yang

That makes sense. Yeah. Whenever I have like a long Slack thread with an engineer and they're like, "Okay, let's go up to the PRD." I'm like, "I'm just too lazy to update the PRD. [laughter] I don't up to the PRD." So yeah, just be able to assign it to linear. That'll be super useful. Yeah. Cool. All right, guys. Well, thanks so much, man. Thanks for giving us an inside look at how linear agent works. And uh yeah, I I I wish you guys the best of luck. I think it's a very interesting problem to solve. Thanks, Peter. Thanks.

有道理。是啊。每次我跟工程师在 Slack 上聊了一长串，他们就说：「好，那把这些同步回 PRD 吧。」我心想：「我实在懒得去更新 PRD。（笑）我不想更新 PRD。」所以嘛，能直接把这事派给 Linear，那就太有用了。是的。酷。好了各位，非常感谢你们。谢谢你们带我们从内部看了一遍 Linear 的 agent 是怎么运作的。嗯，祝你们一切顺利。我觉得这是个非常有意思的问题，值得去解。——谢谢你，Peter。——谢谢。