Inside YC's AI Playbook
频道: Y Combinator
视频: https://www.youtube.com/watch?v=B246K_G7mHU
原文语言: en
统计: 共 46 轮 · 主持人 18 · Garry Tan 9 · Pete Koomen 15
[0:00] 主持人
How do you build superintelligence inside a company? Part of the key thing is not to just use AI as a co-pilot. This is the the thing where you use it as the building layer for everything. And you need to start recording all the artifacts. It's like a shared organizational brain. It's like the closest thing to us being able to like connect our brains.
怎么在一家公司内部打造超级智能？关键之一就是别把 AI 只当成 co-pilot 来用。真正该做的，是把它当成一切的底层建设层。你得开始把所有产出都记录下来，它就像一个共享的组织大脑，几乎是我们目前最接近把彼此大脑连起来的东西。
[0:19] Garry Tan
If you frame this as a way for everyone in an organization to get better at what they do using the like collective skill and instinct of the people they work with, it's incredibly powerful. Today we have a real treat. Uh we have a special guest, general partner at YC, our partner, Pete Koomen. He created Optimizely, which was one of the first and one of the best ways to do AB testing for apps and websites. And since then, he has gone on to create all of our agent infrastructure at YC. So literally all of our harnesses and how we use AI internal to YC. Pete, welcome to the Light Code.
如果你把这件事理解成：让组织里每个人都能借助同事们的集体技能和直觉，把自己的工作做得更好——那它的威力是惊人的。今天我们有个特别的安排，请到了一位重磅嘉宾，YC 的 general partner、我们的合伙人 Pete Koomen。他创办了 Optimizely，那是最早、也是最好用的给 app 和网站做 AB testing 的工具之一。在那之后，他又一手搭建了我们 YC 内部全部的 agent 基建——可以说 YC 内部所有的 harness、以及我们在内部怎么用 AI，都是他做的。Pete，欢迎来到 Lightcone。
[1:07] Pete Koomen
Thanks, Garry. For the last few years since ChatGPT, YC has been funding mainly AI companies. And we've been we've gone through like many different like versions of advice for them about how to build AI-native companies that build like mainly AI products. And we've gone on a crazy journey with them learning all of this. I think a lot of people don't realize that internally YC is actually building and using a lot of the same stuff that we're helping our startups build and use themselves. And it's been I think a very powerful symbiotic relationship for us to actually be adopting these tools and like transforming our own organization, which was started way way pre-AI into a super AI-native organization ourselves. And Pete has really been leading the charge for that. And so I'm really excited about this episode because I've actually been wanting to talk publicly about all the stuff that we built internally and this is the first thing that we're doing it. So, Pete, perhaps to start off, you sort of go back to the beginning and like talk about like there was a particular like moment when we really started adopting these AI tools internally. It was really you who got us started down that path.
谢谢你，Garry。过去这几年，从 ChatGPT 出来之后，YC 投的项目主要都是 AI 公司。我们围绕「怎么构建 AI-native 公司、做以 AI 为核心的产品」，给他们出过一版又一版的建议，跟他们一起经历了一段疯狂的学习旅程。我觉得很多人没意识到的一点是：YC 自己内部其实也在搭建和使用很多跟我们帮 startup 搭的同款东西。对我们来说，这是一种非常强的共生关系——我们自己也在采用这些工具，把我们这个早在 AI 之前很久就成立的组织，改造成一个超级 AI-native 的组织。而这一切的领头人就是 Pete。所以这一期我特别兴奋，因为我一直想公开聊聊我们内部搭的这些东西，这还是头一回。那 Pete，要不我们从头讲起，聊聊当初是哪个特别的时刻，我们真正开始在内部采用这些 AI 工具的——其实就是你把我们带上这条路的。
[2:15] Pete Koomen
Sure. I'm happy to happy to tell the story here and it's I like framing it that way because it was a project that I and a few engineers got started about a year ago, maybe a little more, but that has since snowballed into just a whole infrastructure layer that's made it possible for us to use AI internally at YC in lots of different ways. And And that's actually been one of the neatest parts about this is watching the whole engineering team and and many partners also just dive in and contribute to this this infrastructure layer. We started building our own harness inside of YC for kind of YC specific agents about a year ago. And uh the original impetus for the project was some of the work that I and a and a few of the software engineers at YC were doing with our finance team. Just for a bit a bit of backstory, so YC has for as long as it's existed, as far as I'm aware, run mostly on our own software. And this era has just given us a huge advantage, right? And so, with that context, back to this this moment, maybe a year ago, we were sitting down with the finance team talking through a set of tools that we were going to build for them uh just to help them run through some of their finance workflows. Booking journal entries, uh logging priced rounds, like all the sorts of things that that make YC run, really. I was seeing kind of two things at once. Like on one hand, uh we, you know, we had this sort of loop going internally, right? Where we'd sit down with the finance team, the finance team would describe to our software engineers how, you know, this complicated financial workflow worked and then software engineers would go and build some purpose-built software where there was a deterministic workflow encapsulating everything that they had been told and then hand it back to the finance team and so on. And it felt really inefficient. And then at the same time, this was right around the time when agentic tools were really agentic coding tools were really catching hold, right? And so you had uh kind of the first generation uh Windsurf and Cursor that were well-established by this point. I think this is right around when Claude Code was was introduced. It felt like this was giving me superpowers, right? Um and then kind of watching this sort of old classical way of building software in YC and then watching how I was doing things on my own machine, this it just felt like a bigger and bigger divide between those things. And so the original impetus was, "Why don't we try to build some tools at YC that we could use to run agents that would give the finance team control over their own software, right? Like remove the software engineers from this crazy loop where they have to sort of understand these complicated workflows and give the finance team the tools that they could use to encode their own workflows, not not as, you know, not as Ruby, uh but as as English with prompts, right?"
好，我很乐意讲讲这个故事。我喜欢你这种说法，因为这本来是我和几个工程师大概一年多前启动的一个项目，但后来像滚雪球一样，变成了一整套基础设施层，让我们能在 YC 内部以各种方式使用 AI。这其实也是最棒的部分之一——看着整个工程团队、还有很多合伙人，都一头扎进来给这个基建层添砖加瓦。我们大概一年前开始在 YC 内部搭自己的 harness，专门跑 YC 特定的 agent。这个项目最初的起因，是我和 YC 的几个软件工程师在和财务团队合作时做的一些事。先交代点背景：据我所知，YC 从成立到现在，基本一直跑在我们自己写的软件上。这在当下这个时代给了我们巨大的优势。带着这个背景，回到大概一年前那个时刻：我们当时和财务团队坐下来，讨论要给他们搭一套工具，帮他们跑财务工作流——记日记账、登记 priced rounds，所有这些让 YC 运转起来的事。我当时同时看到了两件事。一方面，我们内部有这么一个循环：我们和财务团队坐下来，财务团队向工程师描述某个复杂的财务工作流是怎么运作的，工程师再去写一套专用软件，把听来的东西全部封装成一个确定性的工作流，然后交回给财务团队，如此往复。这感觉特别低效。而与此同时，那正好是 agentic 工具——尤其是 agentic 编码工具——真正火起来的时候。第一代的 Windsurf 和 Cursor 那时已经站稳脚跟了，我记得 Claude Code 大概也是那会儿推出的。这些工具让我感觉像有了超能力。然后看着 YC 里这种老派、经典的写软件方式，再对比我自己机器上的干活方式，两者之间的鸿沟感觉越来越大。所以最初的念头就是：我们为什么不试着在 YC 搭一套工具，用来跑 agent，把软件的控制权交还给财务团队自己？把工程师从这个疯狂的循环里抽出来——他们再也不用去搞懂这些复杂工作流——直接给财务团队工具，让他们自己来编排自己的工作流，而且不是用 Ruby 来写，而是用英语、用 prompt 来写。
[5:03] 主持人
I mean, what's interesting is like uh we all funded companies like maybe even like two or three years ago when LLMs were out, but like agentic coding wasn't the thing yet. And so the first thing actually was not agentic coding, it was LLMs for writing SQL queries.
有意思的是，差不多两三年前我们就投过一批公司，那时 LLM 已经出来了，但 agentic 编码还不是个东西。所以最早被用上的其实并不是 agentic 编码，而是拿 LLM 来写 SQL 查询。
[5:18] 主持人
Yes.
是的。
[5:19] 主持人
So that's what I remember from like the first versions of what you built was uh how like good it was and how basically it rhymed with like these other failed startups that we had funded like each of us probably funded one at some point, you know, here it was, it was working and it worked so well that non-technical people, uh granted very smart people from finance, but with no engineering background, could use these tools to ask real questions. I I really surprised, too, to be honest. And and so that we started with this kind of purpose-built thing for finance and then rewrote it to be more of a general agent loop, right? And it and it's this is now you see these all over the place now, but I the first kind of magical moment that I had was we had this agent loop and we had a tool registry, a shared tool registry for kind of YC specific tools. And the first tool that really was an unlock for me was I think a tool looking back that you actually built, Jared. It gave these agents the ability to run read-only SQL queries against our database.
这就是我对你最早那几版东西的印象——它好用得让我吃惊，而且基本上跟我们投过的几家最后没做成的 startup 撞了车，我们每个人估计都在某个时候投过这么一家。可这回，它真的能跑了，而且跑得特别好，好到那些非技术的人——当然都是财务部门很聪明的人，但没有任何工程背景——也能用这些工具问出真正有价值的问题。说实话我当时也挺惊讶的。我们一开始是给财务做了个专用的东西，后来把它重写成更通用的 agent 循环。这种东西现在到处都是了，但我当时第一个魔法时刻是：我们有了这个 agent 循环，还有一个工具注册表，一个面向 YC 特定工具的共享 tool registry。而真正让我豁然开朗的第一个工具——回头看，其实是你做的，Jared——它让这些 agent 能对我们的数据库跑只读的 SQL 查询。
[6:21] Pete Koomen
Right? It was two tools actually. One was was running queries against our database and the other one was the ability to read our model files. I remember I built those tools and I felt a little bit like I was breaking the rules cuz initially we started with very limited tools that had very narrowly scoped domains and I kept getting frustrated because they weren't powerful enough to do the things that I wanted. And so I was like, what if we just gave the thing like access complete access to the production database where it could just like trample on anything?
对吧？其实是两个工具。一个是对我们数据库跑查询，另一个是能读我们的 model 文件。我记得是我做的这两个工具，当时还有点像在破坏规矩——因为一开始我们用的工具都很受限、领域划得很窄，而我一直很受挫，因为它们不够强、干不了我想干的事。于是我就想，要不干脆给它对生产数据库的完整访问权限，让它想踩哪儿就踩哪儿？
[6:53]
[laughter]
（笑）
[6:54] Pete Koomen
And I started to like surreptitiously pushed it out maybe late at night. And it worked. And it worked, yeah. It worked extremely well, right?
于是我就开始偷偷摸摸地把它推上线，大概都挑半夜。结果它真的能用。是啊，真的能用——而且效果好得不得了。
[7:02] 主持人
Yeah, perhaps foreshadowing, you know, subsequent things like open claw where it turns out that like the thing that was hampering the world was being worried about security and privacy and all the things that could go wrong. And when you like worry a bit less, you're like, "Oh my god, these things are unbelievably powerful." It's it's another really good example of this weird split between I'm at work and I'm kind of operating in this really narrow box and I'm at home using Claude coder or whatever like open claw hermie and I can do anything, right? And and and trying to trying to narrow that gap. So why was this so useful? This ability to run SQL queries against our database. It sounds really simple. Well, I think this is where it's important to talk about one of the big advantages that I think YC had coming into this experiment uh which is that we run on our own software and all of that software sits on one Postgres database that has everything that's important to YC's world in it. You know, every company that we funded, there's a company's table, there's a there's a founder's table, right? There's tables for our financial transactions, there's tables for the notes that I leave in our little internal CRM, right? All of these functions that I think a lot of other companies farm out to third-party SaaS tools, we've built our own. And as a result, we have this database with every important piece of context that I can now ask questions like, "Hey, show me all of the investors who invested in a space-related company in the last four batches." Right? It just turns out when when all of that context is in one place with a little bit of additional uh information about how the schema is laid out, an agent can go and ask any or answer arbitrary questions about about our business.
嗯，这或许也是后来一些事情的预兆，比如 open claw——事实证明，真正一直拖累全世界的，是对安全、隐私、各种可能出岔子的担心。而当你稍微少担心一点，你就会发现：「我的天，这些东西强得难以置信。」这又是一个很好的例子，说明那种诡异的割裂感：我在公司里，被框在一个特别窄的盒子里操作；而我在家里用 Claude code 之类、open claw、Hermes 这些，我什么都能干。我们就是在努力缩小这中间的差距。那这件事——能对我们数据库跑 SQL 查询——为什么这么有用？听上去很简单啊。这就要说到我觉得 YC 进入这场实验时的一大优势了：我们跑在自己的软件上，而所有这些软件都建立在同一个 Postgres 数据库上，YC 世界里所有重要的东西都在里面。我们投过的每一家公司，有一张 companies 表；有一张 founders 表；有记录我们财务交易的表；有我在内部小 CRM 里留的备注的表。很多别的公司外包给第三方 SaaS 工具的功能，我们都是自己搭的。结果就是，我们有了这么一个数据库，里面装着每一份重要的上下文，于是我现在可以问这样的问题：「嘿，给我列出过去四个 batch 里所有投过太空相关公司的投资人。」结果就是，当所有这些上下文都汇在一处，再加上一点关于 schema 是怎么布局的额外信息，一个 agent 就能去问、或者回答关于我们业务的任意问题。
[8:41] 主持人
That was a magic moment for sure when I first saw that.
我第一次看到那个的时候，那绝对是个魔法时刻。
[8:43] Pete Koomen
Yeah. The cool thing for me is that it didn't just make it easier to answer questions, it dramatically increased the number of questions that we would ask and dramatically increased the the scale and complexity of the questions that we would dare to ask. Where like, you know, in the in the old days back when we were using like BI tools to ask to ask a question like that, you know, like, "What investors have invested like in space-related companies?" That would be like several hours of writing SQL. And so like, unless it was really important, you just wouldn't bother. It's just example of the you know, the this instance of Jevons paradox that you get when you remove the amount of back and forth uh between different teams in order to get a thing done, right? If if in order to ans- ask some kind of complex question about YC, I have to go and knock on on, you know, the data science team's door and wait for them to get it through, you know, their backlog, uh I'm just going to ask far fewer questions. I mean, there are people out there watching this who work in places that still use it. The majority of people live in that world still, and it's 2026, which is a little unfathomable, actually. There's a long way to go, I think, which is which is really exciting. My guess is one question is how do companies that live in that old world could get sort of wings to move so quickly? Because our the magic for us was as you said, everything was the context is in one place that made it easy. You know, if you think about um data science uh historically, one of the first things that the Googlers had to figure out was a big table, right? And big table was, you know, instead of schema you and joins, you have one big table that um can be map reduced. Yes. And so, I think that that's happening again, and I would argue that that's happening now with um Karpathy style knowledge LLM wikis uh with Gbrain.
对。对我来说最酷的一点是，它不只是让回答问题变得更容易，它还大幅增加了我们会去问的问题数量，也大幅提升了我们敢于去问的问题的规模和复杂度。比如说，在过去那种我们还用 BI 工具去问问题的年代，要问一个像「哪些投资人投过太空相关的公司？」这样的问题，那得花好几个小时去写 SQL。所以除非这事真的很重要，否则你根本懒得去问。这其实就是 Jevons 悖论的一个实例——当你把不同团队之间为了把一件事做成而来回沟通的成本去掉以后，就会出现这种情况，对吧？如果为了问一个关于 YC 的复杂问题，我得跑去敲数据科学团队的门，然后等着他们把我的需求从积压列表里排到，那我自然就会少问很多很多问题。我是说，现在还有正在看这个节目的人，他们工作的地方仍然是那一套。大多数人到现在还活在那个世界里，而现在都 2026 年了，这其实有点难以想象。我觉得还有很长的路要走，这点其实挺让人兴奋的。我的一个猜测是，一个问题是：那些还活在旧世界里的公司，怎么样才能长出翅膀、快速地动起来？因为对我们来说，魔法就在于——就像你说的——所有东西、所有 context 都在一个地方，这让一切变得容易。你想想 data science 的历史，Googler 们最早要搞定的事情之一就是 big table，对吧？big table 就是说，不再用 schema 和各种 join，而是把所有东西放进一张大表里，可以拿来跑 map reduce。对。所以我觉得这件事正在重演，我会说它正在用 Karpathy 风格的那种 knowledge LLM wiki、用 Gbrain 的方式重新上演。
[10:31]
[laughter]
（笑）
[10:32] Garry Tan
I mean, that's what I'm seeing anyway. Like, you know, obviously I have I have an Open Claw. It has uh access to lots of lots of systems, and then I'm normalizing it to my own schema that's relevant to me and the things that I care about. And it is like denormalization. It's you're taking data and you're putting it into a format that uh is more or less optimized for Open Claw or Hermes agent. Like, that particular type of harness to be able to ask questions. And it needs retrieval, it needs rag, it needs graph rag, it needs uh you know, hybrid RRF. Like, there's reranking in there. Like, you know, all the things that everyone has learned about retrieval uh is now inside Gbrain. And then, when you give the agents a soul, and it and you give it uh the data, and it knows you and what you care about, like suddenly these things have insane wings. Like, I just kind of can't believe how it sees around corners. And you might ask a question, and it'll even you sort of interpret what your question was about, and like give you a thing that uh frankly like it would take a human who really knows you well to answer. Um all that's possible now. And so, you know, your question is like all the data is everywhere. My answer from like the Open Claw Hermes experience with G brain is like, yeah, you basically have to take that you're going to denormalize it and you're going to put it in a format that is optimized for agent retrieval and understanding. You could wrap it in an MCP, but for whatever reason I just like intuitively I'd be worried like it's still so you know, these things are really good at working with MCP and CLI. Like they're a little even better with CLI. It seems like you have to denormalize and do the big table thing, but you know, specifically for the agent. Looking back over the the last year and a half, uh it feels like we're still kind of in the single player era of agents where the harnesses that have gotten really popular, right? Uh Claude Code, Codex, Pi, Open Claw, Hermes. They're all designed to be used by a single human running on a single machine. And it makes a lot of sense. Right? Because in that environment these these agents can do just about anything, right? And they they make you incredibly powerful. It's it's they're a lot of fun to use. I think one of the big problems uh that I don't think has been solved well yet by anybody is the multiplayer Mhm. harness, right? It's it's enabling that kind of superpower but on a team or an organizational level, right? And and and that's I think been the interesting thing to explore with the infrastructure that we've built at YC is watching which primitives that we've created that have enabled individuals and teams to use agents. You asked the question about if you're working inside of a kind of a legacy organization, which is like anyone who's more than two years old,
反正我看到的就是这样。比如说，很显然我自己有一个 Open Claw。它能接入很多很多系统，然后我把这些数据都规整到我自己的 schema 上，也就是和我相关、和我在乎的东西相关的那套 schema。这其实就是一种反规范化（denormalization）——你把数据拿过来，放进一个或多或少为 Open Claw 或者 Hermes agent 优化过的格式里，让那种特定类型的 harness 能够拿来问问题。它需要 retrieval，需要 rag，需要 graph rag，还需要那种混合的 RRF。里头有 reranking。基本上所有大家在 retrieval 上学到的东西，现在都装进了 Gbrain 里。然后，当你给这些 agent 一个灵魂，给它数据，让它了解你、了解你在乎什么的时候，突然之间这些东西就长出了疯狂的翅膀。我简直不敢相信它居然能预判到弯道后面的东西。你问它一个问题，它甚至会去解读你这个问题到底是想问什么，然后给你一个答案——坦白说，那种答案得是一个真正很懂你的人才答得出来的。而现在这一切都成为可能了。所以，你的问题是「所有数据到处都是」，那我从 Open Claw、Hermes 加上 Gbrain 的体验给出的答案是：对，你基本上就得把这些数据拿来做反规范化，把它放进一个为 agent 检索和理解优化过的格式里。你也可以把它包成一个 MCP，但不知道为什么，直觉上我会有点担心——它还是……你知道，这些东西在用 MCP 和 CLI 时都很在行，但用 CLI 的时候似乎还要更顺一些。所以感觉你还是得做反规范化、做 big table 那一套，只不过是专门为 agent 做的。回头看过去这一年半，感觉我们其实还处在 agent 的「单人模式」时代——那些真正火起来的 harness，对吧？像 Claude Code、Codex、Pi、Open Claw、Hermes，它们全都是设计给一个人在一台机器上用的。这也很合理，因为在那种环境下，这些 agent 几乎什么都能干，对吧？它们让你变得极其强大，用起来也很好玩。我觉得有一个大问题，到目前为止还没有人解得很好，那就是「多人模式」的 harness——对吧——也就是把那种超能力放到一个团队、一个组织的层面上去赋能。而这正是我们在 YC 用自己搭的基建去探索的有意思的地方：去观察我们造出来的哪些 primitive 真正赋能了个人和团队去用 agent。你刚才问的那个问题是，如果你是在一个传统组织里工作——基本上就是任何超过两岁的组织——
[13:17]
[laughter]
（笑）
[13:18] Pete Koomen
uh what are the things that you can focus on uh in order to to help enable everybody at your org to use AI to to to more. Uh and we talked about kind of this common context layer, right? And so, a data warehouse where it just as much of your internal important context lives, it just turns out is extremely useful. There are many tools for connecting individual agent harnesses to uh you know, other MCP tools, other other sources of truth. But just like a coding agent inside a mono repo just tends to be much more efficient, watching our agents operating on our single database that has everything in one schema tells me that there's a lot of value at least in getting all of the context into one place. Having an internal tool registry, this is I think the other really important thing that we built. So, in the beginning, like we were talking about, it was just the whole system was really simple. It was like an agent loop and a simple tool registry and you know, a few other pieces, right? Like a model router underneath. The tool registry is where most of the like YC specific stuff lives, right? Like tool registry is what turns these agents into something that's useful at work. And we had like 20 tools at the beginning including this magical ability to query our SQL database, but over time teams have added more and more tools. Every time we kind of come upon some piece of work at YC that we think could be improved with an agent, we can just add tools and there's more than 350 today. I just checked, right? Every team is adding their own tools. You know, I can do things like manage my office hours. Our finance team can uh you know, can book journal entries, right? We can help manage the events that we run. Uh there's tools for all of the important work that we do at YC. And now, once these all exist in in in in one place, you can make them available to these internal agents that we built, but you can also make them available to cloud code, you know, running running on on on on our individual machines. So, those things above all, I think, were the important pieces that we built that if I were working in any other organization I would focus on building. I mean honestly inspired by what you guys did with tools like this idea of skillify in open claw and then actually the most important the last part of skillify skillify is like this meta skill that I made in open claw where it's like you just do anything in open claw and Hermes. Hermes actually already has skillify they call it something as like it makes skills automatically. But the most important thing I I think is actually like plugging into the resolver which is like your agents.md with like the list of things that the agents can do and then like it links to the markdown entry point that like lets you use a tool basically. And so like this thing keeps coming up in all these different contexts like cloud code has a skill. The skill registry in cloud code is actually a resolver. Our tool registry is actually a resolver. And then the weird thing that you have to do on top of that is actually um I have a meta skill called check resolvable that I call all the time. So I'm always like I do something that's new or different in uh in my agent and then after it does it and I like it I say skillify it and then it becomes basically like a tool call or method call and then I run check resolvable which is like you know look at all of the other skills and tools that exist and is it you know dry don't don't repeat yourself and is it MECE which is you know I'm embarrassed to say a McKinsey term for um the consultants use it for making really good slide decks mutually exclusive collectively exhaustive. That's like how you're supposed to do slides if you're a McKinsey consultant but it's useful because it's like an additional layer on top of don't repeat yourself dry. And like the models just seem to know what those things are and so if you have a dry and MECE resolver table anywhere it's actually like the optimal resolver. Like it's bad to have 10 skills that do all the same thing. It's good to have one skill or one tool that has parameters that then let you call them. So, I don't know. I think it's like this is like the wildest time to be alive as like an applied computer scientist cuz it's like simultaneous like discovery of the same useful applied concepts over and over again. And I wonder if like when people were, you know, developing the first versions of Unix or something is like discovering a stack and a
——你能聚焦去做哪些事，来帮助你组织里的每个人都更多地用上 AI。我们之前聊到过这个共同的 context 层（common context layer），对吧？所以，一个 data warehouse——你内部那些重要的 context 尽可能多地都汇聚在里面——结果证明是极其有用的。市面上有很多工具可以把单个 agent harness 连到别的 MCP 工具、别的事实来源上。但就好比一个 coding agent 在一个 mono repo 里往往会高效得多，我们观察我们的 agent 在那个把所有东西都放在一套 schema 里的单一数据库上运行，这告诉我，至少把所有 context 都汇聚到一个地方是很有价值的。还有一个我觉得非常重要的东西，就是我们建的内部工具注册表（tool registry）。所以一开始——就像我们刚说的——整个系统其实非常简单，就是一个 agent loop，加一个简单的 tool registry，再加另外几个部件，对吧？底下还有个 model router。tool registry 就是大部分 YC 特有的东西所在的地方，对吧？正是 tool registry 把这些 agent 变成了在工作中真正有用的东西。一开始我们大概有 20 个工具，包括那个能查询我们 SQL 数据库的神奇能力，但随着时间推移，各个团队加了越来越多的工具。每次我们在 YC 碰到某块觉得可以用 agent 来改进的工作，我们就直接加工具，到今天已经有 350 多个了。我刚查过，对吧？每个团队都在加自己的工具。比如我可以做一些事，像管理我的 office hours；我们的财务团队可以去登记会计分录（journal entry），对吧；我们可以帮着管理我们办的各种活动。我们在 YC 做的所有重要工作都有对应的工具。而现在，一旦这些工具都汇聚在一个地方，你就可以把它们提供给我们搭的那些内部 agent，但你同样可以把它们提供给 Claude Code，让它跑在我们各自的机器上。所以这些东西，我觉得最重要的是——如果换我在任何别的组织工作，我都会优先去搭的——就是这些部件。我说真的，我自己其实是受你们用工具做的那些东西启发的，比如在 Open Claw 里把东西「skillify」（技能化）的这个想法，然后其实 skillify 最重要的最后一部分——skillify 是我在 Open Claw 里做的一个元技能（meta skill），就是你在 Open Claw 和 Hermes 里随便做点什么。Hermes 其实已经自带 skillify 了，他们管它叫别的名字，反正它会自动生成 skill。但我觉得最重要的一点其实是接进 resolver——也就是你的 agents.md，里面列着 agent 能做的事情清单，然后它链接到一个 markdown 入口，基本上就是让你能用某个工具的入口。所以这个东西在各种不同的场景里反复出现，比如 Claude Code 有 skill，Claude Code 里的 skill registry 其实就是一个 resolver，我们的 tool registry 其实也是一个 resolver。然后在这之上你还得做一件怪事，就是——我有一个叫 check resolvable 的元技能，我老是调它。所以我总是这样：我在我的 agent 里做了点新的或者不一样的东西，等它做完、我觉得不错，我就说「skillify it」，它就基本变成了一个 tool call 或者 method call，然后我跑 check resolvable，意思就是说，看看现存的所有其他 skill 和 tool，它是不是 dry（don't repeat yourself，别重复造轮子），是不是 MECE——说出来有点不好意思，这是个麦肯锡（McKinsey）术语，咨询顾问们用它来做特别好的 slide deck，意思是 mutually exclusive collectively exhaustive（相互独立、完全穷尽）。如果你是麦肯锡顾问，这就是你该怎么做 slide 的方式，但它确实有用，因为它就像是在 DRY 之上又加了一层。而且这些模型好像就是知道这些概念是什么意思，所以如果你在任何地方有一张又 dry 又 MECE 的 resolver 表，它其实就是最优的 resolver。比如说，有 10 个 skill 都干同一件事是很糟的，更好的是有一个 skill 或一个 tool，它带参数，然后让你能去调用它们。所以，我也说不好。我觉得这真的是作为一个应用计算机科学家活在世上最疯狂的时代，因为它就像是同样一批有用的应用概念被一遍又一遍地同时重新发现。我在想，当年那些人开发第一版 Unix 之类的东西的时候，是不是也是这种感觉，就像在发现 stack 这种东西，还有——
[17:45] 主持人
heaps. It feels like we're right at that moment
——一大堆。感觉我们正好就处在那个时刻。
[17:47] 主持人
Yeah. today. Like we're just coming up with the new primitives for what an agentic system actually is. And you can see it in the parallel sort of development of like we're just trying to do a thing and it might be in cloud code or it might be in our own internal harness or it might be in open claw, it might be in Hermes. Like these things just keep coming back over and over again. Y Combinator Startup School is back. We're hand-selecting the most promising builders in the world and flying them out to San Francisco for July 25th and 26th to discuss the cutting edge of tech and startups. Apply now for your spot. Yeah, it's really interesting to look at how some of the other companies that are building this stuff have built their infrastructure because you see a lot of these same primitives in in each of them, right? Like there's the agent loops, there's tool registries, there's skill registries. Looking at at at the way that we're using skills now YC, so if you think of skill as a simple abstraction layer over tools, we have a handful of sort of shared skills uh that that we all have access to uh through this through this agent system. And it's been interesting to watch. I think you've talked about this where this progression of like in the beginning you were kind of writing your own system prompts and then skills emerged, so you started writing your own skills and then you would start uh meta prompting where you where you know, you'd do it again. Write a skill. Exactly. Improve the prompt. Yes. Automatically. Yeah.
对，今天就是。就像我们正在为「一个 agentic 系统到底是什么」想出新的 primitive。你能从这种并行的演进里看出来——我们只是想做成某件事，它可能在 Claude Code 里做，也可能在我们自己的内部 harness 里做，也可能在 Open Claw 里，也可能在 Hermes 里。这些东西就这样一次又一次地反复出现。Y Combinator Startup School 回来了。我们正在亲手从全世界挑选最有潜力的 builder，把他们请到旧金山来，在 7 月 25 日和 26 日一起探讨科技和创业的最前沿。现在就申请你的名额吧。对，去看看其他在做这类东西的公司是怎么搭它们的基建的，挺有意思的，因为你会在它们每一家身上看到同样的这些 primitive，对吧？像 agent loop、tool registry、skill registry。看看我们现在在 YC 怎么用 skill 的——如果你把 skill 想成是凌驾于 tool 之上的一个简单抽象层，我们有那么几个共享的 skill，是我们所有人都能通过这套 agent 系统访问到的。这个过程看起来挺有意思的。我记得你聊过这个，就是这样一种演进：一开始你是自己写 system prompt，然后 skill 出现了，于是你开始写自己的 skill，再然后你会开始做 meta prompting，就是——你知道——你会再做一遍。「写一个 skill。」没错。「改进这个 prompt。」对。自动地。对。
[19:08] Pete Koomen
Yes. Seeing us kind of do the same progression internally where we have a couple skills and now we've gotten to the point where we have these sort of autonomous self-improving loops, right? Uh you know, and so uh
对。我们在内部也看到了同样的演进过程——我们有几个 skill，现在已经走到了这样一个阶段：我们有了这种自主的、自我改进的循环（self-improving loop），对吧？所以——你知道——所以——
[19:20] Pete Koomen
Auto research from Karpathy again, you know, yeah. Or slash goal now in Codex. Like they've they've incorporated it, too. We have this general agent that every night will go and read through all of the agent conversations that employees have had and look for uh things it could have done better and pieces of context that if it had up front, it would have done more efficiently. This is Open Crow's dream cycle and G brain also has a dream cycle. This is a um a a skill improvement dream cycle, but it could also potentially um read all the transcripts and then write them back into the internal uh DB into the internal CRM on like what we know about people and companies. Indeed. And we we there are cool examples of using transcripts actually to make these skills more effective as well. One of the shared skills that we have uh is a skill that that partners at YC use to help our companies uh write what we call two sentence descriptions, right? Everybody here has written hundreds of these.
——又是 Karpathy 说的那个 Auto research，对吧。或者现在 Codex 里的 slash goal。他们也都把它整合进去了。我们有这么一个通用 agent，它每天晚上都会去把员工和 agent 的所有对话通读一遍，去找那些它本可以做得更好的地方，以及那些「如果它一开始就拿到，就能干得更高效」的 context 片段。这就是 Open Claw 的 dream cycle，Gbrain 也有 dream cycle。这是一种 skill 改进的 dream cycle，但它其实也有可能去读所有的 transcript，然后把内容反写回内部的 DB、反写回内部的 CRM 里，比如更新我们对人和公司的认知。确实。而且我们——还有一些很酷的例子，是真的拿 transcript 来让这些 skill 变得更有效。我们有一个共享 skill，是 YC 的合伙人用来帮我们的公司写所谓「两句话描述」（two sentence description）的，对吧？在座的每个人都写过几百个这种东西。
[20:23] 主持人
We should probably explain what a two two sentence description actually is, yeah.
我们大概应该先解释一下「两句话描述」到底是什么，对吧。
[20:26] 主持人
Sure. So, a two sentence description is a concise way of explaining what your company does in natural language that anyone will understand and why it's interesting. Sounds easy, but it's surprisingly hard for founders to actually And also no one does it. Weirdly. Weirdly like even the most experienced founders like forget because they have perfect context. Interestingly, uh I now realize YC itself is uh a context engineering uh sort of process in that like people we would frequently teaching people, you have perfect context about what's going on in your brain, but great communication is replicating that same context in someone else's brain. And that's what a two sentence pitch is. Like what is it? Like I don't even know what the heck this is. And then second part is like, is it interesting or valuable? What you know, is it worth my time? And so that you know, when I when I teach two sentence pitches, that's my favorite way to do it. It's like, do I even know what the heck this is? Because if you don't know what it is, you can't even ask a question about it. It's like, something about computers, I guess, whatever. What What time is lunch again? And then the second part is equally important, which is like, if I've heard that you know, there are like 20 companies. Like, there are five other companies in this room that do X. Like, and then I don't understand like why this is noteworthy. Like, again, I'm like thinking about my pastrami sandwich again, right? [laughter] So So the two sentence pitch like viscerally is important for founders. And it's it's a it's a simple kind of atomic thing that every partner at YC has practiced over and over and over again. I think Tom, uh one of the one of the partners here, wrote a skill that teaches an agent how to uh take some context about a company and can and condense that into a two sentence description. And so that was his sort of handwritten prompt or skill about how that was done. And one of the cool things that happened in the last month or two was that a couple of the other partners took a meeting that they had with a a group office hours they had with a bunch of the companies in the spring batch and just went through and had every founder try their hand at at a two sentence description and kind of gave them feedback and input. And so kind of the knowledge that lives in a partner's head about how to do this effectively was exchanged back and forth, right? And and and now lived in the context of of that meeting transcript. And handing that back to the agent and saying, given, you know, what you've learned by reading through this context, improve the two sentence description skill. And they got noticeably better after that. Like, this thing is now better than I am, I would I would argue at writing those. This is how super intelligence happens inside organizations. [laughter] I mean, this two-sentence pitch thing sounds like something kind of small, but embedded in it is actually something very powerful. I'm sure you guys have heard Jack Dorsey talk about what he's doing with Block. He basically is trying to turn Block into a mini AGI around helping people in the world make payments to one another, right? Uh and then this is actually the micro mechanism by which he's going to do that, right? Like you can look at the operation of any organization as the aggregate of you know, I mean, the two-sentence pitch at YC is that's sort of one of like thousands of things that I would argue we do for founders. But you know, we just walk through a very concrete way where someone wrote a prompt, used it, used a bunch more, other people used it, a bunch of artifacts came off of that around literally like the transcript of using it becomes a thing that can be used to meta prompt and improve in an automated fashion on a daily basis the operation of that one skill. And then suddenly that one skill, you just said it. That skill is now better than any of us individually than be you know, when before we actually had access to that. And so this is like a particular like needle pin prick in the fabric of like how any organization does things. And then how do you build super intelligence inside a company? You do that on everything you do. And it's not more complicated than that. Like you literally just compose everything that you do and any given thing that any given person can do, you combine that in aggregate and in this particular process and like you have a super organization. It's possible now. Like every single person watching this can do this at any company, at their own company, they can do it at their job. I mean, the interesting thing is that's why you should start a startup Cuz people are going to be trapped in organizations with people running organizations that are very powerful and have all these resources and all this capital that do not believe what we just said.
当然。所谓「两句话描述」，就是用任何人都能听懂的自然语言，简洁地说清楚你的公司是做什么的，以及它为什么有意思。听起来很简单，但对创始人来说，真要做到出奇地难。而且很怪的是，几乎没人去做。很怪。很怪的是，连最有经验的创始人都会——你知道——忘掉，因为他们自己拥有完美的 context。有意思的是，我现在意识到，YC 本身就是一个 context engineering 的过程，因为我们经常教大家：你对自己脑子里发生的事拥有完美的 context，但好的沟通是把同一份 context 复制到别人的脑子里。而这正是「两句话 pitch」要干的事。第一是：它是什么？我连这玩意儿到底是个啥都不知道。然后第二部分是：它有意思吗、有价值吗？你知道，它值不值得我花时间？所以——你知道——我教别人写「两句话 pitch」的时候，我最喜欢的方式就是这样。就是：我到底搞不搞得清这是个什么东西？因为如果你都不知道它是什么，你连一个关于它的问题都问不出来。就好像，「呃，跟电脑有关的什么东西吧，随便啦。午饭几点来着？」然后第二部分同样重要，就是：如果我听完之后觉得——你知道——「有 20 家公司」，「这屋里还有另外五家公司也在做 X」，然后我就不明白这玩意儿为什么值得一提，那我——你知道——我又开始想我的 pastrami 三明治了，对吧。（笑）所以「两句话 pitch」这件事，从切身体会上来说，对创始人是很重要的。它是一个简单的、原子级的东西，YC 的每个合伙人都一遍又一遍又一遍地练过。我记得 Tom——这里的一位合伙人——写了一个 skill，教 agent 怎么拿一家公司的一些 context，然后把它浓缩成一句「两句话描述」。所以那是他手写的 prompt、他手写的 skill，讲的是这事该怎么做。然后最近这一两个月发生了一件很酷的事：有几位别的合伙人开了一场会——他们跟春季批次的一群公司开了一次集体 office hours——就挨个让每个创始人试着写自己的「两句话描述」，然后给他们反馈和意见。于是，原本只活在某个合伙人脑子里的、关于怎么把这件事做漂亮的知识，就这样来回交换出来了，对吧？而且现在它活在那场会议 transcript 的 context 里。然后把它交还给 agent，对它说：「根据你通读这份 context 学到的东西，去改进这个『两句话描述』的 skill。」结果改完之后它明显变好了。这东西现在写「两句话描述」已经比我强了，我敢这么说。这就是超级智能（super intelligence）在组织内部诞生的方式。（笑）我是说，这个「两句话 pitch」听起来好像是件挺小的事，但其实里头埋着某种非常强大的东西。你们肯定听过 Jack Dorsey 讲他在 Block 干的事。他基本上是想把 Block 变成一个围绕「帮助世界上的人互相付款」的 mini AGI，对吧？而这其实正是他要用来实现这个目标的微观机制，对吧？你可以把任何组织的运转，看成是——我是说——大量这种东西的总和。YC 里的「两句话 pitch」只是我会说我们为创始人做的成千上万件事里的其中一件。但我们刚刚很具体地走了一遍这个过程：有人写了一个 prompt，用了它，又用了很多次，别人也用了它，从中产出了一堆 artifact——字面意义上，使用它的那份 transcript 本身就变成了一个可以拿来做 meta prompt 的东西，可以每天自动地改进这一个 skill 的运作。然后突然之间，这一个 skill——你刚才也这么说了——这个 skill 现在已经比我们任何一个人单独都强了，比我们以前还没拥有它的时候强。所以这就像是在「任何组织怎么做事」这块布料上，扎下的一个针眼般的小点。那么，你怎么在一家公司内部构建超级智能？你就把这件事用到你做的每一件事上。没有比这更复杂的了。你就是字面意义上把你做的每一件事、把任何一个人能做的任何一件事，组合起来，放进这个特定的流程里——然后你就有了一个超级组织。这现在是可能的。看这个节目的每一个人都能做到这一点，在任何公司，在他们自己的公司，在他们的工作岗位上都能做。我是说，有意思的地方在于，这正是你应该去创业的原因。因为人们会被困在那些组织里——那些组织的掌权者非常强大，手里有这么多资源、这么多资本，却根本不相信我们刚才说的这些。
[25:07] 主持人
Because they keep all the context locked down.
因为他们把所有 context 都锁得死死的。
[25:09] Garry Tan
Right, because it's unsafe. Unsafe. This is one of those things that we talk about um how to build that AI native organization, right? Part of the key thing is not to do just use AI as a co-pilot. I think that's very 2020 three, four, right? This is the the thing where you use it as a really the the building layer for everything. And you need to start recording all the artifacts. Like people wouldn't have thought of a meeting recordings and this is one of those reasons why all these uh meeting recorders have been taking off. People have been finding them with coaching them on the meetings, but it's not just that. You could take that and improve all the output for you that you do, like writing emails, communication, planning. You have the whole context of everything. It's funny to say I remember the Dario essay where it's like there's some of the blockers on just the rate of progression of AI are not technical, they're just sort of like social, cultural things. Things kind of like a really interesting example. Two years ago it would have seemed to I just remember like it felt odd to just like record a meeting or like there was just like people trying to figure out what the like social etiquette around it was and like how intrusive it was. And today I just feel like it's almost like default assumed that like most meetings are being recorded, especially if they're on Zoom, but just in general like everyone started recording things now. It's a little scary, but I think if you frame this as a way for everyone in an organization to get better at what they do using the like collective skill and instinct of of the people they work with, it's incredibly powerful. Having a canonical two-sentence description skill is not just a way to like generate a a snippet of text for a a It's a way to help me get better at understanding what makes for effective founder communication, right? Because now I can tap into everything that Diana and Hardt and you two have learned over the many years you've done this job, which are now kind of baked into this skill through the conversations that you've had.
对，因为它不安全。不安全。这就是我们经常聊的话题之一——怎么去打造那种 AI-native 的组织，对吧？关键之一就是别只把 AI 当成 copilot 来用。我觉得那是很 2023、2024 年的玩法了，对吧？真正的做法是把它当成一切的 building layer（构建层）。而你得开始把所有的 artifact 都记录下来。比如以前没人会想到去录会议，这也正是为什么现在这些会议录制工具能火起来的原因之一。大家用它们来复盘会议、给自己做教练，但不止于此。你可以拿这些记录去改进你产出的所有东西——写邮件、沟通、做规划。你手里握着一切的完整 context。说来有意思，我记得 Dario 那篇文章里讲过，AI 进展速度的一些阻碍其实不是技术性的，而是某种社会和文化层面的东西。这是个特别有意思的例子。两年前，我就记得当时光是录个会都让人觉得怪怪的，大家还在摸索围绕这件事的社交礼仪是什么、它到底有多冒犯。可今天我就感觉，几乎已经默认大多数会议都会被录下来了，尤其是 Zoom 上开的会，但其实普遍来讲，现在大家都开始录东西了。这有点吓人，但我觉得如果你把它理解成一种让组织里每个人都能借助同事的集体技能和直觉变得更厉害的方式，那它的威力是惊人的。有一个标准化的、两句话的描述 skill（技能文件），它不只是用来生成一段文字片段，它还是一种帮我更深入理解什么才算有效的创始人沟通方式的工具，对吧？因为现在我能调用 Diana、Harj 还有你们俩这么多年干这份工作积累下来的全部经验——这些经验都通过你们曾经的对话，沉淀进了这个 skill 里。
[27:06] Pete Koomen
It's like a shared organizational brain. Yes. It's like the the closest thing to us being able to like connect our brains, right? Yeah.
就像一个共享的组织大脑。对。这几乎是我们目前最接近于「把彼此的大脑连起来」的东西了，对吧？是啊。
[27:13] Pete Koomen
It totally is, right? And I I can have an agent now come and I can do practice sessions with it, right? I can have it critique. Like there there are so many possibilities once you get all of this knowledge into a place where an agent can can work with it. It's a It's a very empowering thing for every human in the organization. There's some subtle interesting things around here that like, you know, other people might get wrong that like, I feel like we've gotten right. I mean, one of them is by default the agent conversation is actually globally viewable by any full-time employee at YC. You know, we sort of weren't sure about that decision. I mean, it felt right and it felt like living in the future, but it did not come easily. I feel like we had a lot of conversations about like, "Well, then everyone sees everything. Is that okay?" And like, you know, "What is not okay?" And then I'm glad we made the choice to keep it open, actually, cuz I agree.
完全就是这样，对吧？现在我可以叫一个 agent 过来，跟它做练习演练，对吧？我可以让它来给我做点评。一旦你把这些知识都汇集到一个 agent 能调用的地方，可能性就太多了。这对组织里的每一个人来说都是一件极具赋能感的事。这里头有些很微妙、很有意思的点，别人可能会搞错，但我感觉我们做对了。其中之一是：默认情况下，agent 的对话对 YC 任何一位全职员工都是全局可见的。说实话我们当时对这个决定也没那么笃定。它感觉是对的，感觉像活在未来，但这个决定来得并不轻松。我记得我们为此聊了好多——「那不就所有人都能看到所有东西了吗？这样行吗？」还有「什么才算不行？」不过我很庆幸我们最后选择了保持公开，因为我也赞同这一点。
[28:07] 主持人
people learned how to use it from watching how other people used it.
大家是通过看别人怎么用，学会怎么用它的。
[28:10] Pete Koomen
Yes. We used that transparency to solve several problems at the same time. One, every agent conversation, as you mentioned, was broadcast internally to a Slack channel. And anybody could join that Slack channel and look and learn, right? And I remember this is another kind of big unlock moment was when you started using it really heavily. You were like super creative with with the things you were doing with it. And a lot of us watched that. It was like, "Oh, wow. I didn't even occur to me to to
对。我们用这种透明度同时解决了好几个问题。第一，正如你提到的，每一次 agent 对话都会被广播到一个内部的 Slack channel 里。任何人都可以加入那个 Slack channel，去看、去学，对吧？我记得另一个很关键的解锁时刻，就是当你开始重度使用它的时候。你用它玩出来的那些东西超级有创意。我们好多人都在围观。当时的感觉就是「哇，我都没想到还能这么用——」
[28:37] Pete Koomen
to to to use it that way, right? It allows you to be a little more lenient on internal security, right? One of the things we talked about earlier was this trade-off where these agents are at their most powerful when they are given unrestricted access to lots of context, which runs counter to the way more most organizations work. It turns out that by defaulting to public broadcast for these conversations, you kind of institute a bit of a social control on what people can do with it. Uh that as we learned, I think has been like reasonably effective uh inside of this high-trust environment at keeping private information private. Yeah, what's interesting is um it it betrays two traits of uh truly agentic, like 1,000x superintelligent organizations that I would not have necessarily guessed would exist, but are now like must exist if you want to create this type of organization. You have to be relatively egalitarian, and you also have to be trust by default. And then neither of those things uh actually are most organizations in the world. If you're the founder of an organization, you actually have to have those at the core of what you're doing. And I think like that kind of environment honestly works best at startups, right? When it's a small group of people that are all aligned and and and and operating in a high-trust environment.
——这么用它，对吧？这让你可以在内部安全上稍微放宽一点，对吧？我们前面聊到的一点是这样一个权衡：这些 agent 在被赋予不受限制地访问大量 context 的权限时，威力是最大的，而这恰恰跟大多数组织的运作方式背道而驰。结果发现，通过把这些对话默认设为公开广播，你其实就建立起了一种社会性约束，制约着大家能拿它来干什么。事实证明，正如我们后来体会到的，这在我们这种高信任度的环境里，效果相当不错——既能保护隐私信息，又不至于把它锁死。是啊，有意思的是，它暴露出了真正 agentic、那种 1000 倍超级智能组织的两个特征——这两个特征我本来未必猜得到会存在，但现在看来，如果你想打造这类组织，它们就是必须存在的。你必须相对地平权，而且你还必须默认信任。而这两点恰恰是世界上大多数组织都不具备的。如果你是一家组织的创始人，你就真得把这两点放在你所做之事的核心。我觉得这种环境说实话在创业公司里最管用，对吧？当团队是一小群人、目标一致、又在高信任度环境里运作的时候。
[29:54] Garry Tan
The other thing you have to do is be willing to spend like 10 to 100,000 a year on tokens. But if you're willing to do it and you invest in the skills and you like actually do everything in an open way with your team that way, like basically what I realize is it allows you to live in 2028, right? Like what you spend 100,000 or a million dollars a year on now, it will be commonplace like in in 2 years, right? It'll it won't cost 100,000 in a year, it'll cost 10,000, and the year after that it'll be like a couple hundred bucks, right? And everyone will do it. And we'll call it like this is how companies are now. So, basically there's a one-time time warp where you can leapfrog every incumbent, all Fortune 500s, all startups that exist by doing this. Like I'm imagining in the '90s, I wonder if it felt similarly when companies started buying computers for their employees.
另一件你得做的事，是愿意每年在 token 上花个 10 万到 100 万美元。但只要你愿意这么做，并且投入去打磨这些 skill，真正以一种开放的方式跟你的团队做所有事，我意识到的是——它能让你活在 2028 年，对吧？你现在每年花 10 万或 100 万美元买到的东西，两年后就会变得稀松平常，对吧？到时候它不会再要 10 万一年了，会降到 1 万；再过一年，可能就只要几百块了，对吧？然后人人都会这么干。我们会管它叫「现在公司就是这样运作的」。所以说，本质上存在一个一次性的时间扭曲窗口，你能借此弯道超车所有在位者——所有财富 500 强、所有现存的创业公司。我在想 90 年代是不是也有过类似的感觉，就是当公司开始给员工买电脑的那会儿。
[30:47] Pete Koomen
Yeah. They were probably very expensive and probably only certain companies really invested in buying these like expensive, flaky computer systems for their employees, but like what a superpower to have a computer when your competitors like don't have computers. I think more tactically how I've seen this affect uh YC has been raising the the floor. The floor. The floor in a sense. What I mean by that is that you could have a new employee joining and maybe would have taken them 6 months to ramp up, but with this it's sort of like they automatically get a lot of the context from the company working and they know how the best people on the star players in your organization do things by apprenticeship automatically with AI instead of uh because partner time is expensive or sometimes the best people in our org they're very busy, right? And you get to kind of run the simulation of what it's like to be like Pete when he does like a awesome job coaching founders on sales or like Gary when he's like talking to founders and giving very specific advice. I think it helps all the new new entrants in the organization just be a mini version of you a lot faster. One of the first things that I appreciated about being able to use a coding agent was that all of the dumb questions I was too embarrassed to ask, I had no trouble asking asking the agent. And it this is kind of that same thing but at an organizational level, right? You're a brand new employee, you're embarrassed to ask, you don't want to bug Harj with with a question and now you don't have to, right? You and which on that means a lot more questions get asked and answered and people ramp up much more quickly. After you had built all of this agent infrastructure at YC, it inspired you to write this essay "Horseless Carriages" that went like pretty viral on the internet. Maybe you can like explain the ideas behind horseless carriages. I think they're still very relevant now. It was a critique of a lot of the the AI software that I saw being built at the time. And to be totally honest, I think a lot of it still falls into this
是啊。那些电脑当时大概很贵，可能也只有某些公司真正肯投钱去给员工买那种昂贵又不稳定的计算机系统，但是——当你的竞争对手连电脑都没有的时候，有电脑就是一种超能力啊。更具体地说，我看到这件事对 YC 的影响，是把「地板」抬高了。地板。某种意义上的地板。我的意思是，可能有个新员工入职，本来要花 6 个月才能上手，但有了这个，就好像他们能自动从公司运转中获取大量 context，并且通过 AI 自动「拜师学艺」，了解组织里那些最厉害的明星员工是怎么做事的——而不必去占用合伙人的时间，因为合伙人的时间很贵，或者说我们组织里最厉害的那些人通常都很忙，对吧？你就能去跑一遍模拟，体验一下当 Pete 出色地辅导创始人做销售是什么样的，或者 Gary 跟创始人聊天、给出非常具体建议的时候是什么样的。我觉得这能帮所有新加入组织的人更快地变成一个迷你版的你。我最早开始用 coding agent 时，最让我欣赏的一点，就是所有那些我不好意思问出口的蠢问题，我问 agent 一点心理负担都没有。这其实是同一回事，只不过放到了组织层面上，对吧？你是个全新的员工，你不好意思问，你不想拿问题去打扰 Harj，而现在你不必了，对吧？这意味着会有多得多的问题被问出来、被解答，大家上手也快得多。在你把这一整套 agent 基建在 YC 搭起来之后，它启发你写了那篇文章《Horseless Carriages》（无马的马车），在网上传得相当火。也许你可以讲讲 horseless carriages 背后的想法。我觉得这些想法现在依然非常切题。那篇文章是对当时我看到的很多 AI 软件的一种批评。说句实话，我觉得其中很多到今天还是落入了这种——
[32:41] 主持人
It's still like that. Yeah, it didn't change.
现在还是这样。是啊，没变。
[32:43] Pete Koomen
Yes. I just saw a lot of examples of uh companies building software and adding AI features by sort of slotting a little bit of AI inside of a lot of software, right? And And the example that I used at the time was the the kind of email writer that uh the the Gmail uh team had had shipped. But the the real idea underneath was this kind of that the the the potential for AI is to shift control of software from the developer to the user, right? And And the the simple example I started with was basically that all of these kind of like AI as a little feature kept a bunch of prompt context about how the AI should do a job locked away and hidden from the user, which is just this classic example of like, well, it's the developer's job to figure out how all of this stuff should work. So, the developer should write that, and we should protect the user from that kind of complexity.
对。我当时看到了很多例子，公司在做软件、加 AI 功能时，就是往一大堆软件里塞那么一小撮 AI，对吧？我当时用的例子是 Gmail 团队发布的那个邮件代写功能。但底下真正的核心想法是这样的：AI 的潜力在于把软件的控制权从开发者手里转移到用户手里，对吧？我一开始举的那个简单例子，本质上就是：所有这些把 AI 当成一个小功能的做法，都把关于「AI 该怎么完成一项工作」的一堆 prompt context 锁起来、藏着不让用户看到。这正是那种经典思路——「这是开发者的活儿，得由开发者去搞清楚这一切该怎么运作。所以应该由开发者来写好它，然后我们要把用户保护起来，免得他们接触那种复杂性。」
[33:37] Garry Tan
Safetyism, I hate it.
安全至上主义（Safetyism），我讨厌它。
[33:38] Pete Koomen
Right. And And you know, and it And it's just again going back to this contrast between watching the way that some of these tools work and what it was like to use a coding agent on my computer that could do anything, right? And feeling feeling like I I had superpowers. I think the conclusion that this essay points to is that as we get better at building AI-native software, it's going to look a lot more like the agent wrapping software deterministic tools rather than deterministic software wrapping an AI, right? And we've done our best to expose that to internal employees with some of these primitives that we built. Um but we have a lot we have a long way to go. The chat as the interface, I just feel something There's like I things going around right now about how there's a need to build new interface for like AI and what does that look like. And I think that just comes from people who haven't like touched and felt it yet. Chat is actually pretty good because like you trust the agent, you increasingly trust the agent to do more of the work, and you trust its decisions, and you don't actually need to like have too much of a UI to go in and like review the things it's it's doing. I feel like it's time for a just-in-time software.
没错。你知道吗，这又回到了那个对比——一边是看着这些工具是怎么运作的，另一边是在我自己电脑上用一个无所不能的 coding agent 是什么感觉，对吧？那种感觉就像我拥有了超能力。我觉得这篇文章指向的结论是：随着我们越来越擅长构建 AI-native software，它会越来越像是 agent 在包裹（wrapping）确定性的软件工具，而不是确定性的软件去包裹一个 AI，对吧？我们已经尽力把这一点通过我们搭的一些 primitive（基础组件）暴露给内部员工。不过我们还有很多——我们还有很长的路要走。聊到把 chat 当作交互界面，我就有种感觉……现在外面有不少说法，说我们需要为 AI 这类东西打造全新的界面，那应该长什么样。而我觉得这种说法恰恰来自那些还没真正上手摸过、感受过它的人。Chat 其实相当好用，因为你信任这个 agent，你越来越信任 agent 去完成更多的工作，你信任它的决策，你其实并不需要太多的 UI 去进进出出地审查它正在做的事。我感觉是时候迎来 just-in-time software（即时生成的软件）了。
[34:47] 主持人
Yeah, basically, right? Like yes, occasionally you want it to present you like maybe you like a specific view of something, but
对，基本就是这样，对吧？比如说，是的，偶尔你会希望它给你呈现某个东西的特定视图，但是——
[34:54] 主持人
And it could make the software and build it as a single-page JavaScript just purposely built for you at that moment. Yeah. And it could be a skill file that could be like called anytime you want. I was thinking a lot about this because I used to be in the camp that oh, when ChatGPT came out and it was 2023, that perhaps chat was not going to be the UI for all these AI applications. And I've definitely changed my mind. Part of it is that after experiencing all these tools, and I think the more I reflect upon it, why chat is probably the better interface is because it's the closest thing to human language, and human language and writing is basically the closest thing to expression of thinking.
而且它可以把软件做成、构建成一个单页 JavaScript，专门为那一刻的你量身打造。对。它也可以是一个 skill 文件，你随时想用都能调用。我最近想了很多这个问题，因为我以前是站在另一边的——当 ChatGPT 在 2023 年出来的时候，我觉得 chat 可能不会是所有这些 AI 应用的 UI。但我现在彻底改变想法了。一部分原因是，在体验了所有这些工具之后，我越想越觉得，chat 之所以可能是更好的界面，是因为它最接近人类语言，而人类语言和书写基本上是最接近思维表达的东西。
[35:32] 主持人
Mhm. So, chat is the closest stepping stone to clear intelligence.
嗯。所以说，chat 是通往清晰智能最近的那块踏脚石。
[35:36] 主持人
Yeah. So, you can't just put it in a box. I think it just constrain us too much to have a very specific box. So, that's why I thought it was like, okay, all in with chat interfaces. I used to be in the other camp, and it's like I just multi-modal. I know we've talked about like Telegram is not ideal, but I actually really Yeah, it's pretty good. Yeah, it's pretty good.
对。所以你不能就把它塞进一个框里。我觉得用一个非常具体的框来约束我们，限制太多了。所以我才会想，好吧，那就全押在 chat 界面上。我以前是站在另一边的，现在我就是 multi-modal。我知道我们聊过 Telegram 并不理想，但我其实真的挺——对，它挺好用的。对，挺好用的。
[35:55] Garry Tan
And the voice memo, sometimes when I don't want to type, you just do the voice memo, and it's it feels like I'm talking to Like I can give my open claw, like I can give it text, I can give it voice, I can give it pictures of things, like I can give it files, like it's like pretty good.
还有语音备忘录，有时候我不想打字，就直接录个语音备忘录，那感觉就像我在跟——比如我可以给我的 Open Claw，我可以给它文字、给它语音、给它图片、给它文件，就像，挺好用的。
[36:07] Garry Tan
Yeah. I just experienced this. So, like January, I think the last episode we did, I just talked about this, like I spent January and through February building a half a million lines of code for a Rails app, which was Gary's list, and it was like, yeah, I know people make fun of me for like it was a blog, but it was like I built the blog in like the first week. Like I spent a month and a half building a full agentic framework that did like my own version of deep research and like fact-checking. But the thing is I built it the way I would have built software in 2013, the last time I wrote code. It was like the web 2.0 version of this. And Claude code lets you do that. And what's crazy to connect is like I'm working like I don't know. I think I wrote like 40,000 lines of code the last 3 days just for G brain. And G brain is basically Gary's List 2.0, but it's totally open source, right? So everything I had to write for agentic retrieval, everything I had to do for voice extraction, everything I had to do for fact-checking, all of that now exists inside G brain and I just gave it to my, you know, Gary's List team yesterday as their own open claw instance. And they're flying now, right? Like they were complaining about like I had made, you know, this monolithic writer chat interface and it was like full of bugs cuz I was like re-implementing things that open claw and telegram already do. And now they just use open and claw telegram and my retrieval system with like all the same data that I extracted it out and with our MCP and it's working great. Like basically, you know, Gary's List 2.0 the next rewrite thankfully is not half a million lines of rails code that is like insane to actually, you know, it's rigid, it's takes a long time it like takes like 10 times longer. You know, even though it was 1/100 the amount of time to do it like by hand, you don't have to do it by hand. Like that half a million lines of code in rails is easily like 10,000 lines of like typescript and like maybe 2,000 lines of markdown. And all of that is way more dynamic. Like you could just say like actually, for the second paragraph, I really like including a biography of like the the we're focusing on. And it's like I don't have to code that in Rails. I don't even have to write that into um a Ruby file that then gets evaled in like, you know, my complex eval infrastructure. Like, Open Claw just knows that, and I have an eval skill. My editor-in-chief can just change it on the fly, and I didn't touch it. Yes. And it's like, this is insane, actually. Like, this is actually the dawn of just-in-time software, and I can see it right now. The best AI software that I've used, whether it's inside of Wyse, or or tools that others have built, tend to be very small. And just add kind of the smallest amount of code ahead of time that you need in order to let the model shine. Mhm. And you can build an awful lot with that, right? I can write tens of thousands of lines of code, uh like like you're saying. But, the ability to start at this like extremely simple thing that I need to understand very little in order to use is incredibly powerful, and I think that's I think most software in the future is going to look like.
对。我最近就亲身经历了这个。比如一月份，我想上一期节目我就讲过这个，我花了一月份一直到二月份，给一个 Rails app 写了五十万行代码，那就是 Gary's list。然后，对，我知道大家拿我开玩笑说那不就是个博客嘛，但其实那个博客我第一周就搭好了。我花了一个半月在搭一整套 agentic framework，里面有我自己版本的 deep research、还有 fact-checking。但问题是，我是用 2013 年——也就是我上一次写代码时——的方式来写的，是那种 Web 2.0 的版本。而 Claude Code 让你能这么干。最离谱、最值得串起来看的是，我现在的工作——我说不好，我觉得过去三天我光是给 G brain 就写了大概四万行代码。G brain 基本上就是 Gary's List 2.0，但它是完全开源的，对吧？所以我之前为 agentic retrieval 写的所有东西、为语音提取做的所有东西、为 fact-checking 做的所有东西，现在全都装进了 G brain 里。我昨天就把它当成一个独立的 Open Claw 实例交给了我的 Gary's List 团队。他们现在飞起来了，对吧？之前他们一直抱怨说，我做的那个一体化的 writer chat 界面全是 bug，因为我相当于在重新实现 Open Claw 和 Telegram 本来就能做的事。而现在他们直接用 Open Claw、用 Telegram，加上我的检索系统，用的还是我抽取出来的同一批数据，配上我们的 MCP，跑得特别好。所以基本上，Gary's List 2.0、下一次重写，谢天谢地不再是五十万行 Rails 代码——那真的离谱，它很僵硬、很费时间，比如说慢上十倍。你知道吗，虽然当初做出来只花了百分之一的时间，因为你不用手写。那五十万行 Rails 代码，轻轻松松就能压缩成一万行左右的 TypeScript，外加可能两千行 markdown。而且全都灵活得多。比如你可以直接说，其实第二段我挺想加上我们聚焦的那个人的一段小传。这种事我不用在 Rails 里写死，我甚至不用把它写进一个 Ruby 文件，再扔进我那套复杂的 eval 基础设施里去 eval。Open Claw 就直接懂了，我有一个 eval skill。我的主编可以临时随手改，我都不用动手。对。这真的太离谱了。这其实就是即时软件（just-in-time software）的曙光，我现在亲眼看到了。我用过的最好的 AI 软件——不管是 Wyse 里头的，还是别人做的工具——往往都非常小。它们只是提前加上你所需要的最小量的代码，好让模型去发光。嗯。而你能用这点东西做出非常多的事，对吧？我可以写好几万行代码，就像你说的那样。但能从这么一个极其简单、我几乎不用搞懂什么就能用起来的东西出发，这种能力强大得不可思议，我觉得这就是未来大多数软件会有的样子。
[39:23] 主持人
talking about this earlier, but I think that is what Open Claw did really well. Like, there were like a few things that you want you wanted like some ability to give it a bit of personality. You wanted it to like persist and last for a long time, and have some concept of memory. And it's not like perfect, but that's like actually like good enough is like for that use case. And Claw code, too. Every time Boris comes and speaks at Wyse, he spoke with Diana uh earlier this week. One of One of the things that really stands out is how obsessed he is with simplicity, and with just like making the product as small as possible. My favorite example of this is is uh the this open-source harness called Pi, which is a That's what That's what Open Claw uses as its out-of-the-box coding agent. It's this beautiful piece of software, which is just like the smallest possible coding agent. You can use Pi to modify and extend Pi, right? And it's this kind of idea of like self-extending and self-referential software. It's really fascinating. And and you're right, Openclaw was built on top of that. One of the things I'm very curious to see is how many other sort of pieces of classic software emerge in this form as this kind of minimal thing that you start with uh and then use an agent to extend over time. I think more and more I mean, looking at honestly the benefits that we've gotten from having our own customizable software, I suspect that a lot of commercial software uh will come with this capability uh out of the box in the future. There's a really interesting subtle thing that I wanted to talk about around like what I learned from your essay, uh which is like AI can either be centralizing or decentralizing. And um the Google Gmail like I can't change the prompt thing is like the perfect example of that. We basically have a choice to be made over the next I don't think it's even that long. I think it's like 18 to 24 months. It might take 5 years, but um there are sort of two scenarios and uh what comes to mind is literally like the uh 1984 Macintosh commercial by Apple where it's like is 2034 going to be like 1984? And you know, the 1984 case would be we have centralized control, like there are five kings, there's only, you know, one of them maybe wins. They have the most advanced AI. They have uh end run around all compute and power. They have all the space data centers cuz they could you can't build any terrestrial data centers in America anyway. There's this like centralization of control. And not only that, they don't let you run your own prompts. Like they literally do the Gmail thing, but like for your whole computing existence, right? And this would be as if like personal computers never existed and there were only mainframes and minicomputers. Like this is sort of lost to the sands of time, but you know, in the 1960s and '70s when computers first came out, like you couldn't go to the store like you can today. You couldn't go to an Apple store and just buy an iPhone, let alone uh a Mac. You had to get access to like this thing that was worth like hundreds of thousands of dollars to millions of dollars. And the only
我们早些时候聊过这个，但我觉得这正是 Open Claw 做得特别好的地方。比如有那么几件事是你想要的：你希望能给它一点个性；你希望它能持续存在、用很长时间，并且有某种记忆的概念。它并不完美，但对那个用例来说，其实已经够好了。Claude Code 也是。每次 Boris 来 Wyse 演讲——他这周早些时候跟 Diana 聊过——其中真正让人印象深刻的，是他对简洁的痴迷，对把产品做得尽可能小的执着。我最喜欢的例子是那个叫 Pi 的开源 harness，那就是 Open Claw 开箱即用的编码 agent。它是一件极其漂亮的软件，就是尽可能小的那种编码 agent。你可以用 Pi 来修改和扩展 Pi，对吧？这就是那种自我扩展、自我指涉的软件理念，真的很迷人。你说得对，Open Claw 就是建在它之上的。我很好奇的一件事是，未来还会有多少别的经典软件以这种形式出现——一开始是个极小的东西，然后用 agent 随着时间不断扩展。我越来越觉得——老实说，看看我们从拥有自己可定制软件中得到的好处，我猜未来很多商业软件会开箱即带这种能力。有一个很有意思、很微妙的点我想聊聊，是我从你那篇文章里学到的：AI 既可以是中心化的，也可以是去中心化的。Google Gmail 那个「我没法改提示词」的事，就是个完美的例子。我们基本上在接下来——我觉得都不用太久，大概十八到二十四个月，也可能要五年——要做一个选择。大致有两种情形，我脑子里浮现的简直就是 Apple 那支 1984 年的 Macintosh 广告，就是那句「2034 会不会变成 1984？」你知道，1984 那个版本就是：我们走向中心化控制，有五个国王，最后可能只有其中一个胜出。他们有最先进的 AI，他们绕过了所有的算力和电力限制，他们拥有所有的太空数据中心——因为反正在美国你建不了什么地面数据中心。这就是一种控制权的中心化。而且不止于此，他们还不让你跑自己的提示词。他们真的就做 Gmail 那一套，但是套到你整个计算生活上，对吧？这就好像个人电脑从来没出现过，世上只有大型机和小型机一样。这段历史几乎被时间的尘沙湮没了，但你知道，在上世纪六七十年代电脑刚出来的时候，你没法像今天这样去商店——你没法走进 Apple Store 随手买台 iPhone，更别提 Mac 了。你得设法去用那种价值几十万到几百万美元的大家伙。而唯一——
[42:22] Garry Tan
was like And it was like tightly locked down by corporate policies. You're right. And the And the thing that really spurred the computing revolution was when people started having personal computers that they could experiment on. Yeah. And just like the priesthood, right? There was a small priesthood and an institutional base that controlled capital, literally the means of production. And so, you know, this is like a coherent future that we could live in that I don't want to live in. And the alternative to that is actually uh embedded in the Homebrew Computer Club. It's embedded in the revolution that Steve Jobs and Steve Wozniak gave us when they were in the garage in Mountain View, literally soldering together breadboards. And they like sold 500 of these Apple Ones. And I think we're at the Apple One moment right now. We are coming up with the primitives. We are learning how do these things work and how do we sell it and how do we package it? Uh but then there's like a lot of choices right now, right? Like most people, the mass you know, a billion users use ChatGPT. And ChatGPT like gives you a little access. But MCP is really locked down. You actually, you know, can't hook things up to your own databases that easily. Um and you know, for what? Safety? Like I would argue Claude is like a little bit more open, but not really. Perplexity is probably the best version of it, but it's still like you know, pretty limited compared to what you could do with Open Claude and Hermes Agent. And so, what does the uh revolution look like that is like the true personal AI moment? And that's what I hope that we are building with things like G Brain and you know, Hermes Agent and Open Claude. Like the ability to run your own software, to change your own prompts, to test all of it, to have your own private repo that like you know is only yours, to be able to choose which model to use, and maybe it's an open weight model. Like to me that's sort of the white pill for AI is we could have corporate control, no control of your own prompts, and like literally the AI happens to you. You know, you're under the API line. Or like there's this other alternative where I want like a billion people to actually control and program for themselves what are these things. This should be an extension of yourself and what you care about, not what, you know, Meta or Alphabet or even OpenAI or Anthropic care about. I always really bristle when I see AI framed as a way to replace people because it just doesn't match the way that I have experienced it and the way that so many of the people around me have experienced it, not as a replacement for humans, but as a thing that empowers. If you look at at at kind of how tech has developed since the era of of mainframes to PCs to the internet which gave everyone like a publishing platform like it's it's a story overall above all of individual empowerment and I think AI is going to play out the same way. I think it is going to enable us to do more than we could before. I think it's going to eliminate kind of the drudgery style work that like made a lot of my job painful in the past. To me it's like we have to make choices to do so. By default like a company is not open. By default a company is command and control. By default maybe the leadership gets access to these tools, but like the, you know, line level people, the staff people don't, right? And like we need like a radically different type of organization and we need to actually offer computing in a different way and these are all choices and the people who are watching are going to be the people who build all these things in society. So, we better choose well.
——而且它被企业政策死死锁住。你说得对。而真正点燃这场计算革命的，是人们开始有了自己的个人电脑、可以拿来折腾的时候。对。这就像一个祭司阶层（priesthood），对吧？有一小撮祭司、一个掌控资本的体制基础，掌握着字面意义上的生产资料。所以你知道，这是一个我们可能会身处其中、但我并不想身处其中的、自洽的未来。而它的另一种可能，其实就藏在 Homebrew Computer Club 里。它藏在 Steve Jobs 和 Steve Wozniak 带给我们的那场革命里——他们当年在 Mountain View 的车库里，真的就在那儿手焊面包板。他们卖出了五百台 Apple One。我觉得我们现在正处在 Apple One 时刻。我们正在搞出这些原语（primitives），我们正在学这些东西怎么运作、怎么卖、怎么打包。但眼下也有很多选择，对吧？比如大多数人，那一大批——你知道，十亿用户在用 ChatGPT。ChatGPT 给你开了一点点口子。但 MCP 被锁得很死。你其实没法那么轻松地把它接到自己的数据库上。为了什么呢？安全？我会说 Claude 算是稍微开放一点，但也没真开放多少。Perplexity 大概是这里头做得最好的版本，但跟你用 Open Claude 和 Hermes Agent 能做的相比，还是相当受限。所以，那个真正属于「个人 AI 时刻」的革命，会是什么样子？这就是我希望我们正在用 G Brain、Hermes Agent、Open Claude 这些东西去构建的：能跑自己的软件，能改自己的提示词，能把这一切都测一遍，能有一个只属于你自己的私有仓库，能选用哪个模型——也许是个开放权重（open weight）模型。对我来说，AI 的那颗「白药丸」就是：我们可以走向企业控制、无法掌控自己的提示词、AI 字面意义上是「降临到你头上」的——你处在 API 线之下；或者走向另一种可能，我希望让十亿人真正去掌控、去为自己编程这些东西。它应该是你自身的延伸，是你所在乎之事的延伸，而不是 Meta、Alphabet，甚至 OpenAI 或 Anthropic 所在乎之事的延伸。每当我看到 AI 被描绘成一种取代人的方式，我都会本能地抗拒，因为这跟我亲身体验到的、跟我身边那么多人体验到的方式都不符——它不是人类的替代品，而是一种赋能的东西。如果你看看科技自大型机时代以来是怎么一路发展的——从大型机到 PC，再到给了每个人一个发布平台的互联网——这通篇是一个关于个体赋能、压倒一切的故事，我觉得 AI 也会这样演下去。我觉得它会让我们做到比从前更多的事。我觉得它会消除掉那种让我过去的工作如此痛苦的、苦力式的杂活。对我来说，关键是我们必须主动做出选择才行。默认情况下，一家公司是不开放的。默认情况下，公司是命令与控制式的。默认情况下，也许只有领导层能拿到这些工具，而你知道，一线员工、基层员工拿不到，对吧？我们需要一种根本上不同类型的组织，我们需要真正以一种不同的方式去提供计算能力——而这些全都是选择。正在看这期节目的人，将会是那些在社会中亲手构建出这一切的人。所以，我们最好选对。
[46:05]
[music]
（音乐）
[46:05] Garry Tan
Well, that's all the time we have for today. I mean, I think we covered some pretty heavy stuff, but Pete, thanks for joining us. Thank you. Thank you. Thanks for watching, guys. We'll see you guys on the next one.
好了，今天的时间就到这里。我是说，我觉得我们聊了不少挺有分量的东西，不过——Pete，谢谢你来参加。谢谢。谢谢。也谢谢大家收看，我们下期再见。