Andrej Karpathy on Software 3.0 and the Future of Intelligence | AI Ascent 2026
概要
Karpathy AI Ascent 2026 访谈:Software 3.0 范式、vibe coding 到 agentic engineering、可验证性决定 AI 自动化边界、神经网络将成为宿主进程
核心洞察
被访者:Andrej Karpathy(OpenAI 联合创始人、前 Tesla Autopilot 负责人)
访谈者:Stephanie Zhan,Sequoia Capital · AI Ascent 2026
时长:约 30 分钟 | 整理日期:2026-05-02
Executive Summary
Karpathy 以自身 2025 年 12 月的"顿悟时刻"为起点,完整阐述了 Software 3.0 范式——编程正从写代码(1.0)、训练权重(2.0)转向"把文本复制粘贴给 Agent"(3.0)。他用 MenuGen、OpenClaw 安装等亲身案例证明:大量现有应用"不应该存在",神经网络正在吞噬中间层代码。在自动化边界问题上,他提出可验证性(Verifiability)框架:RL 训练天然偏向可验证领域,导致模型能力呈"锯齿状"(jagged)分布——同一个 Opus 4.7 能重构十万行代码库却建议你步行去洗车。对创业者的建议是:寻找高价值但尚未被实验室覆盖的可验证 RL 环境,自行微调即可拉开差距。在人类角色层面,他区分了 Vibe Coding(提升所有人的能力下限)与 Agentic Engineering(保持专业软件的质量上限),强调人类仍需掌控品味、判断和系统设计——"你可以外包思考,但无法外包理解"。
2025 年 12 月:从"偶尔好用"到"再没改过一行"
- Karpathy 在 2025 年 12 月假期密集使用最新模型,发现代理式工具输出的代码"直接就对了",他甚至想不起上一次手动修正是什么时候——这标志着从辅助工具到全面信任的质变
- 他在 X/Twitter 上反复呼吁:很多人对 AI 的认知还停留在"ChatGPT 类聊天工具",但 2025 年 12 月之后,Agentic Coherent Workflow 已经"真正开始 work 了"
- 直接后果:他的 side projects 文件夹爆炸式增长,全部采用 vibe coding 完成,进入"无限 side projects"模式
Software 3.0:编程 = 给 Agent 的复制粘贴文本
- 1.0 → 写代码;2.0 → 整理数据集 + 训练神经网络;3.0 → Prompt + Context Window 就是你对 LLM 解释器的全部杠杆
- OpenClaw 案例:安装不再是一个膨胀的 Shell 脚本,而是一段给 Agent 的文本指令。Agent 自带智能,能观察环境、执行操作、在循环中自动 debug,远比精确指定每个步骤强大
- MenuGen 案例(核心叙事弧):Karpathy 花大量精力 vibe-code 了一个 Vercel 应用——拍餐厅菜单照片 → OCR 提取菜名 → 图像生成器渲染菜品图片 → 重新排版展示。但 Software 3.0 版本只需一步:把照片丢给 Gemini,说"用 Nanobanana 把菜品图片叠加到菜单上",直接在原始图片像素层面渲染出结果。整个 MenuGen 应用根本不应该存在
- 推论:这不仅仅是"编程加速",而是全新类别的信息处理成为可能。例如他的 LLM Knowledge Bases 项目——让 LLM 为组织或个人创建 Wiki,这在以前根本没有对应的代码可写
可验证性框架:为什么 AI 能力是"锯齿状"的
- 前沿实验室训练 LLM 本质上是巨型 RL 环境:给验证奖励 → 模型在可验证领域(数学、代码)能力飙升,在不可验证领域则"粗糙、锯齿"
- 经典案例对比:Opus 4.7 能同时重构十万行代码库、发现 zero-day 漏洞,却会告诉你"洗车店只有 50 米远,建议步行去"——这种荒诞的锯齿感说明模型并非通用智能
- 国际象棋轶事:GPT-3.5 到 GPT-4 国际象棋能力飞跃,很多人以为是通用能力提升,实际上是 OpenAI 有人决定把大量棋谱数据放进预训练集。用户处于实验室决策的"受摆布"位置——哪些 RL 电路被激活,完全取决于实验室选择关注什么
- 对创业者的建议:即使实验室没有直接聚焦你的领域,只要该领域可验证、能构建 RL 环境,你就可以自行微调并获得优势。Karpathy 暗示存在一个他认为极有价值但尚未被覆盖的领域(拒绝透露具体答案——"Sorry, I don't mean to vague-post on stage")
Vibe Coding vs Agentic Engineering:下限与上限的区分
- Vibe Coding = 提升全民能力下限:任何人都能 vibe code 出一个应用,这是了不起的民主化
- Agentic Engineering = 维持专业软件质量上限:不允许因 vibe coding 引入安全漏洞,仍需对软件质量负全责,但要用 Agent 大幅提速
- Karpathy 将 Agentic Engineering 定义为一门"工程学科":Agent 是 spiky、stochastic 但极其强大的实体,如何协调它们在不牺牲质量的前提下加速,就是这门学科的核心
- 关于 10x 工程师:在 agentic 时代,顶尖工程师的倍数远超 10x,峰值差距被极大放大
人类不可替代的能力:品味、判断与系统设计
- Agent 目前仍是"实习生级别"实体:人类负责审美、判断、品味和顶层监督
- Stripe x Google 账户 Bug 案例:MenuGen 用户用 Google 账号注册、用 Stripe 付款,Agent 试图用 Stripe 邮箱去匹配 Google 邮箱关联资金,完全忽略了用户可能使用不同邮箱——缺少持久化 user ID 的系统设计意识
- Agent 生成的代码质量问题:bloaty、大量 copy-paste、抽象脆弱——"it works but it's really gross"
- MicroGPT 项目实验:Karpathy 反复提示 LLM 简化 LLM 训练代码,模型"做不到"——明显感觉到脱离了 RL 电路,像"在拔牙"而非"光速飞行"
- 人类仍需掌握底层概念(如 tensor 的 view vs storage、内存效率),但 API 细节(keep_dims vs keep_dim、dim vs axis)可以完全交给 Agent
- 招聘范式必须变革:不应再出编程谜题,应让候选人完成大型端到端项目(如"用 Agent 写一个 Twitter 克隆,部署后用 10 个 Codex 5.4x 尝试攻破它")
Agent-Native 世界:一切都要为 Agent 重写
- 当前所有框架、库、文档仍是"写给人类的"——Karpathy 最大的 pet peeve:"为什么还在告诉我该做什么?我什么都不想做,直接告诉我该给 Agent 复制粘贴什么!"
- 部署 MenuGen 时最大的痛苦不是写代码,而是配置 Vercel、DNS、各种第三方服务的设置菜单——理想状态是一句 prompt 搞定从构建到部署的全流程
- 未来展望:神经网络成为"宿主进程",CPU 退化为"协处理器";计算花费的主体从经典计算转向 neural network inference
- 终极形态:每个人和组织都有自己的 Agent 代表,"my agent talks to your agent"来处理会议安排等细节
教育与理解:不可外包的最后堡垒
- Karpathy 反复引用一条让他"每隔一天就想起来"的推文:"You can outsource your thinking, but you can't outsource your understanding"
- 他感到自己正在成为瓶颈——甚至连"我们要构建什么、为什么值得做"这些基本方向判断,都需要人脑的深度理解来支撑
- LLM Knowledge Bases 作为理解增强工具:每读一篇文章就自动扩充个人 Wiki,通过不同视角的信息投射(synthetic data generation over fixed data)来获得洞察
- 核心观点:LLM 在"理解"层面尚无优势,人类在此仍不可替代;理解力决定了你能否成为好的"导演"来指挥 Agent 集群
附录:关键人/机构/产品/数据
| 概念 | 定义 |
|------|------|
| Software 3.0 | 编程 = Prompt + Context Window,LLM 作为解释器 |
| 可验证性(Verifiability) | RL 训练的核心杠杆,决定模型能力的锯齿分布 |
| 锯齿智能(Jagged Intelligence) | 模型在 RL 覆盖领域飙升、在覆盖外领域崩塌的不均匀特征 |
| Ghosts vs Animals | LLM 是统计模拟电路上的"幽灵",非进化驱动的"动物"——无内在动机、好奇心或恐惧 |
| Vibe Coding | 全民编程的能力下限提升 |
| Agentic Engineering | 在保持质量上限的前提下用 Agent 加速的工程学科 |
| Agent-Native | 为 Agent 而非人类设计的基础设施、文档和工作流 |
ctually helped co-ound open AAI right inside of this office. Was the one who actually got Autopilot working at Tesla back in the day, and he has a rar
e gift of making the most complex technical shifts feel both accessible and inevitable. You all know him for having coined the term vibe coding last y
ear, but just in the last few months, he said something even more startling. That he's never felt more behind as a programmer. That's where we're star
ting today. Thank you, Andre, for joining us.
hat you've never felt more behind as a programmer. That's startling to hear from you of all people. Um, can you help us unpack that? Was that feeling
exhilarating or unsettling?
ls like lot code, adjacent things, uh for a while, maybe over the last year as it came out and it was very good at you know chunks of code and sometim
es it would mess up and you have to edit them and it was kind of helpful and then I would say December was this uh clear point where for me I was on a
break so I had a bit more time. I think many other people were similar and uh I just started to notice that with the latest models uh the chunks just
came out fine and then I kept asking for more and it just came out fine and then I can't remember the last time I corrected it and then I was I just
you know trusted the system more and more and then I was vibe coding [laughter] and uh so it was kind of a I do think that it was a very stark transit
ion. I think that a lot of people actually I tried to I tried to stress this on uh Twitter and or X because I think a lot of people experienced AI las
t year as ChachiPT adjacent thing. Uh but you really had to look again and you had to look as of December uh because things have changed fundamentally
and uh especially on this like agentic coherent workflow uh that really started to actually work. Um, and so I would say that um, yeah, it was just t
hat realization that really uh, uh, had me um, go down their whole rabbit hole of just, you know, infinity side projects. Uh, my side projects folder
is like extremely full with lots of random things and, uh, just, uh, V coding all the time. Uh, so, uh, yeah, that kind of happened in December, I wou
ld say, and I was looking at the repercussions of that since.
ust better software, it's a whole new computing paradigm. And um software 1.0 was explicit rules, software 2.0 was learned weights, software 3.0 is th
is. Um if that's actually true, what does a team build differently the day they actually believe this,
比如当 OpenClaw 出来的时候,当你想安装 OpenClaw,你通常会期望这是一个 bash 脚本,一个 shell 脚本。运行 shell 脚本来安装 OpenClaw。但问题是,为了适配很多不同的平台和很多不同类型的计算机,你可能需要在上面运行 OpenClaw,这些 shell 脚本通常会膨胀变得极其复杂。但问题是你仍然被困在 software 1.0 的世界里,想要写代码。而实际上 OpenClaw 的安装是一大段文本,你应该复制粘贴给你的 agent。所以基本上它是一个小技能——复制粘贴这段文字,交给你的 agent,它就会安装 OpenClaw。这之所以强大得多,是因为你现在在 software 3.0 的范式下工作,你不需要精确地拼写出设置的每一个细节。Agent 有自己的智能,它会打包好然后按照指令行事,它会查看你的环境、你的电脑,执行智能操作来让事情运转,它在循环中调试问题,这就是强大得多的方式,对吧?
所以我认为这是一种非常不同的思维方式——那段要复制粘贴给你 agent 的文本是什么?这就是编程范式。我觉得还有一个更极端的例子是我构建 MenuGen 的时候。MenuGen 的想法是,你去一家餐厅,他们给你一个菜单。通常没有图片。所以我不知道这些东西是什么,通常大概 30% 的菜我完全不知道是什么,50% 也有可能。所以我想拍一张餐厅菜单的照片,然后得到这些菜可能长什么样的图片,一种通用意义上的。所以我 vibe code 了这个应用,基本上让你上传一张照片,它做所有这些事情,它运行在 Vercel 上,基本上重新渲染菜单,给你所有的菜品,给你一张图片——它用一个图像生成器来 OCR 所有不同的标题,用图像生成器来获取它们的图片,然后展示给你。
然后我看到了这个的 software 3.0 版本,这让我震惊了——就是直接拍照,交给 Gemini,说用 Nanobanana 把这些东西叠加到菜单上。然后 Nanobanana 返回的图像恰好就是我拍的那张菜单的照片,但它实际上在像素里渲染了菜单上不同菜品的样子。这让我震惊了,因为实际上我整个 MenuGen 都是多余的。它是在旧范式下工作的,那个应用不应该存在。而 software 3.0 范式更加原始。你的神经网络做越来越多的工作,你的 prompt 或 context 就只是图像,输出也是图像,中间不需要任何应用。
所以我觉得人们必须重新构建思维框架,不要在现有范式下思考,然后仅仅把它当作现有事物的加速。实际上是有新的东西现在可以实现了。回到你关于编程的问题,我觉得那也是在旧思维模式下的例子,因为这不仅仅是关于编程以及编程变得更快。这是更广泛的信息处理现在可以被自动化了。所以这甚至不仅仅是关于代码。以前的代码处理的是结构化数据,对吧?你在结构化数据上写代码。但是比如我的 LLM knowledge bases 项目——基本上你让 LLM 为你的组织或个人创建 wiki 等等。这甚至不是一个程序。这是以前不可能存在的东西,因为以前没有代码能基于一堆事实创建一个知识库。但现在你可以把这些文档用不同的方式重新编译,重新排序,创造出新的、有趣的东西,作为对数据的重新构建。所以这些是以前不可能的新事物。我觉得这是我一直试图回到的主题——不仅仅是我们能做什么以前存在的事情现在更快了,我觉得还有新的机会,是以前不可能的事情,我几乎觉得那才是更令人兴奋的。
I'm writing code, software 2.0, I'm actually programming by creating data sets and training uh training neural networks. So the programming is kind o
f like arranging data sets and maybe some objectives and neural network architectures. And then what happened is that basically if you train one of th
ese GPT models or LLMs on a sufficiently large set of tasks implicit basically um implicitly because by training on the internet you have to multitask
all the things that are in the data set. Uh these actually become kind of like a programmable computer in a certain sense. So software 3.0 know is ki
nd of about uh you know your programming now turns to prompting and what's in the context window is your lever over the interpreter that is the LLM th
at is kind of like interpreting your context and uh performing computation in the dig digital information space. So I guess um yeah that's kind of the
transition and I think there's a few examples of that really drove it home for me and maybe that might be instructive. Uh so for example when you whe
n openclaw came out when you want to install openclaw you would expect that normally this is a bash bash script like a shell script. So run the shell
script to run to install open claw. Um but the thing is that in order to target lots of different platforms and lots of different types of computers y
ou might run an open claw. This these shell scripts usually balloon up and become extremely complex. But the thing is you're still stuck in a software
1.0 universe of wanting to write the code. And actually the open claw installation is a is a copy paste of a b bunch of text that you're supposed to
give to your agent. Uh so basically it's it's a little skill of uh you know copy paste this and give it to your agent and it will install open claw. A
nd the reason this is a lot more powerful is you're working now in the software 3.0 paradigm where you don't have to precisely spell out you know all
the individual details of that setup. The agent has its own intelligence that it packages up and then it kind of like follows the instructions and it
looks at your environment, your computer and it kind of like performs intelligent actions to make things work and it debugs things in the loop and it'
s just like so much more powerful, right? So I think that's a very different kind of like way of thinking about it is just like what is the piece of t
ext to copy paste to your agent? That's the programming paradigm. Now I think one more maybe uh example that comes to mind that is even more extreme t
han that is when I was building um menu genen. So, menu genen is this idea where you um you come to a restaurant, they give you a menu. There's no pic
tures usually. So, I don't know what any of these things are uh usually like 30% of the things I have no idea what they are, 50%. So, I wanted to take
a photo of the restaurant menu and to get pictures of what those things might look like in a generic sense. And so I built I've vcoded this app that
basically lets you upload a photo and it does all this stuff and it runs on Verscell and uh it basically rerenders the menu and it gives you like all
the items and it gives you a picture that it uses an image um you know generator uh for to basically OCR all the different titles uh use the image gen
erator to get pictures of them and then shows it to you. And then I saw the software 3.0 version of this which is which blew my mind which is literall
y just take your photo give it to Gemini and say use Nanobanana to overlay the the things onto the menu. Uh and Nanabanana basically returned an image
that is exactly the picture of the menu that I took but it actually put into the pixels it rendered the different things in the menu and this blew my
mind because actually all of my menu gen is spirious. It's working in the old paradigm that app shouldn't exist. uh and uh yeah the software 3.0 para
digm is a lot more kind of raw. It just um your neural network is doing more and more of the work and your prompt or context is just the image and the
output is an image and there's no need to have any of the app in between. Um so I think that people have to kind of like reframe you know not to work
in existing paradigm of what things existed and just think about it as a speed up of what exists. It's actually like new things are available now. An
d going back to your programming question, it's not even I think that's also an example of working in the in the old mindset because it's not just abo
ut programming and programming becoming faster. This is more general information processing that is automatable now. So um it's not just even about co
de. So previous code worked over kind of like structured data, right? And uh you write code over structured data. But like for example with my LLM kno
wledge basis project um basically you get LLMs to create wikis for your organization or for you in person etc. This is not even a program. This is not
something that could exist before because there was no there was no code that would create a knowledge base based on a bunch of facts. But now you ca
n just take these documents and uh basically uh recompile them in a different way and uh reorder them and create something that is uh new and interest
ing uh as a reframing of the data. And so these are new things that weren't possible. Uh and so I think this is uh something that I keep trying to get
back to as to not only what can we do that existed that is faster now but I think there's new opportunities of just things that couldn't be possible
before and I almost think that that's more exciting.
ny folks here followed your own progression of programming from last October to early January February this year. Um, if you extrapolate that further,
what is the 2026 equivalent um, for building websites in the '9s, building mobile apps in the 2010s, building SAS um, in the last cloud era, what wil
l look completely obvious in hindsight that is still mostly unbuilt today?
o a lot of this code shouldn't exist and it's just neural network doing most of the work. Um I do think that the extrapolation looks very weird becaus
e you could basically imagine I don't I yeah so you could imagine completely neural computers in a certain sense you feed raw videos like imagine a de
vice you takes raw videos or audio into basically what's a neural net and uh uses diffusion to render a UI that is kind of like you know unique for th
at moment in a certain sense and um I kind of feel like in the early days of computing actually people were a little bit confused as to whether comput
ers would look like calculators or computers would look like neural nets and in 50s and 60s it was not really obvious which way would go and of course
we went down the calculator path and ended up building classical computing and then neural nets are currently running virtualized on existing compute
rs but you could imagine I think that uh a lot of this will flip and that the neural net becomes kind of like the host process and uh the CPUs become
kind of like the co-processor so we saw the diagram of you know intelligence compute is going to of neural networks is going to take over and become t
he dominant spend of flops so you could imagine something really weird and foreign when where neural nets are doing most of the heavy lifting. They're
using tool use as this like you know um historical appendage for some kinds of like deterministic tasks. Uh but what's really running the show is the
se uh neural nets that are in a certain way. Um so you can imagine something extremely foreign as the extrapolation but I think we're going to probabl
y get there uh sort of piece by piece. Um and I don't yeah that that progression is TBD I would say.
[snorts]
t um uh this concept of verifiability, the fact that AI will automate faster and more easily domains where the output can be verified. Um if that fram
ework is right, what work is about to move much faster than people realize and what professions do we have that people actually think are safe but tha
t are actually highly verifiable?
所以我觉得我写关于可验证性的原因是我在试图理解为什么这些东西如此参差不齐。其中一些与实验室如何训练模型有关,但我觉得一些也与实验室的关注重点以及他们碰巧放进数据分布中的东西有关。因为有些东西在经济中显著更有价值,最终创造了更多的环境,因为实验室想要在那些设置中工作。所以我觉得代码是一个很好的例子。可能有很多可验证的环境他们可以考虑,但碰巧没有纳入其中,因为在那些领域拥有能力并没有那么有用。
但我觉得对我来说最大的谜团是——有一段时间最喜欢的例子是 strawberry 这个词里有多少个字母 r,模型出了名地会答错,这是参差不齐的一个例子。模型现在已经修补了这个问题,但新的例子是:我想去洗车,洗车店离我 50 米远,我应该开车还是走路?最先进的模型今天会告诉你走路去,因为它太近了。怎么可能最先进的 Opus 4.7 可以同时重构一个十万行(笑声)的代码库或者发现零日漏洞,却告诉我走路去洗车?这太疯狂了。在这些模型仍然参差不齐的程度上,这表明第一,也许有什么地方稍微不对,第二,你确实需要在循环中,你需要把它们当作工具,你确实需要保持对它们在做什么的关注。
所以我觉得我所有关于可验证性的写作,长话短说,就是试图理解为什么这些东西是参差不齐的。有没有什么模式?我觉得是某种可验证加上实验室关注的组合。也许还有一个有启发性的轶事——从 GPT-3.5 到 GPT-4,人们注意到国际象棋能力提高了很多,我觉得很多人认为这只是能力的自然进步,但实际上更多的是——我觉得这是公开信息,我在网上看到过——大量的国际象棋数据被纳入了 pre-training 数据集。只是因为它在数据分布中,模型就比默认情况进步多得多。所以是 OpenAI 的某个人决定添加这些数据,然后你就有了一个大幅提升的能力。这就是为什么我要强调这个维度——我们在某种程度上受实验室所做的事情摆布,受他们碰巧放进去的东西的影响。你得实际去探索他们给你的这个没有说明书的东西。它在某些场景下有效,但在某些场景下可能不行。你得自己探索一下。如果你在那些属于 RL 训练过的电路中,你会飞起来。如果你在数据分布之外的电路中,你会很挣扎,你得搞清楚你的应用在哪些电路中。如果你不在那些电路中,那你就得认真看看 fine-tuning,自己做一些工作,因为它不一定能直接从 LLM 开箱即用地出来。
automate what you can specify in code and uh kind of this latest round of LLMs can easily automate what you can uh verify in a certain in a certain s
ense because the way this works is that when frontier labs are training these LLMs these are giant reinforcement learning environments. So they are gi
ven verification rewards and then because of the way that these models are trained they end up basically uh progressing and creating these like jagged
entities that really peak in capability in kind of like verifiable domains like math and code and adjacent and kind of like stagnate and are a little
bit um you know rough around the edges when uh things are not kind of like in that in that space. So I think the reason I wrote about verifiability i
s I'm trying to understand why these things are so jagged. Um and some of it has to do with how the labs train the models but I think some of it also
has to do with um the focus of the labs and what they happen to put into the data distribution. Uh because some things basically are significantly mor
e valuable in economy and end up creating more environments because the labs wanted to work in those settings. So I think code is a good example of th
at. There's probably lots of verifiable environments they could think about that happen not to make it into the mix because they're just not that usef
ul to have the capability around. Um, but I think to me the big um I guess like the big mystery is uh the favorite example for a while was that how ma
ny letters are are in a strawberry and the models would famously get this wrong and it's an example of jaggedness. Uh the models now patch this I thin
k but the new one is I want to go to a car wash to wash my car and it's 50 meters away. Should I drive or should I walk? And state-of-the-art models t
oday will tell you to walk because it's so close. How is it possible that state-of-the-art Opus 4.7 will simultaneously refactor a 100,000 like [laugh
ter] codebase line codebase or find zero day vulnerabilities and yet tells me to walk to this car wash? This is insane. And to whatever extent these u
h models are remain jagged, it's an indication that number one maybe something's slightly off or um number two you need to actually be in the loop a l
ittle bit and you need to treat them as tools and you do have to kind of stay in touch with what they're doing. And so I think all of my writing long
story short about verifiability is just trying to understand um why these things are jacked. Is there any pattern to it? And I think it's some kind of
a combination of verifiable plus labs care. Maybe one more anecdote that is instructive is uh from GPT 3.5 to GPT4 people noticed that chess improved
a lot and I think a lot of people thought oh well it's just a progression of the capabilities but actually it's it's more that uh I think this is pub
lic information I think I saw it on the internet um a huge amount of like um data of chess made it into the pre-training set and just because it's in
a data distribution uh basically the model improved a lot more than it would just by default. So someone at OpenAI decided to add this data and now yo
u have a capability that just peaked a lot more. And so that's why I think I'm stressing this um dimension of it as we are slightly at the mercy of wh
atever the labs are doing, whatever they happen to put into the mix. And you have to actually explore this thing that they give you that has no manual
. And it works in certain settings, but maybe not in some settings. And you have to kind of um explore it a little bit. And uh if you're in the circui
ts that were part of the RL, you fly. And if you're in the circuits that are out of the data distribution, uh you're going to struggle and you have to
kind of figure out which which circuits you're in in your application. And if you and if you're not in the circuits, then you have to really look at
fine-tuning and doing some of your own work because it's not going to necessarily come out of the LLM out of the box.
concept of jagged intelligence in a little bit. Um, if you are a founder today and thinking about building a company, you are trying to solve a proble
m that you think is tractable, something that uh is a domain that is verifiable, but you look around and you think, "Oh my gosh, well, the labs have r
eally really started uh getting to escape velocity in the ones that seem most obvious, math, coding, and others." What would your advice be to to the
founders in the audience?
fiability makes something tractable in the current paradigm because you can throw a huge amount of RL at it. Um so maybe one way to see it is that uh
that remains true even if the labs are not focusing on it directly. So if you are in a verifiable setting where you could create these RL environments
or examples then that actually sets you up to potentially do your own fine tuning and you might benefit from that. But that is fundamentally technolo
gy that just works. You can pull a lever if you have huge amount of diverse data sets of RL environments etc. Uh you can use your favorite fine-tuning
framework and um and uh pull the lever and get something that actually uh works pretty well. So um I don't know what the examples of this might be. U
m, but I do think there are some very valuable uh reinforcement learning environments that people could think of that I think are not part of the Yeah
, I don't want to give away the answer, but there is one domain that I think is very uh Oh, okay. Sorry, I don't mean to vape post on on the stage, bu
t there are some examples of this.
almost everything can be made uh verifiable to some extent. some things easier than others. Um because even for like things like writing or so on, you
can imagine having a council of LLM judges and probably get get to some get get something uh reasonable out of the um from from this kind of an appro
ach. So it's more about what's easy or hard. Um so I I do think that ultimately um uh yeah, I think uh
atable.
t engineering. What do you think is the difference between the two and what would you actually call what we're in today?
ibe coding is about raising the floor for everyone in terms of what they can do in software. So the floor rises, everyone can vibe code anything and t
hat's amazing, incredible. But then I would say agentic engineering is about preserving the quality bar of what existed before in professional softwar
e. So you're not allowed to introduce vulnerabilities due to VIP coding. Um you are um you're still responsible for your software just as before, but
can you go faster? And spoiler is you can but how do you how do you do that properly? And so to me agentic engineering when I call it that because I d
o think it's kind of like an engineering discipline. You have these agents which are these like spiky entities. They're a bit fable, a little bit stoc
astic, but they are extremely powerful. is how do you how do you coordinate them to go faster without sacrificing your quality bar and doing that well
and correctly um is the the realm of agentic engineering um so I kind of see them as as different like one is about maybe raising the raising the flo
or and the other is about um you know extrapolating and what I'm seeing I think is there is a very high ceiling on agentic engineer uh capability and
you know people used to talk about the 10x engineer previously I think that this is magnified a lot more 10x is uh is not uh the speed up you gain. Um
and I think uh it does seem to me like people who are very good at this um peak a lot more than 10x uh from from my perspective right now.
y like that framing. Um one thing that when Sam Alman came to AIN last year, one memorable thing he said was that people of different generations use
chatpt differently. So if you're in your 30s, you use it as a Google search replacement. But if you're in your teens, tragic is your gateway to the in
ternet. What is the parallel here in coding today? If we were to watch two people code using OpenClaw, Claude Code, Codeex, one you'd consider mediocr
e at it and one you would consider fully AI native. How would you describe the difference?
我觉得一个相关的想法是,很多人可能正在为此招聘,因为他们想雇佣强大的 agentic engineer。我看到的是大多数人仍然没有为 agentic engineering 能力重构他们的招聘流程。如果你还在出谜题让人解,这仍然是旧范式。我会说招聘应该变成这样——给我一个真正大的项目,看看某个人怎么实现那个大项目。比如说写一个 Twitter 克隆给 agent 用,然后把它做得非常好、非常安全,然后让一些 agent 在这个 Twitter 上模拟一些活动,然后我要用 10 个 Codex 5.4 或者 X high 来试图攻破你部署的这个网站,它们会试图破坏它,但应该做不到。也许就是这样的形式,对吧?所以是的,在那种环境中观察人们构建更大的项目并利用工具,也许就是我会主要关注的。
I mean I think it's a just trying to
get the most out of the tools that are available utilizing all of their features investing into your own um kind of setup. Uh so just like previously
all the engineers are used to basically getting the most out of the tools you use either it's vim or v code or now it's you know cloth code or codec o
r so on. So um just investing into your setup um and um utilizing a lot of the you know uh tools that are available to you. Um and I think it just kin
d of looks like that. I do think that um maybe related thought is um a lot of people are maybe hiring um for this right because they want to hire stro
ng agentic engineers. I do think that um what I'm seeing is that uh the you know most people have still not refactored their um their hiring process f
or a gentic engineer capability right like if you're giving out puzzles to solve and this is still the old paradigm I would say that hiring have to ha
s to look like give me a really big project and see someone implement that big project like let's write say a Twitter clone uh for agents and then uh
make it really good make it really secure and then have some agents uh simulate some activity uh on this Twitter and then I'm going to use 10 codecs 5
.4x for X high to try to break your break your um uh this website that you deployed and they're going to try to basically break it and they should not
be able to break it. And so maybe it looks like that, right? And so yeah, watching people in that that setting and building bigger uh projects and uh
utilize utilizing the tooling is maybe what I would uh look at for the most part.
e valuable, not less?
所以我觉得人们必须负责这个 spec,这个计划。而且我实际上甚至不喜欢 plan mode。我的意思是——显然它非常有用——但我觉得这里有一些更一般性的东西,你需要和你的 agent 一起设计一个非常详细的 spec,也许基本上就是文档,然后让 agent 去写代码,你负责监督和顶层分类,但 agent 在做很多底层的工作。
所以我觉得你不再关心一些细节了。举个例子,神经网络中的数组或张量——PyTorch 和 NumPy 以及 Pandas 等等之间有大量的 API 细节。我已经忘了 keep_dims 还是 keepdim,是 dim 还是 axis,是 reshape 还是 permute 还是 transpose。我不再记得这些东西了,对吧?因为你不需要了。这是那种由实习生处理的细节,因为他们有非常好的记忆力。但你仍然需要知道,比如说底层有一个 tensor,有一个底层的 view,然后你可以操作同一个 storage 的 view,或者你可以有不同的 storage,那会更低效。所以你仍然需要理解这些东西在做什么以及一些基本原理,这样你就不会不必要地复制内存等等。但 API 的细节现在已经交出去了。所以你负责的是品味、工程、设计,确保它有意义,确保你在要求正确的东西,确保你说"好,这些必须是唯一的用户 ID,我们要把所有东西绑定到这个上面"。所以你在做一些设计和开发,工程师在填空。这目前就是我们所处的阶段,我觉得这是每个人现在都在看到的。
tities right so it's remarkable um you basically still have to be in charge of the aesthetics the the judgment the taste and a little bit of oversight
maybe one one of my favorite examples of like the the weirdness of agents is um for menu genen uh you sign up with a Google Google account but you um
purchase credits using a stripe account and both of them have email addresses and my agent actually tried to basically um like when you purchase cred
its, it assigned it using the email address from Stripe to the Google email address like there wasn't a persistent user ID that that uh for people it
was trying to match up the email addresses, but you could use different email address for your Stripe and your Google and basically would not associat
e the funds. And so this is the kind of thing that these agents still will make mistakes about is like why would you use email addresses to try to cro
ssorrelate the funds? They can be arbitrary. You can use different emails, etc. Like this is such a weird thing to do. So I think people have to be in
charge of this spec, this plan. And um I actually don't even like the plan mode. I I would I mean obviously it's very useful, but I think there's som
ething more general here where you have to work with your agent to design a spec that is very detailed and maybe it's uh maybe basically the docs and
then get the agents to write them and you're in charge of the oversight and the top level categories, but the agents are doing a lot of the under the
hood. And um so I think you're not caring about some of the details. So as an example also with um arrays or tensors in neural networks. Um there's a
ton of details between PyTorch and NumPy and all the different like pandas and so on for all the different little API details. And I I already forgot
about the keep dims versus keep dim or whether it's dim or axis or reshape or permute or transpose. I don't remember this stuff anymore, right? Becaus
e you don't have to. This is the kind of details that are handled by the intern because they have very good recall and but you still have to know for
example that um you know there's underlying tensor there's an underlying view and then you can manipulate view of the same storage or you can have dif
ferent storage which would be less efficient and so you still have to have an understanding of what this stuff is doing and some of the fundamentals u
m so that you're not copying memory around unnecessarily and so on but uh the details of the APIs are now handed off so it um you're in charge of the
taste the engineering the design um and that it makes sense and that you're asking for the right things and that you're saying that okay that these ha
ve to be unique user IDs that we're going to tie everything to um and so you're doing some of the design and development and the engineers are doing t
he fill in the blanks and that's currently kind of like where we are and I think that's what everyone of course is seeing I think right now
think there's a chance that this um taste and judgment matters less over time or will the ceiling just keep rising
一个好的例子是我的 micro GPT 项目,我试图把 LLM 训练简化到尽可能简单。模型讨厌这个。它们做不到。我不断尝试提示 LLM 简化再简化,它就是做不到。你能感觉到你在 RL 电路之外。感觉像是你在拔牙。它不像光速那样顺畅。所以我觉得人们仍然负责这些。但我确实认为没有什么根本性的东西在阻止它。只是实验室还没有做到,几乎是这样。
ould Okay. Um, I mean, I'm hoping that the that it improves. I think probably the reason it doesn't improve right now is again, it's not part of the R
L. There's probably no aesthetics cost or reward or it's not good enough or something like that. Um, I do think that when you actually look at the cod
e, sometimes I get a little bit of a heart attack because it's not like super amazing code necessarily all the time and it's very bloaty and there's a
lot of copy paste and there's awkward abstractions that are brittle and like it works but it's just really gross. Um, and I do I do hope that this ca
n improve in future models. Um, a good example also is this uh you know micro GPT project which where I was trying to simplify uh LLM training to be a
s simple as possible. The models hate this. They can't do it. I tried to I keep I kept trying to prompt an LLM to simplify more simplify more and it j
ust can't you feel like you're outside of the RL circuits. It feels like you're obviously you know you're pulling teeth. It's not like light speed. So
I think um I do think that people are still remain in charge of this. But I do think that there's nothing fundamental again that's preventing it. It'
s just the labs haven't done it yet almost.
So I'd love to come back to this idea of uh jagged forms of intelligence. you wrote a little b
it about this with a very thoughtprovoking piece around animals versus ghosts. Um, and the idea is that we're not building animals, we are summoning g
hosts. Um, and these are jagged forms of intelligence that are shaped by data and reward functions, but not by intrinsic motivation or fun or curiosit
y or empowerment. Uh, things that kind of came about via evolution. um why does that framing matter and what does it actually change about how you bui
ld and deploy and evaluate or even trust them?
what these things are, right? Because if you have a good model of what they are or are not, then you're going to be more competent at uh using them.
Um and I do think that um I don't know if it has I'm not sure if it actually has like real power. [laughter] I think it's a little bit of philosophizi
ng. Um, but I do think that um I think it's just um coming to terms with the fact that these things are not, you know, animal intelligences. Like if y
ou yell at them, they're not going to work better or worse or it doesn't have any impact. Um, and uh it's all just kind of like these statistical simu
lation circuits where the the substrate is pre-training so like statistics and then but then there's RL bolting on top. So, it kind of like increases
the dispendages and um maybe it's just kind of like a mindset of what I'm coming into or what's likely to work or not likely to work or how to modify
it. But I don't actually I don't know that I have like here are the five obvious outcomes of how to make your system better. It's more just being susp
icious of it and um
figuring out over time.
y have um real permissions. They have local context. they actually take action on your be your behalf. What does the world look like when we all start
to live in that world?
所以每个人都对如何把需要完成的工作分解为对世界的传感器和执行器感到兴奋。怎么让它 agent 原生化?基本上先向 agent 描述它,然后围绕对 LLM 非常可读的数据结构进行大量自动化。所以我希望有很多 agent-first 的基础设施出现。对于 MenuGen,当我写那篇博客文章的时候——不确定有多出名(笑声)——很多工作、很多麻烦不是写 MenuGen 的代码,而是在 Vercel 上部署它,因为我得跟所有这些不同的服务打交道,把它们串起来,得去它们的设置和菜单里,配置我的 DNS 之类的,真的太烦了。所以这是一个很好的例子。我希望对于 MenuGen,我能给一个 prompt 给 LLM,构建 MenuGen,然后我不需要碰任何东西,它就以同样的方式部署在互联网上。我觉得这是一个很好的测试,看我们的基础设施是否正在变得越来越 agent 原生。
然后最终我会说,是的,我确实认为我们正在走向一个世界,在那里人和组织都有 agent 代表。你知道的,我的 agent 会跟你的 agent 对话,来敲定我们会议的一些细节之类的。所以(笑声)我确实觉得大致就是往那个方向走,但嗯,是的,我想在座的每个人都对此感到兴奋。
nvironment looks like and everything has to be rewritten. Everything is still fundamentally written for humans and has to be moved around. I still use
most of the time when I use uh different frameworks or libraries or things like that, they still have docs that are fundamentally written for humans.
This is my favorite pet peeve. Like I don't uh why are people still telling me what to do? Like I don't want to do anything. What is the thing I shou
ld copy paste to my agent? [laughter] Like uh so it's just um every time I'm told, you know, go to this URL or something like that, it's just like ah
[laughter] you know. [snorts] So um everyone is I think excited about how do we decompose the workloads that need to happen into fundamentally sensors
over the world, actuators over the world. How do we make it agent native? Uh basically describe it to agents first. um and then have a lot of automat
ion around um you know the um yeah around data structures that are very legible to the LLMs. Uh so I think um yeah I'm hoping that there's a lot of ag
ent first um infrastructure out there and that you know for Menuguen famously when I wrote the uh not I'm not sure how famously but when I wrote the b
log post about Menuguen [laughter] um a lot of the work a lot of the trouble was not even writing the code for Menugen it was deploying it in versell
because I had to work with all these different services and I had to string them up and I had to go to their settings and the menus and you know confi
gure my DNS and it was just so annoying and so that's a good example of I would hope that menu gen that I could give a prompt to an LLM build menu gen
en and then I didn't have to touch anything and it's deployed in that same way on the internet. Uh I think that would be a good kind of a test for whe
ther or not uh a lot of our infrastructure is becoming more and more agent native. And then ultimately I would say yeah I I do think we're going towar
ds a world where um there's agent representation for people and for organizations and um you know I'll have my agent talk to your agent uh to figure o
ut some of the details of our meetings or or things like that. So, [laughter] um I do think that that's uh roughly where things are going, but um yeah
, I think everyone here is excited about that.
super interesting,
e world at making complex technical concepts simple and deeply thoughtful about how we design education around it. Um, what still remains worth learni
ng deeply when intelligence gets cheap as we move into the next a era of AI?
我觉得这说得非常好。因为我仍然是系统的一部分,信息仍然需要进入我的大脑,我觉得我正在成为一个瓶颈——甚至只是知道我们在试图构建什么、为什么值得做、我如何指导我的 agent 等等。所以我仍然认为最终需要有什么东西来引导思考和处理,而这仍然在某种程度上从根本上受到理解的约束。
这也是我非常兴奋于所有 LLM knowledge bases 的原因之一,因为我觉得那是我处理信息的一种方式。每当我看到信息的不同投影,我总觉得获得了洞察。所以对我来说这实际上是很多 prompt 来对固定数据做 synthetic data generation。我真的很享受——每当我读一篇文章,我的 wiki 就会从这些文章中被建立起来,我喜欢问关于事物的问题。我觉得最终这些都是以某种方式增强理解的工具,而这仍然是一个瓶颈,因为如果你不理解,你就不能成为一个好的导演。LLM 当然不擅长理解,你仍然独特地负责这一点。所以,嗯,是的,我觉得为此目的的工具非常有趣和令人兴奋。
king about it like every other day. It was something along the lines of um, you can outsource your thinking but you can't outsource your understanding
. And um,
I think that's really nicely put. I so yeah because I still I'm still part of the system and I still I still have to somehow information
still has to make it into my brain and I feel like I'm becoming a bottleneck of just even knowing what are we trying to build why is it worth doing uh
how do I direct you know how do I direct my my agents and so on so I do still think that ultimately something has to direct the thinking and the proc
essing and so on and um that's still kind of fundamentally constrained somehow by understanding and this is one reason I also was very excited about a
ll the LM knowledge bases because I feel like that's that's a way for me to process information and anytime I see a different projection onto informat
ion. I always like feel like I gain insight. So it's really just a lot of prompts for me to do synthetic data generation kind of over over some fixed
data. Uh so I I really enjoy uh whenever I read an article I have my uh you know my wiki that's being built up from these articles and I love asking q
uestions about things or um and I I think that ultimately these are tools to enhance understanding in a certain way and this is still kind of like a b
it of a bottleneck because then you can't direct the you can't be a good director if you still uh because the LM certainly don't excel at understandin
g you still are uniquely in charge of that. So, uh, yeah, I think, uh, tools to that effect, I think are incredibly interesting and exciting.
xcited to be back here in a couple years and to see if we've been fully automated out of the loop and they actually take care of understanding as well
. Uh, thank you so much for joining us, Andre. We really appreciate it. [applause]