Latent Space: The AI Engineer Podcast

We first covered Baseten last year when DeepSeek mania was at peak hype. Now they have raised a monster $13B round and become one of the new cohort of AI Infra decacorns that are (with Nvidia, Intel, and the semis complex) chief beneficiaries of the Inference Inflection.
We return to Baseten at the peak of the 2026 edition of Open Weights debate. Ali has published a viral breakdown of Kimi K3:
And since you last saw him, Philip has spoken at AI Engineer and written the definitive book on Inference Engineering spotted all over SF:
Three years ago, inference engineering barely existed as a category.
Today, it is one of the most critical disciplines in AI. Inference engineering inherently tackles a different question than standard model training: “How do you turn those weights from training into a product that is fast, reliable, and affordable at scale?” Focusing on these creates an entirely new optimization problem.
In one recent GLM-5.2 experiment, quantizing more of the model actually preserved its benchmark quality while increasing throughput by 20%, because the errors introduced in different layers could cancel each other out.
Inference is no longer just the final step after training. It is becoming its own engineering discipline, with its own research problems, infrastructure, and increasingly specialized roles.
In this episode, Baseten’s Philip Kiely and Ali Taha join swyx and Vibhu to explain what actually happens after a new open model is released and what it takes to turn “we generated a token” into a fast, reliable, production-ready API.
We go deep on cache-aware routing, disaggregated prefill and decode, quantization, speculative decoding, KV-cache movement, model parallelism, GPU kernels, and the race to make frontier models up to 10× faster. Philip and Ali explain why inference optimizations can still produce gains of 20%, 100%, or even 200%; how quantization errors can cancel one another out; why identical weights can behave differently across clusters; and how Baseten grafted a Kimi vision encoder onto GLM-5.2 without changing the underlying language model.
The conversation then expands beyond LLMs into NVIDIA Dynamo, mega kernels, Rubin, AI-specific chips, local inference, video generation, diffusion versus autoregressive models, and the enormous compute barrier to generating coherent long-form video. Finally, we explore the convergence of training and inference, continual learning through persistent KV cache, and the emerging loop where models help optimize the infrastructure that runs them.
We discuss:
* What happens when a 200,000-token request enters an inference system
* Cache-aware routing and reusing previously computed KV cache
* Why prefill and decode are increasingly handled by different GPUs
* When dedicated deployments become cheaper and more reliable than shared APIs
* How speculative decoding uses a smaller model to accelerate a larger one
* Tool calling, structured outputs, and what LLMs actually do
* What it takes to support a new open model on day zero
* Grafting Kimi’s vision encoder onto GLM-5.2
* Retrofitting inefficient model layers with components from other architectures
* Why models sometimes collapse into repeating the same token
* How hardware, kernels, and race conditions create nondeterministic failures
* Preserving model fidelity while making inference faster
* How quantization errors can cancel each other out
* Why inference optimizations still deliver gains of 20%, 100%, and 200%
* How optimized serving can make a model up to 10× faster
* NVIDIA Dynamo, KV-aware routing, and distributed model serving
* Speculative decoding the speculative decoder
* Why local AI is about making models less dumb while data-center AI is about making them less slow
* Tensor, expert, and pipeline parallelism across GPUs
* Hardware-aware model design, auto-tuning, and the case against mega kernels
* Rubin and why inference is becoming a systems problem
* Whether modern GPUs are evolving into programmable AI ASICs
* Why enormous models like Kimi K3 require GB300-class hardware
* Why open-source video generation still trails Veo, Kling, and other closed models
* The quadratic attention bottleneck behind long-form AI video
* Autoregressive video, real-time generation, and compounding quality drift
* Why future video systems may combine autoregressive and diffusion architectures
* Training for inference and inference for training
* Continuous post-training, deployment, evaluation, and improvement loops
* How GLM-5.2 helped optimize the kernels serving GLM-5.2 itself
* Why faster networking could unlock dramatically faster decoding
* Continual learning, KV-cache compaction, and persistent model memory
Show Notes
* How to build a day-0 API for Kimi K3
* 22580: From GPT2 to Kimi3, Explained
Philip Kiely
* LinkedIn: https://www.linkedin.com/in/philipkiely
* X: https://x.com/philipkiely
* Inference Engineering: https://www.baseten.co/inference-engineering/
Ali Taha
* LinkedIn: https://www.linkedin.com/in/aliestaha/
* X: https://x.com/waterloointern
Timestamps
00:00:00 Introduction and the 200K-Token Prompt
00:03:18 Dedicated Deployments, Speculative Decoding, and Tool Calling
00:11:26 Launching Production-Ready Open Models
00:19:06 Model Retrofits, Failure Modes, and Nondeterminism
00:28:22 Quantization and Canceling Errors
00:32:15 The Race to 10× Faster Inference
00:40:48 Dynamo, Speculation, and Local vs. Data-Center AI
00:50:18 Model Parallelism, Auto-Tuning, and Mega Kernels
01:00:55 Rubin, GPUs vs. ASICs, and Custom AI Chips
01:10:03 Giant Models and the Limits of GPU Memory
01:12:42 AI Video, Quadratic Attention, and Autoregressive Generation
01:21:47 Audio, Images, and Diffusion Models
01:27:32 Training, Self-Optimizing Models, and Continual Learning
01:40:06 Closing Thoughts
Transcript
Introduction: Baseten, Waterloo Intern, and Inference Engineering
Swyx [00:00:00]: Okay, we’re here in the studio with Philip, old friend from Inference Engineering, the book, as well as Baseten and everything that you’ve done, you and I have done before, as well as Ali. Welcome.
Ali [00:00:15]: Pleasure to meet you.
Swyx [00:00:15]: Waterloo intern.
Ali [00:00:16]: Waterloo intern, always.
Swyx [00:00:17]: When did you get “Waterloo intern” as a handle?
Ali [00:00:19]: As a handle? Oh.
Ali [00:00:20]: I think the rebranding happened mid-March. When I saw it was open, I was like, “I have to take it. Up for grabs.”
Philip [00:00:26]: The problem is that Ali is really good at his job and is not gonna be an intern much longer.
Philip [00:00:30]: So we have to figure out who’s gonna get the handle.
Ali [00:00:33]: Well, I’ll pass the torch over to the next intern.
Swyx [00:00:34]: Oh, okay. It can be, like, you just pass it to another Waterloo grad.
Ali [00:00:37]: To another Waterloo intern. No, bruh.
Philip [00:00:39]: Yeah.
Ali [00:00:39]: Intern.
Swyx [00:00:40]: Intern, yeah.
Ali [00:00:40]: And no.
Philip [00:00:41]: You gotta get an intern from Waterloo.
Ali [00:00:42]: Yeah, I’ve gotta get an intern from Waterloo.
Swyx [00:00:44]: Right.
Ali [00:00:44]: But they have to follow the path.
Swyx [00:00:45]: Oh, it could, but it could come from Baseten, so it’s like whoever Baseten gets from Waterloo.
Ali [00:00:48]: Right.
Swyx [00:00:49]: Has the title of Waterloo.
Ali [00:00:50]: It stays in the ecosystem.
Philip [00:00:51]: Exactly.
Ali [00:00:52]: Halfway through the internship, you either get it or you’re out.
Philip [00:00:55]: You should also do, like, a big graduation ceremony where you change the handle.
Ali [00:00:59]: Just say it.
Philip [00:00:59]: For everybody.
Swyx [00:01:00]: You guys are good at ceremonies, clearly. We had a nice launch of the book, very successful. But before we get into all that, I wanna start off with a fun question for you. Okay, you’re an expert inference engineer. What happens when I send a long query, say two hundred thousand tokens into Baseten’s inference? What’s the process of query through GPU model routing, balancing, all that? What is all the stuff that we don’t think about?
Long Context Requests, KV Cache, and Cache-Aware Routing
Philip [00:01:26]: With a long query specifically, the first thing that I’m gonna ask is, “Have you sent me this query before, or at least part of it?” and I really hope you have, because it’s gonna be a lot easier for me and a lot cheaper for you. So the first thing that we’re gonna look at is some cache-aware routing, where we’re going to see, we probably have a number of instances, a number of replicas up serving whatever model you’re hitting. We want to send this one to something with, number one, available prefill workers, and number two, ideally some cached input already there so that we can skip prefill on at least part of these two hundred thousand tokens. If you’re doing two hundred thousand tokens, it’s probably coding or a multi-turn agent or something where you would expect to have that cached. If you don’t, we’re gonna have to send it to a prefill worker. We’ve at least on certain models disaggregated prefill and decode, so you’re going to have one set of GPUs that’s solely going to process the input, create the KV cache, and get you your first token, and then that’s going to be passed over to a separate set of GPUs, which is going to run decode. We’re going to iteratively make those tokens. We’re probably going to have some speculator model in front of that. I’m going to assume that you’re doing coding, and because of that, our speculator model, which assumes you’re doing coding, is gonna have a high draft token acceptance rate. If I’m wrong and you’re asking me to summarize every Harry Potter book, it’s gonna be slower. And then we stream that output to you and account for it, charge you, a couple of pennies and say, “Hey, would you like to send another one?”
Swyx [00:03:04]: Except Baseten doesn’t charge by pennies.
Philip [00:03:07]: Well, yeah, we charge. I’m assuming that we’re talking about the public model APIs. If you are setting up a dedicated deployment, then yeah, it’s not pennies.
Public APIs vs. Dedicated Deployments
Swyx [00:03:18]: Yeah, one of the key differentiators when I was talking with Baseten initially was that people who want very high volume just need to rent by the box, ‘cause then it’s up to you to figure out how to saturate the box.
Ali [00:03:31]: And more often than not, it’s, like, way cheaper if you’re pushing, like, millions of tokens per hour, if you just pay per hour instead of pay per token.
Philip [00:03:37]: Yeah, they do. I think that we’ve increasingly seen a lot of demand for the pay per token APIs, just because everyone wants to try open models, and then once they find a use case that’s really sticky, then they move over to dedicated.
Swyx [00:03:51]: Is there a best practice on when it’s time to swap over?
Philip [00:03:54]: Couple reasons. Yeah, reliability, that’s a big one, right?
Ali [00:03:57]: Like, if they have a very specific use case, they want you to train something specifically for them, like they want their own spec dec, for instance, for their own traffic.
Swyx [00:04:04]: Spec dec is speculative decoding.
Speculative Decoding and Custom Speculators
Ali [00:04:05]: Speculative decoding, yeah.
Swyx [00:04:07]: You have to explain.
Ali [00:04:07]: Sorry. Like, speculative decoding is like, if you have a huge model, right? And so the model is going to be generating one token at a time every single turn, every single forward pass. So we attach, like, this little, like, parasite, like this layer that goes on top of the model, and this model just has to predict. It does three very fast autoregressive forward passes, and it will predict, like, three certain tokens, and then you do one forward stage over the entire original model in order to see if those predictions were correct or not, and then you accept them or you reject them. Now, this draft model is traffic specific, so if you, like, Philip said, if you’re summarizing Harry Potter books, I can train exclusively that draft model on Harry Potter books, and I can guarantee you that I’m gonna accept the three tokens every single time. And so with that case, I increase your decode speed. I wouldn’t be able to provide this to you if you’re a shared endpoint
Swyx [00:04:53]: Yeah
Ali [00:04:53]: ‘cause I have no idea if you’re doing Harry Potter, if you’re doing coding, if you’re doing English. We don’t know. Also, there was a thing in the book that mentioned that if they really cared about a specific threshold, chapter four, I think. Do you remember that?
Philip [00:05:06]: Yeah. The things that you can do is you can set a specific, like, batch sizing, a specific, like, parallelism strategy if you’re trying to optimize for, like, throughput versus latency. You can. Maybe a NVFP4 quant doesn’t pass your benchmarks and you wanna run a model at higher precision, you could do that. There’s just a bunch of reasons why you might wanna have your own endpoint and the biggest one, of course, just being, like, you don’t have to deal with someone else doing a hundred million tokens of benchmarking traffic at the endpoint when you happen to be trying to serve your users.
Swyx [00:05:40]: Yeah. I think one thing that is. That is a classic journey. Like, it’s people is asking the, what happens when you type Google into the browser. Tool calling, is that just, you’re generating JSON or is there more complication beyond that?
Tool Calling, JSON, and Structured Outputs
Ali [00:05:58]: Certain customers that we have, they have their own post-trained models, and so they demand a tool calling that’s not just, like parse a file or go find the weather. It’s something that’s very specific and you have to do post-training on this. And if the post-training on the model is not good or if the quantization after the post-training to get the inference to be fast, the model will struggle reading the JSON file and reading the tool calling. But it doesn’t require its own like sandbox. It’s not like it’s going to use that tool calling to like escape a sandbox or like it doesn’t have to be contained. It can just be a normal dedicated deployment. The challenge with tool calling more and more seems to be that the companies want certain tool calling which is a very sensitive thing to train. And because you’re dealing with all of the JSON outputs, if it doesn’t like close the end of the request in a very certain manner, you end up with a model that did the tool calling and like the thinking and so as a result of that, it didn’t see the result and just hallucinated the result as it decoded. That seems to be the most challenging thing with tool calling, not really the sandboxes model.
Philip [00:06:56]: Yeah, that’s a challenge on the training side and then on the inference side, there’s work that you can do to scope the possible output. So we published this at this point close to two years ago, the solution to this problem which is you make a state machine and you use that to constrain the output to a specific format. So this is the structured output problem. If you remember back
Swyx [00:07:27]: Yeah, the specific grammar is,
Philip [00:07:29]: Yeah, exactly
Swyx [00:07:30]: GML had this thing.
Philip [00:07:31]: Yeah. So it’s like the old-school “make sure this is only JSON”, return only JSON or
Swyx [00:07:38]: Yeah
Philip [00:07:38]: Grandma’s gonna die type of prompts.
Swyx [00:07:39]: Is it BNF grammar? At some point OpenAI had released a thing that was like, yeah, if you want to constrain your output, write BNF grammar, back as NOR.
Philip [00:07:47]: In our inference system, it’s just a specified output format. And you get the guarantee that your output’s gonna be structured along that format. And so applying that to tool calls can like help cut down on. You can still call the wrong tool or call no tool. It doesn’t solve the certainty problem but it at least solves the output structuring problem
Swyx [00:08:10]: Yeah
Philip [00:08:10]: Within tool calls.
Swyx [00:08:12]: And MCP is just another form of tool, right.
Philip [00:08:14]: Yeah, exactly.
Swyx [00:08:15]: As far as there’s no special thing there.
Philip [00:08:16]: The thing I’m always like explaining to people is the LLM is not capable of doing anything. It’s only capable of making suggestions of what to do and then if those suggestions are formatted in a certain way and applied to a system that knows what to do with them, then an action occurs.
Swyx [00:08:32]: Yeah. Part of the fun stuff is, this is solved outside of tool calling too. Like in an agent loop if the output is not correct or you’re right, like reasoning, tool calling was done in the reasoning trace, just be like, “Oh, I don’t know what to do. Let me just try again.” And it might get there after a few tries. And on your point of training, sometimes this is harder in smaller models, so you don’t have the same exact quality output
Ali [00:08:56]: Right.
Swyx [00:08:57]: When you just swap from a big model, right?
Ali [00:08:59]: Yeah. I will say that, before, I think we need to go back to inference engineering proper.
Ali [00:09:04]: But, I had expected that something would replace JSON because it’s hard to stream JSON ‘cause JSON must be complete and you must have open and close brackets and everything. So it’s hard to parse something or validate something while it’s being streamed. So people invented all sorts of things that are like, I forget the name of some of these alternatives, but it’s something like TOML, something like YAML. But JSON seems to be dominant still.
Philip [00:09:30]: The JSON outputs aren’t that long, right? Like you could have a long-- ‘cause tool calls also contain the arguments in them and perhaps for a certain tool you might pass like a very long argument. But my impression of the median tool call is that it’s a relatively small number of tokens, right? So I would expect that speculators are generally fairly good at something as formatted as JSON. And so you would have like a pretty fast decode step there and that the streaming wouldn’t be as valuable, but maybe I’m wrong about that.
Ali [00:10:02]: I think you’re also bounded by the software or that the model is gonna integrate with if the software is built with JSON for the tool calls or if the company that you’- if your customer says that this is how our software works and our tools are interfaced with JSON, you can ask them to like, change their software and say like, “Yeah, this is gonna be better for the model.” but like with the right training shouldn’t be that much of a difference. Also more profitable if it outputs more tokens probably.
Swyx [00:10:25]: Depends on your business model.
Swyx [00:10:27]: It really depends. But I will say that, as a writer with like experience a lot with generated output, I do try to move from text to JSON text which is very long JSON, right? Like there’s paragraphs in every field because I’m trying to structure it, right?
Philip [00:10:44]: Right.
Swyx [00:10:44]: I want you to first make factual statements, then make opinions then make bullet point summaries, have dates, have entity references have your sources for references, all these things. Anyway, so these are things that like I think people who really experiment with structural output have to really care about. But, let’s, let’s recurse up the stack a little bit. Before we started recording, you mentioned something really cool, which is that there’s a lot of engineering that-- inference engineering that goes on when a new model provider releases a new model, right? So let’s call it GLM-5.2, Kimi K3. I had previously assumed, especially if it’s like, well, GLM 5 to 5.1 to GLM-5.2, like that you’ve supported them before. Is it that much work?
What It Takes to Support a New Open Model
Ali [00:11:26]: It’s a lot of work.
Swyx [00:11:28]: Yeah. Okay. So like, a lot of people, all you guys, right whenever a new model launch like, people rush to say like, “Oh, Hugging Face supports this, Fireworks supports this, Spacetime supports this,” and I’m like, “Yeah, of course we support it.” But what goes into that? What goes into
Philip [00:11:40]: I think it’s more than just support it too, right? It benefits the consumer a lot. Like I think it was with Kimi K2.5 or GLM-5.2 the latest, there was an inference war, right? X provider is at 90 tokens a second. The next day we’re at 150. The next
Swyx [00:11:55]: I kinda kicked that off with the GLM-5.2.
Swyx [00:11:58]: I wrote a Twitter article about. It got like half a million views,
Ali [00:12:02]: Based on being number
Swyx [00:12:03]: Yeah
Ali [00:12:04]: Or it’s for something else.
Swyx [00:12:05]: Yeah. Which,
Ali [00:12:06]: Oh my God
Swyx [00:12:07]: Which then got everyone really excited about, hey, how can we, bend tracks a little bit further and,
Philip [00:12:14]: There’s a difference between support the model, as in I can make a token out of this model, and support a model, as in I have a production-ready API from this model.
Philip [00:12:26]: Getting to the point of I can make a token out of this model is not that hard because generally the, open source inference engines, vLLM, SGLang of the world oftentimes even receive weights ahead of time, maintainers do, or the people making the model merge PRs to ensure support. So you generally can, just get it working on the standard open source stack without too much pain in most cases. The challenge is, every inference company is gonna have own proprietary stack. Some open source components, some in-house stuff. And for any arbitrary model, there’s going to be some new stuff. Sometimes you get lucky, like K, two five to two six was, like, pretty similar.
Quantization, Speculators, and Production Readiness
Ali [00:13:16]: Yeah. It was pure continued post-training
Philip [00:13:18]: Yeah
Ali [00:13:18]: If I remember correctly.
Philip [00:13:19]: Even in those cases, there’s still stuff you have to do. You have to redo the quantization work. You’re taking the model from. Generally, these models are not released in NVFP4, and we want them to be in NVFP4 for maximum Blackwell compatibility. So we have to perform that quantization, and, calibrate the quantization to make sure that we’re not causing any regression in the model’s intelligence. And then we also have to train the speculator, as we’ve talked about. Generally, we have. We have ZDR, zero data retention on our model APIs, so we don’t know exactly the traffic that people are sending us, but we know what’s popular. We know that coding use cases are popular. We know that agents, agentic use cases are popular. So we can get public data sets that are representative of that traffic and train general speculators. Now, with speculators today, you need to train the speculator using the base model itself because you’re getting hidden states out of the model from running inference on these specific prompts, and that is the training data you use to create the speculator. So there’s that process which you need the real model weights for. And then there’s of course just the process of, standing up all the infrastructure behind it, loading all this stuff, testing it. And then when there’s a new model with a newer architecture, I think that, like, the DeepSeek models tend to be the most challenging as they have, like, the most novel architectural stuff going on, model after model. But every new model has something. Kimi K2 had. Oh, sorry, GLM-5.2 had
Ali [00:14:53]: Sparse attention.
Philip [00:14:54]: Yeah,
Ali [00:14:54]: Yeah
Philip [00:14:54]: the DSA.
Ali [00:14:55]: Right. Which is brought from DeepSeek.
Philip [00:14:57]: Yeah. And
Ali [00:14:59]: So you can copy-paste then?
Philip [00:15:01]: It kind
Ali [00:15:01]: I don’t know how this works.
Philip [00:15:02]: So, like we had to, like, build support for that into our runtime. And you’re right, like it is really interesting the way that all of these open source labs borrow from each other. For example, like GLM-5.2 doesn’t have vision. So something that, Haley, a guy on our team, if we could take a look at this, he, like, grafted the Kimi vision encoder onto GLM-5.2.
Retrofitting Vision into GLM-5.2
Ali [00:15:27]: We’ll be training the projector.
Philip [00:15:28]: Exactly. So if you think about, like, the encoder, there’s the encoder, which is the part that looks at the image and turns it into latent information, and then there’s the projector which like
Ali [00:15:38]: You can say latent space. It’s okay.
Philip [00:15:41]: And then there’s the projector that maps it onto, the model itself, and then there’s the model weights. You don’t wanna mess with the model weights because you run a chance of making the model dumber at something else for the purpose of giving it vision. So instead, Haley started with just a projector, which is only a handful of millions of parameters.
Ali [00:16:02]: That would be, yeah.
Philip [00:16:02]: Yeah.
Ali [00:16:03]: Can you show the training one?
Ali [00:16:04]: Like the way it groks
Philip [00:16:05]: Yeah
Ali [00:16:06]: Very interesting.
Philip [00:16:06]: And maybe
Ali [00:16:07]: That right there
Philip [00:16:07]: Maybe Ali, you should take it from here. You’ve got a better
Ali [00:16:10]: Ooh, double the sand
Philip [00:16:11]: Understanding of this than I do.
Ali [00:16:11]: Yeah. You can see, like, he. The way he trained this is really cool. At the beginning, he was training it using just like, “Here’s a picture of a mountain. Can you describe what’s in this mountain?” And that caused it just like the first, learning walls. Like here you can see this all we’re trying to teach it is to translate the encoded. Like it’s already taken the encoder from Kimi K. It’s taken the image. It’
Philip [00:16:31]: Yeah. Frozen
Ali [00:16:31]: Frozen
Philip [00:16:32]: With adapter.
Ali [00:16:32]: Exactly.
Philip [00:16:33]: Yeah.
Ali [00:16:33]: So the brain is frozen and the eyes are frozen. It’s just we’re trying
Philip [00:16:37]: Align
Ali [00:16:38]: Interconnect between the eye and the brain, right? So the projector. And so you take the tokens and then he’s like, “Oh, can you describe what’s in this image?” And he’s like, “Oh, it’s a mountain,” or it’s a person or it’s a human, whatever the case is. But that didn’t cause complete understanding. So he changed it such that every image was associated with a data set of questions. Like, does this image have a white male? Does this image have birds in the top corner? Does this image have a scientist in it? All of that stuff. And it would have to answer questions correctly. And using not just training on describing an image, but being able to answer question, another question, answer over time. Like you can see the grokking, which is like genuinely insane, that retrofitting vision into a large LLM can learn to that extent. And even for images that it doesn’t perform well on, for instance, if you ask it a picture of like Stephen Hawking, “Who is this?” Maybe it doesn’t get it, but it will say something like, “This is Albert Einstein.” Like it still understands
Philip [00:17:25]: Close enough
Ali [00:17:26]: That this is a scientist who is a man who has, some significant achievements, all that stuff. So that’s like really cool.
Philip [00:17:32]: Yeah. So, we’ve covered Hao Tian before, who the author of the LLaVA paper that did this, a while ago. And I think that’s very foundational work for anyone who hasn’t done vision work before.
Ali [00:17:41]: Same with the CLIP and MetaCLIP, where you go from just captioning to building out questions
Philip [00:17:47]: Right
Ali [00:17:47]: Off the image and how much better you can get performance.
Philip [00:17:50]: Right. Right. Right. Yeah. But what’s, what’s so exciting about this is if you look at a model like this. Now, this is a little bit more of a research project. It’s not. It got to 56% on MMLU Pro, I think. So not quite frontier. But if you’re running this model, you haven’t suffered any loss on your GLM-5.2 quality. If you don’t have an image, it’ll just behave exactly the way it used to. And ultimately
Ali [00:18:14]: Which in the inference code you literally do not include the other part, right?
Philip [00:18:18]: Yeah. You would just skip the encoder if you don’t have an image input.
Ali [00:18:22]: Okay.
Philip [00:18:22]: Just confirming.
Philip [00:18:23]: Yeah
Ali [00:18:23]: Does it affect a lot on the overall inference side? Like you’re not adding much, you’re adding a very small vision encoder. These are typically like
Philip [00:18:30]: They’re super fine
Ali [00:18:31]: Less than a billion parameters, right?
Philip [00:18:32]: Yeah. It’s, - There’s a little bit less standardization among vision encoders
Swyx [00:18:37]: Yeah
Philip [00:18:37]: So the support matrix can be a little bit, sparser. But overall, yeah, it’s a pretty, it’s a pretty minor component of the overall system. And ultimately what you get out of the system is all of a sudden you have Kimi Vision, GLM weights, and DeepSeek attention all in one model.
Open Source Model Grafting and Franken-Merges
Philip [00:18:56]: And that’s, I think, a lot of the power and beauty of open source, is that you can take all of these different components and combine them together into a system that’s better than anyone
Swyx [00:19:05]: Yeah
Philip [00:19:05]: Can be individually.
Swyx [00:19:06]: People used to say that you would also do Franken-merges where you would take like
Philip [00:19:10]: Yeah
Swyx [00:19:10]: Layers from each model.
Swyx [00:19:11]: Does anyone do that anymore?
Ali [00:19:13]: Well, to your point previously when you were mentioning like, the work that goes into supporting a model when it first comes out, like GLM-5.2 or MiniMax M3 or whatever the case is. Sometimes you do have to like, you do have to switch out some things. Like, for instance, the MiniMax M3 head uses full attention, and with full attention you end up with this like insane bottleneck in spec dec ‘cause you’re doing auto-regressive token generation for three tokens, and you’re doing this like N squared over all of the tokens that are in your sequence. Your KV cache is like very large because it’s not sparse, it’s not top K. So we find it better to like, okay, we’re gonna replace this, we’re gonna replace this layer with a layer from another model that’s using like GQA, for instance. And then just with the right training, you can get it to have the same acceptance rate. So it is very possible to retrofit layers from other models and very much needed. If a layer is like inefficient, the training just becomes the challenge, like how do you ensure that you train it properly? Which again to your earlier point is like the mesh between training and inference. As in like you need very good training in order to do fast inference. That’s like, I feel like more and more becoming true.
Swyx [00:20:21]: Yeah. Anything else on the support side when you say like get it to fully production ready?
Loop Detection, Race Conditions, and Non-Determinism
Philip [00:20:26]: Yeah. I think that there’s also a question of just, we can test a model to a pretty extensive degree, but we’re trying to get it out quickly and then you see a bunch of other people test it and you get interesting results. There was an issue with, GLM briefly where we had some like mode collapses where it would just output the same token over and over again for certain prompts on certain temperatures. Like once you expose an endpoint to the real world, there’s going to be, so many more varieties of things given to it that you’re able to, discover and patch things. So it’s not just a, day zero process, it’s then like for the first week, for the first month, if a model remains popular, like how do you both fix bugs and then continue to push the envelope on performance?
Ali [00:21:21]: What do you mean you don’t want your model outputting S?
Swyx [00:21:24]: Is there loop detection on that stuff, by the way? It still happens like quite a lot, which is surprising.
Ali [00:21:30]: We have like we, in our endpoint, like if a model was to output the same token like four plus times, we just cut the generation. We say like, “Oh, sorry, this-- Like try again,” or like we will reprocess the request. ‘Cause we know then, like if it, like if, yeah, it’s four times the same token, it’s probably collapsed.
Swyx [00:21:45]: Yeah. Is there a way to opt out in case I really want that?
Ali [00:21:48]: You want that?
Ali [00:21:50]: I think there’s a way that we have to handle it. I’m not exactly certain, but I feel like in certain models, like when they output something like you can imagine, like a table for instance, and so they want, they wanna draw like 12 dashes and 12 dashes. Yeah, I think there’s a way for that to happen. I think we only do it on certain tokens. Like we exclude certain special characters.
Swyx [00:22:07]: Yeah.
Ali [00:22:07]: So we only do it on like certain like S is the most common almost. GLM-5.2
Swyx [00:22:11]: Oh
Ali [00:22:11]: And I think it was DSV 4 as well. Like you’d just have like looping issues where like you literally
Swyx [00:22:17]: It
Ali [00:22:17]: Just have like S.
Swyx [00:22:18]: Yeah. Is there a special, something special about S? No, just randomly
Ali [00:22:21]: It just seems to be the one token involved.
Swyx [00:22:23]: Yeah. And it’
Philip [00:22:24]: Is there
Swyx [00:22:24]: And it’s only temperature 0
Ali [00:22:27]: No
Swyx [00:22:27]: Even at other temperatures
Ali [00:22:27]: Even at like 0.9 or whatever, it will still, it will still collapse.
Swyx [00:22:30]: That’s weird, right?
Ali [00:22:30]: It’s, it is an inference problem to be honest, like a software problem. Like oftentimes, the image you run will-- like NVIDIA will release an image for instance, and if we will upstream the changes from their latest TensorRT-LLM image into our stack, we’ll find that it fixes it. Or oftentimes this will only happen in an inference engine that you’re using like SGLang. But if you were to switch to vLLM, that isn’t the case. So it seems to be like an extremely like deterministic software issue and not really a model issue. It’s not like a weights problem. Like I’- we’ll say like, “Oh, it’s a problem with the quant. We did PTQ wrong,” right? But that isn’t, that doesn’t make sense because the same weights used with a different inference engine does not repeat the problem. And sometimes it’s, the kernels that are being used in the backend have like these very subtle sometimes race conditions, where if you were to use this model hosted on one cluster, you will never get this problem.
Swyx [00:23:19]: Oh my God.
Ali [00:23:19]: But if you host it on a different cluster, you will. And the reason is the KV cache transfer from a node to node in that one cluster is using a slower interconnect than the node to node in another cluster. So that exposes the race, whereas in another cluster it doesn’t. So then you end up just like, okay, this model is not gonna be hosted on this cluster. We’re gonna host it on, another cluster because that cluster exposed that problem. But then it ends up with like, okay, is it the software? Is it the model weights or is it the hardware?
Swyx [00:23:42]: There is a thing about this with temperature 0 still not being deterministic, right?
Ali [00:23:46]: Right.
Swyx [00:23:46]: Mostly because of hardware. Even at temperature 0 same model, you won’t always get the same output.
Swyx [00:23:52]: Even-- But I’m surprised by the race condition one because, I thought PyTorch was a graph that like guarantees that you at least, execute things in the right order.
Ali [00:24:02]: Well, yeah, true. Like I’m not, I’m not saying that there is. Like well, you have things like PTL optimizations where like you can start a kernel before the end of the previous kernel, and that’s like ‘cause you want to do that because there’s
Swyx [00:24:12]: It’s like pipelining
Ali [00:24:12]: Expense. Exactly.
Swyx [00:24:13]: Yeah.
Ali [00:24:13]: But it’- But you don’t do it cleanly. Like you overlap a little bit of the execution. No, it is very possible that the kernel itself, like that one block that is supposed to be running in this instance of time, that kernel itself has a race condition. For instance, like a missing barrier. Like often if you’re designing a kernel and you want it to make it to be very fast, if you don’t test it extensively, you’ll, you’ll have certain threads access data points from registers before they’ve been written to by other threads
Swyx [00:24:36]: Yeah
Ali [00:24:36]: For example, because like your barrier is wrong or your synchronization was wrong. But yeah, like the testing itself is very difficult in those like, and
Swyx [00:24:42]: And there’s no like borrow checker
Ali [00:24:45]: What does that mean?
Swyx [00:24:46]: Like Rust. Like the. If you’re trying to have like memory safety It sounds like a comparable problem.
Ali [00:24:52]: Well, yes, but you’re working in CUDA, right, NVIDIA GPUs. Like- You just need a higher level language like modular Maybe that’s what modular is supposed to do. I don’t know.
Quantization Quality and Vendor Fidelity
Vibhu [00:25:00]: How do you see keeping quality of the model? So you talked about all these steps of, okay, you gotta do quantization, train your own speculative decoder
Ali [00:25:07]: Right
Vibhu [00:25:07]: Run on different hardware. Looking at other model providers, okay, you kicked off a inference speed race on the consumer end. What goes into keeping quality the same across them, right? Sure, you can run benchmarks
Ali [00:25:22]: Yeah
Vibhu [00:25:22]: But, like, how do you determine how much quantization are there standards? What goes into
Philip [00:25:27]: There’s a few things on quality. Most inference optimizations are lossless. KV caching, for example. You are just recomputing or preventing recomputing the same values. Speculation, of course, if a draft token is wrong, it gets rejected. The main lossy optimization is quantization. And that really comes down to, number one, data format, number two, which parts of the model you choose to quantize, which layers, and number three, like doing a lot of calibration on the quantized weights, to ensure that you’re preserving all the outliers. There’s other tricks that you can do, though. A big one is long context, ‘cause one thing you asked at, right at the beginning is, “Oh, what’s gonna happen if I send a 200,000 token request in?” So with a long input sequence, you need to, store a lot more information. You need to process a lot more tokens. And so even if a model has a context of a certain length, you might, as an inference provider, choose to build an API with a shorter context length, and of course a full length one as well. Because if someone doesn’t need the full million token context, for example, you can get them better performance. I don’t know if that’s exactly like quality of the model. The way that I think about quality is to what degree are we faithfully serving the original model? If you think of a golden implementation of a model that performs exactly the way the model is designed to perform, I think of quality as how close are we getting to that, 100% fidelity of the model.
Philip [00:27:13]: You can also, of course, think about quality from the training side and how do you push yourself past 100%. But when I think about purely inference optimizations, it’s getting faster while staying as close to that 100% fidelity mark as possible. And certainly our standard internally is that, like you should not be able to tell the difference between our API and a, official API. I think Kimi in particular does a good job of vendor benchmarking here
Ali [00:27:41]: Yes
Philip [00:27:41]: Where they have
Ali [00:27:42]: They released an actual vendor benchmark.
Philip [00:27:43]: Exactly, yeah.
Ali [00:27:44]: ‘Cause they accused, some people, Amazon? There was some provider that was not doing very well on Kimi’s benchmark.
Philip [00:27:50]: Yeah.
Philip [00:27:51]: So, with Reflect we probably
Vibhu [00:27:52]: This was a long time ago, right?
Philip [00:27:54]: No.
Ali [00:27:54]: Yeah, like three
Vibhu [00:27:55]: They also
Ali [00:27:55]: Four, five months ago
Vibhu [00:27:57]: This also happened with, I don’t remember which model, but they pulled out quite a few, and then they started a whole chart about this. It might have been
Philip [00:28:03]: Kimi Vendor Verifier.
Ali [00:28:04]: Yeah.
Philip [00:28:05]: Yeah.
Ali [00:28:05]: Yeah, ‘cause you, ‘cause you’d be pissed, right? Like if you’
Philip [00:28:07]: Yeah.
Ali [00:28:07]: If like if I’m a consumer and I’m using like Amazon’s endpoint for instance, and I’ve used Kimi and I’m like, “Oh my God, like this is bad,” I’m not gonna say, “Oh, Amazon quantized the model in a bad way.” I’m gonna say, “Oh, Kimi sucks.” Right?
Philip [00:28:17]: Yeah.
Ali [00:28:17]: So it seems like that makes sense.
Philip [00:28:19]: Yeah, they care. They care.
Vibhu [00:28:21]: Justifiably.
Ali [00:28:21]: Yeah, justifiably.
Vibhu [00:28:22]: This is probably a stupid question, but just checking, has anything improved from main quantization?
Philip [00:28:28]: Yeah.
Vibhu [00:28:28]: Like, is quantization always strictly worse?
Ali [00:28:30]: Well technically
Vibhu [00:28:32]: No
Ali [00:28:32]: It’s a lossy. Quantization
Philip [00:28:33]: Yeah
Ali [00:28:33]: Is a lossy, it’s a lossy implementation.
Philip [00:28:36]: Speed improves
Vibhu [00:28:36]: Speed improves.
Ali [00:28:37]: It the number, like
Vibhu [00:28:38]: No, I’ always look for inverse scaling laws.
Philip [00:28:40]: Yeah.
Ali [00:28:40]: Yeah.
Vibhu [00:28:40]: This is something I learned from Noam Brown, where like things that normally act in one direction sometimes do.
Philip [00:28:45]: Well, technically when you run a benchmark, because these models are deterministic, sometimes your,
Ali [00:28:52]: Yeah
Philip [00:28:52]: NVFP4 quant is like, two basis points higher than your
Ali [00:28:56]: No, it’s noise. It’s noise.
Philip [00:28:57]: Yeah, exactly. I’m like, yeah, it’s, it’s within. That’s why I always say within margin of error.
Philip [00:29:01]: And I stopped saying that because everyone assumes that what is, well, within some margin of error, we’re barely inside of that to the worst, so we’re saying. But yeah, sometimes it’s just like, gives you a higher output score. But like Ali said, that’s noise. To my knowledge, you’re not necessarily making the results better. You’re just trying to, again, like keep your fidelity as close to 100% to the original model.
Layer Selection, KL Divergence, and Better Quantization
Ali [00:29:27]: There is, to your point, research that we did on MP. I don’t know if you are able to pull
Philip [00:29:31]: Yeah
Ali [00:29:32]: A tweet we did. One of our research interns, Joshua, I think it’s a tweet on how we have 20% better quantized GLM-5.2 than NVIDIA. Essentially what we found throughout like this month research is, okay, quantization is a lossy. It’s. You’re compressing the data from, occupying 16 bits to occupying, four bits, for instance. And so you’re losing some information, and you’re trying to minimize that. And so when I say that I’m gonna quantize the model, my job becomes how do I find the layers that I can quantize, and how to find the layers to not. For instance, with image models, I don’t quantize modulation layers, and I don’t quantize out projections because those two are. Like out projection is what you see as the user. Modulation is what the model sees or understands. Right, exactly. And so to his paper, do you have the. It doesn’t have the. Yeah. It’s a long paper. I don’t know if I can find
Vibhu [00:30:25]: If there’s a part to search or it’s probably in the thread.
Ali [00:30:28]: It’s probably in the thread.
Vibhu [00:30:29]: Yeah.
Ali [00:30:29]: But the long and the short is it is very possible that quantizing more of the model makes the results. Like if I have a model that I quantize layers one, five, and 10, and another model where I only quantize layers one and It is possible that the model in which I quantized more information is going to perform better because the quantization errors have canceled out. And so what Joshua showed in his mathematical proof where he had like a verifier in, is that you can predict which layers are going to have quantization errors that will cancel out with each other, and you choose to quantize those layers. And so the result of doing this mathematical quantization is you end up with a model that’s 20% more quantized than another provider, so you get 20% more throughput of it because there’s more layers than running an NVFP4, and your quality is better than that other quant because the layers that you chose to quantize have their errors cancel out, like one layer skewed to the right one layer skewed to the left, one layer skewed to the right. Your final logits distribution is more similar to the original distribution of the model, so you have better fidelity. And so the way we proved this was with KL divergence. So instead of just scoring on the benchmarks, we scored the KL divergence between the logit distribution of the quantized model and the logit distribution of the original full precision model, and we showed that with this technique we get. If your probability distribution on the logits which token it wants to select is more of the same as the original model, you’re probably gonna end up staying true to the original model. So yeah, so it seems like previously before this, it seemed like the industry was, well, the more you quantize, the worse it’s gonna be, ‘cause the more loss you introduce. That’s not exactly, not necessarily true. So yeah, doesn’t improve it, but can cancel out.
Philip [00:31:57]: I think it might be this, but reminds me a good bit about pruning where you can prune off certain layers.
Philip [00:32:03]: But very interesting. Didn’t know this was a whole paper you guys put out.
Ali [00:32:06]: It’s. Fun fact, it was originally 72 pages, this paper, and then we decided
Philip [00:32:11]: Wow
Ali [00:32:11]: We can’t tell. We couldn’t release it. So it’s now 45.
Swyx [00:32:15]: Still 39 pages, so very substantive. We talked about evals and all these things and, like what’s possible in terms of speedup? Like it’s like probably like the number
Inference Speedups and Benchmarking
Swyx [00:32:25]: Thing that people do wanna care about, and it’s something that you wrote about in your post. Like official API is 70 tokens per second, and you push it up to 90. Is that like a normal thing?
Philip [00:32:36]: So what’s cool about working in inference, the reason that I think inference is going to be a useful place to do engineering for a long time, is that if you look at highly optimized domains like, say, finance, if you’re in finance, you measure how much better you got in basis points. It’s like, “Oh, I got five basis points better, like twentieth of 1% better,” that’s huge news because everything is so optimized. When we publish optimizations, it’s 20%, it’s 100% it’s 200%. So there’s still probably like a lot further to go, honestly. Like you’ll, you’ll know that inference is pretty much solved when researchers start publishing about how they got 1% faster at something.
Swyx [00:33:19]: Which by the way, because I am from the finance background, in the ‘70s, that was the margin at the time. When you did quantitative finance research, you would find
Ali [00:33:27]: And like 20%, tens of percent.
Swyx [00:33:29]: That’s. Yes.
Philip [00:33:29]: Yeah.
Swyx [00:33:30]: And now it’
Philip [00:33:31]: Tiny fractions
Swyx [00:33:32]: For those people interested, look up Andrew Lo’s paper. He had a really interesting illustration of quant, stat arb, distribution, narrowing down from like those kinds of 20% differences in the ‘70s, down to nothing today, which is very cool.
Philip [00:33:48]: Exactly, and we’re at the beginning of the same type of thing. Now benchmarking is hard. I think anyone will tell you that, and benchmarking provider speeds is hard because there’s so many variables that go into it. What hardware are you using? How much load do you have on the system? What’s the exact nature of the prompts and input and output sequence lengths? All that stuff. But overall, when you start stacking these improvements, you’re looking at multiples. You can look at it. The most common form, of course, is TPS, tokens per second, which is bad naming by us in the industry, ‘cause there’s two tokens per second. There’s tokens per second, the throughput number, and the latency number.
Ali [00:34:31]: TTMT, yeah.
Philip [00:34:32]: Like total tokens per second out of the, out of the GPU as a throughput number. Most people only care about tokens per second as the latency number, which we should call ITL, intertoken latency, but we don’t.
Philip [00:34:44]: Anyway, so you can imagine a standard API without many optimizations for a 1 trillion parameter model operating somewhere in the 30 to 50 tokens per second range for reasonable traffic profile. And we generally see the goal of, pushing to 10X that. But, not necessarily day zero, but by stacking enough optimizations, if you have, say like four optimizations, each of which doubles performance. Or sorry, three optimizations, each of which doubles performance, then you stack that up, that’s an 8X gain. That’s the order of magnitude that we’re working with in this space. We’re trying to make things substantially faster, not just go from like 70 to 90.
Swyx [00:35:38]: Are you saying you’ve. You have done that?
Philip [00:35:40]: So let’s say you have as a reasonable baseline, 30 or 40 tokens per second. You can achieve 10X that. So like on GLM-5.2, if you run it unquantized, perhaps on H100s even, and you’re just using an off-the-shelf inference engine with no particular optimizations, no speculator, nothing extra around like KV routing, no disaggregation, you’re, you’re probably, yeah, looking at that like 30 to 40. You think that’s like a reasonable baseline?
Swyx [00:36:12]: Right. Right.
Philip [00:36:12]: To get to something like 10X, there’s a lot of trade-offs that you’re making. If we’re running at more like a 300, 400 tokens per second range, you are using the best hardware possible. You have a optimized speculator. You have done all of your quantization work. You are Seeing a pretty high cache hit rate. You are running with a reasonably small batch size and a parallelism configuration that is tuned for latency versus throughput, but it is possible. So the spreads that you see if you, like, go on artificial analysis or you go on OpenRouter and you look at, the worst provider to the best provider, oftentimes can hit that range. 10X is of course very aggressive. It’s oftentimes maybe more of a four to six times improvement. But that’s the performance that makes us really excited, is when we can get these huge gains, not just go from 70 to 90 tokens.
Stacking Optimizations: NVFP4, Speculation, and Disaggregation
Ali [00:37:19]: It’s also, like, hardware dependent. Like, if
Philip [00:37:20]: Yeah
Ali [00:37:20]: If you have a thing where you’re serving it on just, like, a node of H100s and then you throw, like, you shard the model across, like, four nodes of B200s. Like, you can definitely increase the speed with just throwing more hardware at it. Like, normalizing for the same exact hardware and the same number of GPUs.
Philip [00:37:35]: Yeah. Then you’re looking at, like, a two to 4X improvement
Ali [00:37:38]: Right. Right
Philip [00:37:38]: Depending on the inference optimizations. So yeah, it’s. Some of it’s, what’s the call, and some of it’s who’s the driver.
Vibhu [00:37:46]: If you break down the two to 4X, say the example is run GLM-5.2
Ali [00:37:51]: Yeah
Vibhu [00:37:51]: On B200s
Ali [00:37:53]: Yeah
Vibhu [00:37:53]: Single node, right? What’s, like, the cost trade-off for effort to get, like, the last bit of juice out versus what should people just think of, right?
Ali [00:38:01]: Spectre quantization. Yeah.
Vibhu [00:38:03]: Spectre quantization.
Ali [00:38:04]: That’s, that’s, that’s like 95%. Like
Vibhu [00:38:06]: And how far does that get you? And how easy is that for the average person to do? So say right I wanna throw the weights of GLM-5.2 on a node of B200s, how easy is it to find speculative decoder- decoder model or already quantized model? How much work goes into it?
Philip [00:38:23]: If you’re doing it up front, it’s quite a lot of work. If you’re doing it today, there’s going to be people who have published things that you can just, you can just grab some NVFP4 weights. You can grab a speculator. Yeah, if we’re thinking about, like, what are the 2Xs we’re stacking, going from, BF16 to NVFP4 is, it’s not quite a 2X, right? It’s like. I think it’s about, like, 30 to 40%, from 16 to 8, and then another 30 to 40% multiplied from, 8 to 4. So that doesn’t quite get you a 2X, but, like, roughly a 2X. Speculator, roughly a 2X. Disagg on top of that if you’re able to get enough hardware and put enough traffic through it, another roughly a 2X. And then you add in some, double-digit percent increase from having just a better runtime with, the latest kernels and stuff behind it. And that’s how it stacks up.
Ali [00:39:21]: Yeah
Philip [00:39:21]: So building each of those, like, building the, quantized weights is, for someone who really knows what they’re doing, hours to days of work. Building the speculator, again, like, hours to days of work. And the, disagg setup, hours to days. Well okay, but like once you have
Ali [00:39:39]: Once set up. Once set up. Yeah
Philip [00:39:40]: Yeah, getting disagg working for the first time, I’m saying, of course, is very difficult.
Philip [00:39:44]: The marginal implementation
Ali [00:39:48]: Like, if you’re just grabbing, like if you are a person, like just a normal consumer who has access to, like, a node of B200s and you’re wondering, “How can I just host it myself?” You don’t need to quantize the model yourself. There’s always gonna be, like, an open source quantized checkpoint. NVIDIA’s gonna push one out if no one else does. You. Usually, the providers will have their own spec dec that they’ve trained as well. You don’t need to train your own spec dec. You can just use that as well.
Philip [00:40:09]: Yeah. Like, GLM-5.2 has its own MTP.
Ali [00:40:13]: Right. Right.
Vibhu [00:40:14]: What’s multi token prediction?
Philip [00:40:15]: Yes.
Ali [00:40:16]: I’m just
Vibhu [00:40:16]: Can you explain that?
Ali [00:40:16]: I’m just an expert.
Ali [00:40:18]: I can do it for you in case I get it wrong?
Vibhu [00:40:20]: No.
Vibhu [00:40:21]: Yeah, you should correct if we’re wrong, but their multi-token prediction can be used for self-speculative decoding.
Ali [00:40:27]: I’m not sure. I’m not gonna correct that.
Vibhu [00:40:28]: Okay. I’m semi-confident in that
Ali [00:40:30]: Okay. Yeah
Vibhu [00:40:30]: But someone can check. But it’s useful to paint the story of, okay, not just the average person, but say a company wants to switch from serverless inference I wanna throw this up on. I wanna rent some GPUs, throw it up. These are the steps you take to do significantly faster than just put it behind vLLM.
Ali [00:40:48]: Right.
Vibhu [00:40:49]: I was waiting for a mention of Dynamo.
Vibhu [00:40:51]: I feel like, that’s supposed to be the baseline that you measure against.
Dynamo, KV Routing, and Disaggregation Toolkits
Philip [00:40:55]: I would think of Dynamo as less of a box system and more of a toolkit for building with. So when we talk about doing aware routing, when we talk about doing KV offloading, when we talk about doing, PD disaggregation, Dynamo fundamentally is. By the way, Dynamo is an open source library from NVIDIA.
Ali [00:41:17]: We’ve done a pod with Kyle
Philip [00:41:18]: Okay
Ali [00:41:19]: Kyle Cranin.
Philip [00:41:19]: Cool. So then your listeners know then that it supports all the different inference frameworks. And it is multi hardware, which is interesting.
Ali [00:41:28]: But it’s just a router, it’s not like an optimizer layer.
Philip [00:41:30]: Yeah. All it does, like, what Dynamo is good at, it is a library for moving information around your cluster, around your hardware. So if you have, KV cache on one place and you need it to be somewhere else, Dynamo coordinates NIXL for you to move that around.
Philip [00:41:49]: That doesn’t mean that, like, out of the box, you just say, “Pip install Dynamo,” and then you get, like, a massive performance speed up. It’s more of a developer toolkit.
Ali [00:42:01]: Yeah. I would have said it would. It comes with a set of defaults that you can then swap out.
Philip [00:42:06]: It does. If the industry at large, I think, was, like, rolling out all of these deployments, standard, then I think it would be, like, a credible baseline. But, we’ve got to, we’ve got to benchmark against, like, what we’re seeing in the wild.
Speculative Decoding Methods: Medusa, EAGLE, n-Gram, and Spec-Spec
Vibhu [00:42:23]: I did wanna talk a little bit more about PD disagg, because that is probably, like, number three after quantized and speculative decoding. In your book though, I was just gonna pull out the book.
Philip [00:42:31]: Yeah.
Vibhu [00:42:32]: Like section 522 on Medusa, 523 on EAGLE
Philip [00:42:35]: Yeah
Vibhu [00:42:36]: 524 on gram.
Philip [00:42:37]: It’s 55, would be disaggregation
Ali [00:42:42]: Yeah. Well, no, I just wanted to dwell a little bit
Philip [00:42:44]: Yeah
Ali [00:42:44]: The other. Like, so what do you choose to include? What do you choose to not to include? Because there was all these other techniques.
Philip [00:42:51]: Yeah.
Ali [00:42:51]: Are these still relevant? Because I think they came out, like, a year and a half ago maybe.
Vibhu [00:42:55]: Medusa is quite old.
Philip [00:42:56]: Yeah, Medusa’s old.
Ali [00:42:58]: It was old.
Vibhu [00:42:58]: But is it in the book as a good, here’s
Philip [00:43:01]: Baseline
Vibhu [00:43:01]: Baseline vanilla understand it?
Philip [00:43:02]: Like you should know this.
Vibhu [00:43:03]: Like I read the paper, I’m like, “ it makes so much sense.”
Philip [00:43:05]: Yeah.
Philip [00:43:05]: So with the book, I had a couple goals. One was to give people just a working vocabulary for the space as a whole, and the other was to give them some intuition about how each of these techniques works. As I mentioned in my AI Engineer talk, which is the first public addendum to this, the speculation space has moved much faster than everything else. So yeah, even at the time that I wrote the book Medusa, I very much included as a way for people to understand how the space evolved rather than what the most modern technique is. And now of course, there’s DFlash, dSpark. There’s, there’s newer techniques even than EAGLE, although EAGLE is still very commonly used.
Ali [00:43:51]: SpecSpecta.
Philip [00:43:52]: Yes. Speculative decoding.
Vibhu [00:43:54]: What can
Ali [00:43:56]: Oh, it’s a paper by Tri Dao and it’s like, it’s doing speculative decoding
Vibhu [00:44:00]: Huh
Ali [00:44:01]: For the speculative decoder.
Philip [00:44:02]: Oh, in spec- oh my God.
Ali [00:44:02]: It’s literally just an another. It’s like, yeah, that’s the most simple way to explain it, and it seems like he got trivial speed ups there. But it seems that the complexity with training, it’s almost like in our mind at least, it’s almost as complex as training GANs. Like it’s like a very delicate balance and oftentimes you, it’s just but yeah, it’s literally speculative decoding on speculative decoding.
Vibhu [00:44:21]: Speculative.
Ali [00:44:22]: Yeah. We saw this paper.
Vibhu [00:44:24]: It’s interesting, right?
Ali [00:44:24]: Yeah.
Vibhu [00:44:24]: I wouldn’t even expect it to be very particular to train, I would
Ali [00:44:29]: Right.
Vibhu [00:44:29]: The naive part of me is like, okay, train speculative decoder.
Ali [00:44:32]: But like, and it makes sense, like the whole idea of speculative decoding is you. It’s like, it’s like almost like the iPhone auto predict version but for a normal model, right? Like you’re just, you’re just, generating three tokens and you’re like, okay, I’ll do prefill on them. And so you save those three turns for your original model. Now your speculative decoder is doing three turns of auto regression, so why not just have an even smaller model?
Ali [00:44:53]: The other question there is what are the size of speculators? So say for
Philip [00:44:58]: Right. It’s like a billion parameters.
Ali [00:45:01]: Like for MiniMax, it’s. Yeah. It’s like one layer. It’s like one 60th of the original model usually.
Philip [00:45:06]: Yeah. I think we should do a paper when we get back to the office.
Philip [00:45:10]: Speculative
Ali [00:45:11]: Speculative
Philip [00:45:11]: Decoding.
Ali [00:45:13]: No, it’s, it does seem like how, when do you stop? But then it also seems like if you’re able to train spec-spec decode for instance, right? Like if you’re able to have a small model that is accurately predicts what the intermediate speculator is gonna predict, that is able to predict what the original target model’s gonna predict, then why not just use that smallest model directly, right?
Vibhu [00:45:34]: Yeah. This is
Ali [00:45:35]: Like it seems like
Vibhu [00:45:35]: Adjacent to the routing problem.
Ali [00:45:36]: Right.
Vibhu [00:45:36]: Yeah.
Ali [00:45:36]: Right.
Philip [00:45:37]: The thing with speculators is one of the practical constraints on using them is that you do have to run a small model on the same hardware that you’re running the big model on. There is a orchestration and resource competition problem inherent in that, and that is one of the constraints on speculation in general, is that draft tokens cost resources to create and cost software complexity to manage. And so if you have like infinitely recursive speculators, you add in quite a bit of that complexity on the actual implementation within the inference engine as well, not just in the training process.
Vibhu [00:46:17]: I was gonna say, I would wonder if you could do similar, like distillation and pruning of, it’s the same thing, it’s just a model. Can we not just distill a lot of the weights, quantize the speculator, out of my domain? The question that also comes up is, this is all for big server workloads, right? How much of this applies to, say I have this MacBook, I wanna run Gemma really efficiently. Similar problems, not the same?
Local AI vs. Data Center Inference
Philip [00:46:45]: Pretty different. I talked to Selo, about this on his podcast a couple weeks ago. The difference between inference engineering for the data center and for production workloads versus inference engineering for local AI, is that we start with fundamentally like different constraints and different goals. With local AI, it’s how do I fit this model onto my hardware and then make it less dumb? And with data center influence, it’s how do I load this model and then make it less slow? And we care about less dumb, and they care about less slow. But the local AI inference engineering ecosystem, I think has a lot for us to learn from in the data center space. They are experts in various forms of quantization, including dynamic quantization that we just don’t touch, in the pruning, in the distillation, in the, layer removal. There’
Ali [00:47:42]: Layer removal matters less.
Philip [00:47:43]: Yeah. There’
Ali [00:47:44]: No one loves pruning really.
Philip [00:47:45]: Yeah. Well, but the, but they do
Vibhu [00:47:46]: Which is surprising, right? But that’s, that’s a whole different thing
Philip [00:47:48]: Just to fit something on the laptop.
Ali [00:47:50]: Right.
Philip [00:47:50]: So yeah, it’s a, it’s an interesting, it’s an interesting space. Not necessarily that like their techniques make sense for us to do in the data center, because we have different resources and different goals, but more that the process as well as the openness of that field is something to, admire.
Ali [00:48:12]: Yeah. Like to your point, like, certain optimizations that would. Like for instance, Turbo Quantum Sharper, like it made such huge hype on that and we did like a whole deep dive on Twitter and like said, what is it? How does it work? Why is it good or not? And it took off and it was implemented on local devices because your memory bandwidth is so slow on like a MacBook, for instance. But try putting the same thing on like an NVIDIA GPU on a B200 Turbo quant would not be. Like, it would not be used. Like, NVIDIA - Like, NVIDIA made it clear that this is not a good optimization, and we’ve seen it firsthand where the overhead of doing dequantization, quantization of, in the kernel itself with turbo quant kernel, each end is much slower than the time that you save from doing the bandwidth. ‘Cause on the B200s, you have like 3.5 terabytes per second. You don’t need decrease the storage that much. You don’t need to do, FP4 KV cache. You don’t need to use a requant. There’s, there’s, there’s better optimizations to be made. But on Edge devices, it’s extremely important, it’s extremely useful. So, seems to be, like, different optimizations there, but then they’re all uniquely combined with like all you wanna quantize the model, you wanna do speculative decoding, like certain common prefixes with both
Philip [00:49:18]: Principles.
Ali [00:49:19]: Yeah, exactly. Exactly. Exactly.
Philip [00:49:20]: They also do a lot of work on, model parallelism, especially over, heterogeneous topology, where you have, some sparks and they are wired together with, Ethernet, DGX sparks.
Ali [00:49:35]: Yeah, this is the Exo Labs guys.
Philip [00:49:36]: Yeah. You have, a number of, Mac Minis stacked up.
Philip [00:49:41]: There’s, the inter. They. One thing that I think we both have to deal with, although they have to deal with a lot more is the interconnect between machines. Which is why, like, one thing that we do a lot is work with tensor parallelism.
Philip [00:49:56]: And that’s where, you are using all of the, all eight GPUs, and sharding the model across it. Tensor parallelism is not a good fit for local AI because it assumes a very high bandwidth interconnects like NVLink. Was, they might be forced to do something like pipeline parallelism, which we’re never gonna do unless we’re doing some kind
Ali [00:50:16]: Yeah. For image
Philip [00:50:17]: Multi-node inference.
Ali [00:50:18]: But since you mentioned it, I wasn’t sure if we were gonna cover it, but let’s briefly explain tensor parallelism and expert parallelism, since you have very nice images.
Tensor, Expert, and Pipeline Parallelism
Philip [00:50:25]: You wanna pull the book?
Ali [00:50:26]: Yeah.
Philip [00:50:26]: Yeah. Let’s, let’s get
Ali [00:50:27]: So I just wanna show a few images.
Philip [00:50:29]: Yeah. Shout out to Luke from Baseten’s design team for making these beautiful images. Oh, that’s a, that’s. Before we get into this, just one other difference is we talk a lot about the active parameters of a mixture of experts model, and for local inference folks, that matters a lot because if you have a batch size of one, you’re only activating that many parameters. When we
Ali [00:50:51]: Yes. I was gonna
Philip [00:50:52]: Inference in the data center
Ali [00:50:52]: I was gonna bring that in the diffusion conversation.
Philip [00:50:54]: Yeah.
Philip [00:50:55]: Yeah. We, I, when we go through like a MoE model, and we host it, for an API, we assume that all parameters are gonna be active because
Ali [00:51:06]: You’re batching
Philip [00:51:06]: Throughout your batch
Ali [00:51:07]: Yeah
Philip [00:51:07]: You’re gonna, you’re gonna hit everything. Cool. So broadly, tensor parallelism you can do with any model. Expert parallelism, you can only do with MoE models. Effectively all models today are MoE models, that are,
Ali [00:51:21]: Sort
Philip [00:51:22]: At least all models large enough that you would care to parallelize them across multiple GPUs. So that’s, that nuance is less important now. With expert parallelism, the idea is you put the entire expert on a GPU. Generally, you have more experts than GPUs, so you might put like N experts per GPU, like eight experts per GPU or whatever. And then you replicate the router, which the router is very small, across each of the GPUs. And then by moving the generation from expert to expert, with each expert being inside a GPU, they’re not competing for resources. You massively increase the throughput that you’re capable of doing, and the, GPU connection is not as important ‘cause there’s not as much communication. Tensor parallelism requires that you are able to do this like all gather, all reduce. So you shard the model across the GPUs entirely. And then for each step, you’re combining the results of each of the GPUs, which is why the interconnect matters a lot, and it is generally. Of course, this is a, this is a very high-level generalization. There’s a lot of places where this is not correct. But generally, TP is helpful for latency, and in many cases, you will use some combination of these two parallelisms, across the model rather than just, like, picking one or the other. Do you wanna add some color there?
Ali [00:52:50]: Like, yeah, usually, like in a model, it’s not. They’re not mutually exclusive. You do tensor parallelism and you’ll do expert parallelism. Pipeline parallelism less solely, it seems to me like we never use pipeline parallelism.
Philip [00:52:58]: Yeah. The only reason you would have to do pipeline parallelism, which is where you separate like different layers and you put like half the layers on one hardware and half on another, is if you are forced to do multi-node inference, because a model is bigger than you have the. Like let’s say, let’s say you’re doing a deployment on H100s for whatever reason, and you’re putting a trillion-parameter model on there. You have to use multiple nodes of H100, and so you. - Because the interconnect is so slow between the nodes, the only viable way to parallelize there is pipeline, but then you would do expert and tensor within each node.
Ali [00:53:36]: And the limiting factor for H100s is HBM?
Philip [00:53:39]: Yeah. They just don’t have enough
Ali [00:53:40]: How much? What’s the magic numbers that we need
Philip [00:53:43]: Like on a B200 is 180 gigabytes per GPU, and then a node of eight, so you’re talking like 180 times eight. And the FP4, so each parameter takes half a byte, so that’s 800 gigabytes. On a H100, it’s like 140?
Ali [00:53:56]: It’s 80.
Philip [00:53:57]: It’s 80?
Ali [00:53:57]: Yeah.
Philip [00:53:57]: Oof.
Ali [00:53:58]: Yeah.
Philip [00:53:58]: I’m old. I’ve been doing this a long time. I remember H100 specs.
Ali [00:54:04]: Yeah.
Philip [00:54:04]: No, so one thing
Ali [00:54:06]: You wanna tell me about the T4s?
Philip [00:54:07]: The T4s. Oh my God.
Ali [00:54:08]: Let me tell you what it was like to run a model on a T4 back in the day.
Ali [00:54:12]: One thing I was surprised to see that more people didn’t do, Jamba. I don’t know if you guys remember Jamba from AI ‘21. They would specifically pick a hardware, and then they designed the arc dimensions for the hardware, and then it would saturate the hardware. Like, it makes sense. And like, somehow all these models don’t do that.
Hardware-Aware Inference and Auto-Tuning
Philip [00:54:32]: Don’t they do this for the training side, though?
Ali [00:54:35]: I don’t know.
Ali [00:54:36]: Sorry,
Philip [00:54:36]: Training. For training the model.
Ali [00:54:37]: Like deciding which GPU, which
Philip [00:54:39]: Yeah. Well, how
Ali [00:54:40]: Yeah, they do And with training, it’s more of like a math. Like you can run the math- Yeah and see the flops and maximize it. With inference, it’s more of like an auto-tuning, like if you like GPU kernel auto-tuning. But like it’s like you define that, “Oh, I have two GPUs. I can do TP1, TP2, EP1, EP2,” for instance, right? And you. So that gives you like total of like two squared combinations, and then you just like you shadow the same traffic, like real prod traffic, and you just see which configuration gives you the best TPM and TPS, and then just use that. I don’t like the fact that it’s, you cannot reason about which one’s gonna give you the best performance or that there isn’t one specific configuration that’s always best. But it seems like auto-tuning is just the way that you find the best one. And with kernels and GPU kernels, it’s much of the same. After you design your kernel and you design your configuration, how many threads do you launch? How many, how much shared memory do you use? You just auto-tune. You just sweep the parameter space on the side, and this is the best one empirically. But yeah, but they are combined. They’re not just entirely- Yeah like separation. There’s a few bits of training that are like hardware targeted. If you look at, for example, NVIDIA Nemotron models, they run very well on Blackwell. That’s, that’s unsurprising. So there’s some degree of that, but I think that most open labs are trying to make models that can be run on as wide of hardware as possible rather than targeting just like a single chip. I see. For usefulness. Yeah. Okay, one more thing while this chart is still up. All gather, all reduce is expensive. One of the things that is a movement in Silicon Valley is mega kernels, just keep fusing kernels. I don’t know. Is it that simple? Well, I, like a fused kernel can’t save you. Like here with tensor parallelism, you’re. The half the matrix is on one GPU and the other half is on another, and if I need the entire matrix in order to do like a nonlinear operation in the next step, which is, for instance, like if I’m doing attention, I need the softmax, or I need to do like exponentiation, I need to have the entire row. So I need to know what the partial result was from GPU 2 and what the partial result was from GPU 1 in order to be able to do the softmax in the next stage. So I, like I have to make them communicate with each other, even if I had a fused kernel, because of the nonlinearities within each one. Also with like mega kernels, like honestly, I’m, I’m, I’m very bearish Ooh on, I’ll be honest. Like- Please. No, it’s just like mega kernels, it was a good research direction, and it seems like a very. Like intuitively, theoretically, it’s nice. Like, oh, like you have a lot of launch overhead from launching- Just- one kernel- Yeah, just keep fusing it moving the data. Just fuse everything together. But yeah, but like the kernel complexity itself is very difficult to write a very optimized mega kernel. It’s, it’s very difficult to do so. And even the, like not to name any companies, but like even the companies that have worked or people that I’ve spoken to who work at companies that do fused mega kernels, they very often don’t end up running those in production because the TensorRT-LLM and modular kernels that launch are faster because you can optimize each individual component, and you can just have them parallelize with each other. With the Rubins, I don’t know if you guys saw the Rubins Twitter post yesterday, but they’re also, Rubins? Like- No, like Rubin, like the GPU. NVIDIA GPU the, yeah, GPU. Yeah. They have a Twitter account for Rubins only? No. Okay. I was like, “What are you talking about?” Yeah. Sorry. One of the tech leads at NVIDIA is like launched a Twitter post said like, “We’re pulling the curtain on Rubin, and here’s the, here’s the specs.” And the third tweet showed, like not to get too technical into it, I and I need to read it much more, but the GPU is designed in such a way that it kills mega kernels. You don’t need to use mega kernels that much anymore. So it seems like that entire research field goes into like, won’t be continued, but yeah. Can I speculate about Rubin for a minute, please? Go. I’ve been through now, we And by the way, they are covered in the book. Yeah. But yeah, they- Well, they’re covered in the book in the sense that like I am aware- The Wikipedia entry from the blog post- Yeah that Rubin is going to happen in the future. And you even had the name of the one, Feynman. Yeah, it’s like, “Hey, this is gonna “ I was like, “This is very up to date.” Like I’m trying to future-proof this thing, okay? I don’t wanna publish a new one until like next year or something. Anyway, so we were discussing the degree to which I am old. And I’ve now been through three hardware launch cycles. I’ve been through the Ampere launch cycle, the Hopper launch cycle, and the, Blackwell launch cycle. Now, when I say launch cycle, I don’t necessarily mean like the actual shipping of the hardware. Like Ampere’s were racked up well before I got in this industry. But there is a lot of time between hardware being racked up and hardware being feasible for inference. So if you look at like the original vLLM and SGLang, vLLM especially, like that was written targeting Ampere and then had to be updated for Hopper, updated for Blackwell. With each of these cycles, it becomes faster and more urgent, but also substantially more complicated. When I look ahead to, what’s going to be new with Rubin, I think that like Dynamo gives me a lot of technical hints around like what kinds of work is going to be very valuable. We’re continuing some trends from Blackwell, right? NVFP4 is big. The amount of compute that they have behind NVFP4 tensor cores is massive. We’ll, we’re gonna talk about video, I think, at some point, and that’s the big barrier there. You’ve got, much faster memory bandwidth, but which was the same thing that made Blackwell so good. But the big thing is more systems thinking. You have more emphasis on the CPU to GPU interconnect, more emphasis on the interconnect between GPUs, and when you look at Dynamo, it’s a system entirely designed around how do I move the KV cache to where it needs to be when it needs to get there? So I think that themes around like KV cache offloading, KV-aware routing, and disaggregation are going to be substantially more important in the Rubin era, which means that inference engineering becomes not just a like CUDA kernel problem, but also like a very traditional hardware infrastructure problem, which is something, we’ve been building toward for a long time, and something that’s like very exciting to me because we’re gonna see
Mega Kernels, Rubin, and the Future of GPU Systems
Philip [01:00:55]: Multiple domains colliding and the ability to reason from the kernel level, like up to the hardware level and back down is going to be very valuable.
Ali [01:01:05]: I will take what Phil said one step further, into that. It’s, I think, trending towards becoming exclusively an infrastructure problem, where like problems of PD disagg, Training, spec dec. But troiting kernels is not going to be much of a problem because the GPU is moving more towards being an ASIC, where it’- you’re just, you’re just trying to orchestrate what happens on the GPU, but you’re not controlling it thread by thread level. And you see this with like QTAL, QDSL, like you’re, you’re just working at levels of like tiles of data, but you’re no longer working at controlling what each thread does on the GPU that’s being taken care of for you. So do you agree that a GPU and future GPUs are trending more and more towards becoming ASICs that just need to be launched and then they do the data operation based on your conversations with other people?
GPUs, ASICs, and Specialized Hardware
Swyx [01:01:50]: Oh, yeah, no. That is a section of the market.
Ali [01:01:55]: Right.
Swyx [01:01:55]: And ASICs can do, a lot more performance for only their workload.
Ali [01:02:01]: Right.
Swyx [01:02:01]: And the G in GPU makes them continue to be very general.
Philip [01:02:05]: Yeah. The, - I think that there’s like a spectrum
Swyx [01:02:08]: It’s graphics,
Philip [01:02:09]: Yeah.
Swyx [01:02:09]: I keep saying this, I have to correct myself in case people come at me for getting the G wrong.
Philip [01:02:14]: Yeah. It’s like, it’s like a spectrum, right? Of a very general purpose compute to something like a Taalas, where you’ve got the hardware built for a specific set of model weights.
Ali [01:02:26]: The weights burned
Swyx [01:02:27]: The weights
Ali [01:02:27]: Into the chip.
Swyx [01:02:28]: Yeah.
Ali [01:02:28]: No loading.
Philip [01:02:29]: I don’- I wouldn’t say that like, that we’re, we’re, we’re going all the way there. It’s more like along the spectrum, it’s a step in the direction of more specialization within the hardware.
Swyx [01:02:40]: Yeah. I’m curious, I feel like he was driving towards something.
Ali [01:02:43]: My point is being bearish on. Like, you say, like everything else apart from burning the weights into the chip. Burning weights into the chip is like impractical because you wanna fine-tune, you wanna optimize, you wanna quantize, you wanna release new checkpoints of the model. If it’s burned into the chip’s useless in like a month or two, right? My point is: How can you - like seeing NVIDIA more and more specialized, like take its GPUs from a general programming paradigm where you’re just-- it’s a general computer that you can use to program threads, and with every new generation, you’re putting more and more specialized instructions, specialized tensor cores, specialized, MMA instructions, things that will allow you to just control it almost as an ASIC, almost as a collection of ASICs.
Ali [01:03:22]: How can you look at this trend and then still be bullish on companies that are coming up with ASICs for AI?
Ali [01:03:30]: In the sense that, in the sense
Swyx [01:03:31]: Yeah, because they’re, they’re
Ali [01:03:33]: Right.
Swyx [01:03:33]: They’re, they’re evolving towards that direction.
Ali [01:03:34]: They’re almost evolving towards - Like as an Rubin, comp- Like compared to Ampere or, a T4, Rubin is an ASIC. It is, it’s just a thing that is used
Swyx [01:03:47]: Programmable ASIC?
Ali [01:03:48]: Yeah. It’s like - Yeah, like you can program, like I, like. It’s very controversial to call it an ASIC. It is a GPU. It is - It is general. It does have threads. I can write CUDA to control it and change its operations. But it has the systolic arrays and tensor cores and TMAs and tensor memory, and it has these things that are almost exclusively useful for loading model weights. It has, tensor core instructions that are almost exclusively shaped around the head dimensions of models that exist in the market today. To say that you’re gonna come up with an ASIC and you’re gonna etch something into it, well, but the next architecture is gonna be useless.
Philip [01:04:19]: Yeah, I don’t know. I don’t know. I think that the thing to remember is just how long these hardware cycles are.
Ali [01:04:25]: Yeah.
Philip [01:04:25]: So if a chip is coming out today, that means the design process for it was kicked off years ago. And they’- at NVIDIA, they’ve done a very good job of predicting where the market is going to go and,
Swyx [01:04:38]: They have the most information
Ali [01:04:40]: For sure.
Philip [01:04:41]: Of course. But if you look at, there being public open source model architectures that look more or less like early versions of the one today, Rubin’s honestly the first chip that was fully built in that world. And so you can see a lot of the understanding of the shape of the workload that this chip’s going to be asked to do in the way it’s designed.
Swyx [01:05:04]: Yeah. Okay. So I’m not gonna be the best person to directly answer those questions. I think these are very fair questions that - the first one that’s based on Rubin that like I’ve, heard artic-articulated so well. I do think that, I will make a case for a vertically integrated model lab ASICs.
Swyx [01:05:24]: So like the OpenAI, Broadcom, what-whatever, Jalapeño
Philip [01:05:27]: Sure. Yeah
Swyx [01:05:28]: Chip, which like totally makes sense. Like, so - we first had this on the pod with, Martin Casado, where he was like, “Look, if you have a trillion-dollar or five hundred billion dollar training then take fifty billion of that and make a ASIC. Like it’s fine. Like you will get more than ten percent efficiency from the ASIC.” And like that makes sense.
Philip [01:05:46]: Right.
Swyx [01:05:46]: Right? So like a model-specific chip, yes. But ASIC companies, the interesting thing is I feel like you are focus-- you’re hyper-focusing on like you say, like the Taalas stuff.
Philip [01:05:58]: Right.
Swyx [01:05:58]: They are doing a lot more like, surface area engineering or like the actual allocations of memory and hardware and like the communication between chips that, probably still won’t be touched by Rubin, but I don’t know the details.
Philip [01:06:14]: I see. I see.
Swyx [01:06:15]: They-- Typically, they often talk about things that I would expect to have bigger orders of magnitude than would be programmably accomplished by whatever Rubin does. But who know-- who knows?
Ali [01:06:26]: No, I see.
Ali [01:06:28]: Yeah. It seems,
Swyx [01:06:29]: Yeah, like think about what - what are the real blockers to ten x to one thousand x faster inference. It is not the stuff that can be rearranged, just within the existing GPU design.
Ali [01:06:41]: Inter communication.
Swyx [01:06:42]: Yeah.
Ali [01:06:43]: Okay.
Swyx [01:06:43]: Like these guys are aiming for three hundred thousand tokens per second. They’re not f*****g around. Like,
Ali [01:06:49]: Might have to put on some X6.
Philip [01:06:50]: Maybe. I think, it is interesting to me that you’re so bearish on so much of this kernel engineering work, given how much of it you’ve been doing recently.
Ali [01:06:59]: Right. Right. But like the more I do it, the more it just seems to me that
Swyx [01:07:01]: It’s not mega
Philip [01:07:02]: I would also add like
Vibhu [01:07:04]: There’s generations of models being out, right? I think on your guys’ end, you see a lot of, okay, one day it’s GLM, Kimi, DeepSeek, MiniMax, throw in the others. Some are doing completely different stuff, right? Gemma, no encoder. The latest thinking machines is all from scratch. But when you look at the other side, like how long have we been on the GPT-5 generation, right?
Philip [01:07:26]: Right.
Vibhu [01:07:26]: They’ve been serving that thing for quite a while. Sure, there’s maybe more training. There’s, there’s different checkpoints, but like you can squeeze quite a bit out and you do a multi-billion dollar train run. If you can make it X percent more efficient, they serve it for a while. Same with, say, the Claude 5 set, family, right?
Philip [01:07:44]: Like if they release a new model, like if they release GPT-6 now or whatever
Model Longevity, Open Source, and Enterprise Reliability
Vibhu [01:07:47]: Yeah
Philip [01:07:47]: And they release a new model every year, and - well, we don’t know, but if we assume that they’re changing some bits of the architecture and not just doing like post-training, like you’re gonna be spending fifty billion dollars a year every single year coming out with new ASICs for the model and throwing out the ASICs of the previous year away.
Vibhu [01:08:03]: Yeah. Yeah. Easy.
Swyx [01:08:05]: So I think, okay, I would slightly disagree based on my again,
Philip [01:08:09]: Yeah
Swyx [01:08:09]: It’s all secondhand, on the longevity of a model.
Philip [01:08:12]: Right.
Swyx [01:08:12]: There’s still people out there using 4o.
Vibhu [01:08:14]: Yeah.
Swyx [01:08:14]: Yeah, Llama. Not Llama 2, but Llama 3. I still see Llama 3 workloads.
Vibhu [01:08:18]: Yeah.
Swyx [01:08:18]: Because if it’s done, if it’s trusted, don’t change it.
Vibhu [01:08:22]: If it works.
Philip [01:08:24]: Which is one of the promises of open source, right? Like the whole 4o, save 4o movement. Like you don’t gotta have a save Llama 3 movement. You just gotta have an eight one hundred somewhere.
Vibhu [01:08:34]: I think at some point there’s also the question of, okay, if a model can do enough and use enough tool calls and be agentic enough, can it just web search, tool search write code? Do you really need to keep squeezing more? We will because you guys will make it cheap and fast and smaller, and I can swap it in. But at some level, like you give me GLM-5.2 today or say whatever 120 B model, I can run with it for quite a while, right?
Philip [01:08:59]: This is assuming like you don’t need intelligence.
Vibhu [01:09:02]: I think there’s a lot of intelligence where we
Swyx [01:09:03]: You need reliability and predictability. Like I’m in enterprise like like this is tried and tested. It is signed off by like my five thousand stakeholders.
Philip [01:09:11]: Right.
Swyx [01:09:11]: Like I’m not touching it.
Philip [01:09:12]: It runs a batch job every and I like the results.
Swyx [01:09:16]: Yeah.
Philip [01:09:16]: The results are predictable. Yeah.
Vibhu [01:09:18]: Yeah. It doesn’t make sense to keep using them. Like stuff gets sparser, cheaper, better.
Philip [01:09:23]: Right.
Vibhu [01:09:23]: But that doesn’t mean that old models, GLM 50 isn’t usable, right?
Vibhu [01:09:28]: If we hit a stall, say, for whatever reason, there’s still a lot that can be squeezed out.
Swyx [01:09:34]: We’re gonna run out of time. I did wanna also make sure. Yeah. Yes, we happen to have this diagram. Pull. Compare this versus any Cerebras diagram, right? I don’t think Edge10, medics have put out public, charts yet. But the complete the real estate is very different. The size is very different, right? This is not wafer scale, right? This there’s probably like, I don’t know, a few hundred of these on a wafer. I don’t, I don’t know how big
Philip [01:09:55]: Right.
Swyx [01:09:55]: The comparison is. But like, it is a, it is a very like real estate allocation
Vibhu [01:10:00]: Yeah
Swyx [01:10:00]: Difference.
Philip [01:10:01]: Few dozen, I would say.
Swyx [01:10:03]: Few dozen. Yeah.
Vibhu [01:10:03]: Before we move from hardware, I have two quick questions. One, the latest Kimi, which is really big, three trillion
Kimi Scale, GB300, and KV Cache Limits
Philip [01:10:09]: Yeah
Vibhu [01:10:09]: Doesn’t fit on most hardware on single node.
Philip [01:10:12]: Yes.
Swyx [01:10:12]: You need GB300 to fit it on a single node.
Vibhu [01:10:14]: You need GB300 or AMD.
Philip [01:10:20]: It’s simple math. NVFP4, two point eight trillion parameters, one point four terabytes. The GB300s have, two hundred and eighty-eight gigabytes each. So across eight of those, you have enough room for the model, and honestly like. So the other thing with GPU VRAM math is you have to leave space for the KV cache, and that’s going to depend on, to some degree, on the context length. So when a model is both has a very large number of parameters and a very long context length, you’re like fighting over space. Which is why, the KV cache offloading, would become like a more salient topic, I think, with these huge models. ‘cause you just, you’re very crunched for space.
Vibhu [01:11:10]: With the Rubin, you now have what? NVL 72 rack
Philip [01:11:15]: What?
Vibhu [01:11:15]: 20 terabytes of your
Philip [01:11:16]: Yeah. Now you still have NVL 72 on, Blackwell as well, but, you can’t necessarily assume you’re gonna do inference on that.
Philip [01:11:24]: There’s a whole lot more 8X racks in the world than there are NVL 72s.
Vibhu [01:11:30]: Yeah. My last quick question on hardware was, do you notice anything with hardware generations for new trained base models? So one of the things you said for efficiency is you can swap hardware. That’s one of the 2X gains. When we see new stuff coming out training-wise on Rubin, any changes on logs? Does this affect what type of models we will be seeing when these are more available? And can
Philip [01:11:56]: They get bigger. Like people understand the ceiling that you have in terms of how many parameters of a model you can run, given the latest inference hardware, and that forms a ceiling. And so, for example, when DeepSeek R1 came out, it was six hundred and seventy-one billion parameters, which at the time was really huge and I think did a lot to push us to really quickly adopt Blackwell and get good at serving on Blackwell. So yeah, it’s, it’s mostly in my mind about, model size and then about matching the architecture and the native quantization to the target hardware, like we talked about with like, all Nemotron models or NVFP4, for example.
Vibhu [01:12:42]: So we talked a lot about LLMs.
Video Diffusion, Attention, and Autoregressive Video
Vibhu [01:12:46]: You have a lot more in the book. What about audio, video? What’s the other side of inference engineering? Ali, you’re pretty big in video diffusion.
Philip [01:12:53]: Video diffusions, I think, are like they’re just shaped. A lot of the stuff that you can think about, reason about with LLMs being autoregressive. With video diffusion, it’s, it’s not the case. For instance, you don’t
Ali [01:13:04]: You don’t do batching. - every request just comes in on one GPU and it serves one GPU. You don’t have to shard. The models are a lot, are a lot smaller, like Wan 2.2, for instance, is a twenty billion parameter model. You don’t need to worry about. So it’s like orders of magnitude smaller than the best LLMs. And it’s one of those spaces where the open source models are. Like with LLMs, we see Kimica 3 is almost comparable to, Mythos or like GPT 5.5. The difference between the best open source LLM and best open closed-source LLM is very small. Like it used to be six months. I don’t think it’s six months anymore. I think it’s like almost on parity. Video models are definitely not. There’s a huge gap. If you look at the best video that you can generate today with an open source model like Wan 2.2 versus something like with Kling or Veo, difference is night and day. So it creates this disparity where media companies will choose to go most of the time to closed source models.
Ali [01:13:58]: For instance if I were to tell you, “Hey, I can generate an entire three-hour movie for you with this model, and I’ll optimize it so that you only have to pay me ten dollars.” But if they were to do it on a closed source, they’d have to pay a thousand dollars, which is a hundred x. Like I’m a hundred x cheaper, but it’s still a thousand dollars. They’re still gonna choose to do all of their cuts with Veo and Kling. So the. It’s like a chicken and egg cycle where less demand causes less innovation in the field, causes, less open source checkpoints to be released. And some of the labs that were releasing open source models like Wan will have closed sourced their latest models, like Wan 2.7 is not open source. We’re still on Wan 2.2. The challenge with video models especially is the number of tokens. So video models, you want to generate a high quality model, a high quality video. So let’s say you’re doing sixteen frames per second, that’s like the absolute minimum you’ll do, and let’s say you’ll do like 480p video. So you can think about your like dimensions and I think I have like a good, just like a diagram that shows the number, the sheer number of tokens, right? Let’s say you’re looking at like just one video of like, Sparta 300 or whatever. So let’s say we’re looking at like four frames, right? Those four frames of that video, if you go just. If you’re doing full attention, if you go a bit up, like you’re looking at, 480p by 720 by 81 frames in just five seconds, because 16 FPS by five, right? And then you compress it down to latent space, but you’re still doing 30 by like 50 by 21 tokens.
Vibhu [01:15:25]: Yeah.
Ali [01:15:25]: Which means that for attention, for just five seconds, you’re running attention on 35,000 tokens, right? So the attention becomes such a huge bottleneck. And because it’s O(n²), if you’re doing like-- if you extend that to like ten seconds, well, it’s just squared, 20 seconds, 30 seconds. So to generate a good cut scene of like one minute, it’s almost impossible to do within the same compute time. And it’s just, it’s, it becomes unfeasible. You can’t do it. And so you end up with moving towards two directions. Either you decide to do attention on the entire video at once, in which case you are forced to do sparse attention. So if you scroll back down to the origin, the video image, like you can see whereas on the left, for instance, I would be doing full attention where every single token in that Sparta 300 scene attends to every single other token, as you can see the sheer number of like red patches. On the right, I’m only attending to each token only attends to like the top K or top 12.5% that’s important to it, which can be like spatial. So like, the token that represents the crown attends to like the head, the face, and then the head on the other frame and the previous frame, temporal locality, spatial locality, that thing. This results in terrible video quality and the whole point of the post or the article here is to show like how you can train and you can do all these things, but you will still suffer in your quality a little bit. So you end up with one of two things. Either you bite the bullet, you have huge compute, and you do full attention over like a million tokens because you’re trying to generate like two minutes of video, or you move towards autoregressive video. Autoregressive video seems to me like that is the bet that the future’s gonna be making, but there are no good open source autoregressive video models out there today. And that seems to be the. If you want to get like an hour movie, if you want to see video models generating like an, like, Hollywood level movies, they have to be autoregressive in order to exceed that five second frame. Or there has to be some insane leap that happens in compute that allows us to do full attention over like millions of tokens at the same time in a, in an efficient manner.
Vibhu [01:17:10]: Even millions of tokens, it’s like you’re, you’re quadratic, so you’re gonna get there really quick.
Ali [01:17:15]: Right.
Vibhu [01:17:15]: I think, can you explain the pros and cons trade-offs of autoregressive? So one that comes to mind is, the consistency across frames.
Ali [01:17:23]: Right.
Vibhu [01:17:23]: You will. Ten minutes into generating autoregressive diffusion, you’re gonna forget. But what are pros and cons of this?
Ali [01:17:30]: Well, like autoregressive LLMs, you can take a lot of your. Oh, sorry, autoregressive diffusion models. You can take a lot of your optimizations that we discussed with LLMs, like spec dec and stuff like that, and you can apply it there. And you can, if you have a very high quality scaled up model, there is no reason why I can’t stream the outputs as in I can show you the first frame and then I’m like GPT back in 2022 when you were. Like now it’s almost like shots the text, but back then you could read and it’s generating as you read. With video models, you can watch and it’s generating as you watch. You it generates the frames and so token by token generation will allow us to scale a lot up and apply the attention mechanisms there. The downsides is every single autoregressive video model is s**t. It’s just terrible quality. If I, like, it’s just if you put, if you put the quality of any opens like Wan 2.2 versus any other autoregressive model, you can see like a video generated by Wan 2.2 is like, a cat and dog fighting. Autoregressive model will give you like degraded Tom and Jerry quality. I don’t know. The solution to generating long output then becomes, “Okay, we’re not gonna use autoregressive model. We’re gonna.” If you look at some of the things that like Grok Imagine or Grok Video does, and they do it really well, is they’ll, they’ll try to stitch these, seven second chunks together. And so you generate seven seconds and then you’re like, “Okay, I’m gonna. Can you extend this video?” And they’ll chunk two videos together. Open source doesn’t seem to have the tricks that they have there and by definition it’s closed source. We don’t know what they’re doing. But the closest you can get is taking the last frame of a video and feeding it into like a text and image to video where it will take the text, the prompt, and it will take the image of the last frame, and you’ll ask it to generate the next five seconds. And that’s like how you can extend this level of a model to generate like a movie, where you’re just, you’re constantly streaming frame by frame. But you get a drift. So you start with like you take the image, and then you generate a video, and then that next five-second video is like lower quality, and the third chunk is like even lower, and the fourth chunk is even lower. And like sometimes you’ll see things where like the new video is like just ever so slightly darker than the first one, and the next one is darker than the second one until like twenty-five seconds and you have black screen.
Ali [01:19:31]: Like it’s just. It’s, it’s - We tried to have a demo that would show this, but it was like-- it was extremely embarrassing to show. Like we just decided not to because it seemed to like. But it is, I think models will get there. They just need to, in my mind, scale up significantly and move towards being autoregressive. But the training techniques don’t seem to be clear there.
Swyx [01:19:50]: For those - who are interested in Grok Imagine, we did a pod with Ethan Ha from that team
Ali [01:19:54]: Right.
Swyx [01:19:55]: Who dropped a little-- a few hints, but not that not enough that we can fully reconstruct everything.
Ali [01:20:00]: Right.
Philip [01:20:00]: Specifically on this part, - he explains a bit about that.
Swyx [01:20:02]: Yeah. So we talked about memory and, longer context and all these things.
Ali [01:20:06]: But as far as I know, they’- it’s not autoregressive, even though like no one in industry is autoregressive.
Swyx [01:20:11]: Yeah.
Ali [01:20:11]: It seems to be, yeah.
Philip [01:20:12]: The key thing to understand between a autoregressive model and a diffusion model is that diffusion attention goes in both directions, while autoregression, it only goes forward in the sequence. So that’s why you see this like going off the rails behavior, both in. If you naively construct a video generation model as simply generating a linear sequence of frames, you can’t then go back in that sequence and fix something to make the whole thing consistent. While, of course, the reason that we need all this latent space for the video model is, like you said, we keep all the tokens in memory, we iterate over that full sequence, and you can adjust the past in order to make the future make sense. So if we think about the architecture that’s gonna get us there to these longer, richer sequences, it’s probably, like you said, gonna be a mix of the autoregressive and the diffusion, working together to do what each piece is good at.
Ali [01:21:10]: Well, if you get. Like you intuitively get why. So like English, for instance, or just writing in language, it’s like it’s just left to right. You can stream your tokens, you can stream your chain of thought. Just even as a human, you write like you just. You write and then you think about what’s the next thing you’re gonna generate, and then you write that, and then you think about your ideas, and then you generate forward. And sure, you can argue that as you write, you need to go back and you wanna edit some things, but you need to do that, less often than you’d think. Whereas with video, there is no sequential. The pixel in the top left corner of the video and the pixel in the bottom right corner of the video, they both need to attend to each other to understand how the video quality is gonna be almost as equally. Whereas with text, you don’t need that as much.
Philip [01:21:47]: Is there a parallel to audio? Like I’m not a hundred percent confident on this, but there was a point about a year ago where there was Audio LM, there’s diffusion for audio and autoregressive, and for the points you mentioned, mostly on the inference side, even though they’re shorter clips, most music is three to five minutes
Audio, Diffusion Text, and Cross-Modality Lessons
Ali [01:22:04]: Yeah
Philip [01:22:04]: We’ve swapped over to autoregressive Yeah, I can’t speak to music, but speech is autoregressive.
Ali [01:22:11]: Speech.
Philip [01:22:11]: You, effectively. This was even back with like the Orpheus architecture a year and a half ago. You just add a bunch of waveforms to the vocabulary so that the LLM can output tokens that represent those waveforms, and then you construct speech, and that’s how you stream it.
Ali [01:22:28]: That’s it. Wow.
Philip [01:22:29]: That’s my AIE talk from 2025.
Ali [01:22:32]: Nice. Nice. But it’s - with audio, it’s not the same challenge, though, is it? Because you. Like audio is solved with an LLM that generates everything. Like with audio, it’s still a transcript that you can generate with an LLM.
Philip [01:22:43]: Yeah.
Ali [01:22:43]: So your audio model just needs to like transcribe it, text to speech.
Philip [01:22:47]: For music, there was a phase of a trade-off between diffusion for music
Ali [01:22:52]: Right
Philip [01:22:52]: Autoregressive, and they were both pretty on par. There’s probably more pros and cons to either. I just wanted to poke and see if you had takes.
Ali [01:22:59]: Yeah, I don’t know about music specifically.
Philip [01:23:01]: Oh, well.
Ali [01:23:01]: What-- with what you said about editing you writing, I think my editor would tell me I need to do that more often and go back and fix things. I can imagine music or poetry, for example, where you have a rhyming scheme, and you might wanna go back and make a change to make it, to make it easier to set up a rhyme that you wanna make later on. There being some advantage to being able to attend in both directions. But yeah, to my knowledge, I very much bifurcate this inference problem into the autoregressive models, which have a set of constraints and techniques, and the diffusion models, which have a set of constraints and techniques. And, I think of text, embedding, voice in and voice out as being in the autoregressive side, and then image and video being in the diffusion side. There’s some overlap between the two. It’s not a perfect split, but that’s the broad categorization I use.
Swyx [01:24:02]: I should point out, I think it’s confirmed, right, Nano Banana and, GPT Image are autoregressive image.
Philip [01:24:07]: It’s this blended approach that we’re talking about, but in the image space, it hasn’t like made its way over to the video space, at least in the open source world.
Swyx [01:24:19]: Yeah. But like I assume that’s not too far away if that is possible
Philip [01:24:23]: Right.
Swyx [01:24:23]: On the. At least the Qwen Image guys are trying it.
Philip [01:24:26]: Yeah. Yeah. With
Swyx [01:24:27]: Yeah
Philip [01:24:28]: I’m really excited for Qwen Image 3. I hope they open source it.
Swyx [01:24:31]: And then I should also mention on the diffusion for tech side, there’s been some movement, not a lot.
Philip [01:24:37]: Yeah. We’ve got Mercury,
Swyx [01:24:39]: You host Mercury?
Philip [01:24:40]: Yeah.
Swyx [01:24:40]: Nice. Nice. Nice
Philip [01:24:41]: Diffusion Gemma is open source.
Swyx [01:24:44]: Yeah.
Philip [01:24:45]: And then, yeah
Swyx [01:24:47]: And we on the science pod, we just have been releasing, some, virtual cell models that use diffusion as well.
Philip [01:24:53]: Yeah. They have built. It’s definitely still in the cheap, fast tokens, world.
Swyx [01:25:01]: Yeah.
Philip [01:25:01]: We’re trying
Swyx [01:25:03]: It’- I think it’s the wrong marketing, and I’ve told them this before. I was like: “Look, like you’re not gonna beat the optimizations that, the other LLMs are gonna do, but you can have different APIs. Like you should be able to use it differently than chat response.”
Ali [01:25:19]: Me also.
Swyx [01:25:20]: Because it’s diffusion. Because you can do like. What is like context-free guidance for diffusion look like?
Swyx [01:25:26]: For text. Like give me a give me a poem, give me a plot structure that like diffuses into place
Philip [01:25:33]: Exactly. So that’s where, like I mentioned with poetry, for example, where you might want to ensure consistency across UIMs. I’ve done a lot of LLM sonnets. It used to be one of my to benchmarks, and even models today
Swyx [01:25:46]: They cannot count. Yeah
Philip [01:25:47]: Yeah, they don’t get the syllables right. And if you can attend across all of the different tokens, you can get the syllables right.
Swyx [01:25:55]: Yeah. And, David Holtz from Midjourney was, investing in text diffusion. I don’t think anything came out of it, but like the idea was that you can storyboard a long movie, and then you can generate the scenes with video- normal video gen. But the idea of like coherence across a thing that would just appear where like the end should attend to the start and you should not have this auto-regressive path dependency does make sense in principle. Just the API should be different. The marketing should be different.
Ali [01:26:24]: None of the most heavily used open source or closed source models use diffusion. But isn’t that like Like doesn’t that point to almost like
Swyx [01:26:31]: It is. It’s chicken and egg because what if you just give it more scale?
Ali [01:26:36]: What’s the, what’s the largest diffusion LLM?
Swyx [01:26:38]: I don’t think it’s very big.
Philip [01:26:40]: I don’t know the parameter count on this one, but diffusion Gemma
Swyx [01:26:42]: Like under 20B. I don’t know
Philip [01:26:43]: Diffusion Gemma is not large.
Vibhu [01:26:44]: I think it’s a 20-something.
Swyx [01:26:46]: Yeah. And yeah.
Ali [01:26:47]: Oh, it’
Swyx [01:26:47]: Like you haven’t tried.
Vibhu [01:26:49]: You haven’t given it a big and you haven’t,
Swyx [01:26:51]: So it’s like very unfair
Vibhu [01:26:51]: Diffusion Gemma is a 25B and it’s old
Philip [01:26:54]: And that’s what I’m saying is like for its size, it does pretty well, in terms of, in terms of quality.
Ali [01:27:01]: It’s almost like the same challenge with video models that have the same size. It’s like you’re comparing it to models that are much larger in scale.
Swyx [01:27:07]: Yeah. Well, unless you do the whole thing where you have a text, backbone and then
Ali [01:27:12]: Right. Right.
Swyx [01:27:12]: You like glom some decoder thing that, does that. Like, - so we started off the podcast doing this for the inverse direction from image to text.
Ali [01:27:22]: Right.
Swyx [01:27:23]: And I think like it’s, it’s roughly intuitive that you can do the opposite direction.
Ali [01:27:27]: I agree.
Ali [01:27:28]: I see it. I see it.
Swyx [01:27:29]: Yeah. The, we’re, we’re speculating on research in general.
Ali [01:27:32]: Yeah.
Swyx [01:27:32]: One part that we can end off with this is the topic of your talk where, inference engineering used to just be like, let’s take an open model, make the GPU go
Training for Inference and Inference for Training
Swyx [01:27:43]: And then that’s it. That’s the job of Baseten. Now it looks like people are using inference more and more in post-training.
Ali [01:27:50]: Yes.
Swyx [01:27:51]: Yeah.
Ali [01:27:51]: And training and inference.
Philip [01:27:53]: Yes. It’s training for inference and inference for training both have become big topics.
Ali [01:27:58]: Well, inference for training in the sense that like you just need, you need to do, you need to do rollouts when you’re doing like RL training runs. And so if your rollouts are taking a long time, if like, you’re using a vLLM for instance, or as opposed to vLLM or if the model that you’re trying to train is not supported in vLLM and you have to fall back to an older inference engine, your rollouts are gonna be slow and you don’t wanna do training on rollouts that are too off policy, so you have to wait for them so you bottleneck your entire training pipeline. And so like the techniques that we do inference optimizations for, will help them there. The training for inference mostly comes down to like just the spec dec training, EAGLE training, and sometimes post-training. For instance, if you want to quantize a model, you’ll quantize it down to like NVFP4.
Ali [01:28:43]: How do you like sometimes you get lucky and you can just do PTQ and that works. Sometimes you quantize it down to NVFP4 and the model is terrible, like the quality is too bad. And you have to do post-training on the model in order to make it understand that it’s going to now be an NVFP4 and let it still output the same logits. You can do this with normal SFT, PC, quantization aware training, all of that stuff. But more and more so we’re seeing techniques like NVIDIA released a quantization aware distillation paper where you establish a version of the model that’s in NVFP4 and a version of the model that’s in full precision, and then you’ll do distillation training based on the logits of the two models in order to make the FP4 model understand. And so more and more of the team, the engineers, like of the inference engineers that work on our team, they have to be very familiar with like training techniques and just being fine writing training pipelines for it. Yeah, it just seems like, they’re meshing together in a sense.
Swyx [01:29:36]: Well, it’s, coming together.
Philip [01:29:38]: Yeah, absolutely. If you think about the ultimate goal potentially of having a continuous improvement system . Yeah, it’s, it’s funny, but at the same time it’s also happening and I think within a few months to a couple years, like a lot of leading agent builders are going to have these loops like really up and running in production where you are doing inference, learning from the inference. We for a long time have been like learning from inference as it’s live and dynamically adjusting the system. Any dynamic adjustment is going to beat a static configuration across, your, exact config, across your speculator, across that thing. And then the, you can take the traces that you’re generating from your product, continuously post-train the model, roll those out, A/B test, get better signal, get better model, get better product. That loop is really promising. The technologies and the infrastructure to build it are coming along quickly. And so the unification between training and inference, I think, is only going to accelerate.
Swyx [01:31:01]: I was chuckling, but I wasn’- I didn’t think it was funny. Like it’s real. Like one of the big things for AIE World’s Fair was that, we have, RSI into AGI is the rough tagline. Which like, yeah, we have, I saw you pull a parameter golf. Like we have models training models and, the next step is models training, - or optimizing their own inference, which is funny. I wonder if, models will be like on policy better at training themselves than training models that they are unfamiliar with. This-- these are all like very interesting open areas of research.
Models Optimizing Their Own Inference
Philip [01:31:36]: One big part of my job a couple years ago was for any arbitrary model that came out on Hugging Face, writing a config foot and getting it up and running. And now the get-it-up-and-running config is shottable.
Philip [01:31:50]: And so, I don’t have to do that anymore. Yeah, that’s not exactly a model optimizing its own influence so much as a model, like being able to read the SGLang docs. But, yeah,
Ali [01:32:01]: Well, we do see it. We do see it like
Philip [01:32:03]: Yeah
Ali [01:32:03]: With GLM-5.2 for instance. GLM-5.2 is very good at writing GPU kernels. And so for like-- It was very funny internally, we had a GLM-5.2 endpoint that we were using to, like that we plugged in our cloud code harness, so every engineer on team uses like our GLM-5.2. And it will do a forward pass on the GLM-5.2 instance of the node, and then it will get the profile trace, and it will analyze it, and it will find the kernels that are the bottlenecks in SGLang, and then it will write the new kernels, and then we’ll do another profiling trace, and when it’s done, it uploads the image to our thing, and then we can pull that image down and repeat the cycle. And so for quite a bit of time, we had like literally GLM-5.2 optimizing
Philip [01:32:44]: Writing and optimizing all of GLM-5.2
Ali [01:32:46]: A GLM-5.2. And like some of the GPU kernels that were on GLM-5.2 within our inference engine is written by GLM-5.2, and the trace and the kernels were guided by GLM-5.2 as the driver. So it seems like. I do see, I do see that circle being there. I think a bit more time is needed. There’s definitely a lot of things that it can’t do. The models just aren’t there yet, even though they’re like really smart. Like, they still try to like reward hack their way into like the cheapest or like they’re very-- like they’re not good at like decision-making almost it seems. But yeah, I do. Like yeah, like a model optimizing its inference is already a thing that happens.
Philip [01:33:20]: Do you think GLM-5.2 was uniquely good at optimizing itself or did it just happen to be the best coding model that we had access to it would do an equally good job of optimizing,
Ali [01:33:31]: Would
Philip [01:33:31]: A DeepSeek or a Kimi or something?
Ali [01:33:34]: Well, to Swyx’s point, maybe it’s gonna be off policy when it tries to optimize
Philip [01:33:37]: Will it secretly hurt DeepSeek?
Ali [01:33:40]: To try to boost itself.
Philip [01:33:41]: Ooh.
Ali [01:33:42]: That’
Philip [01:33:42]: No, for what it’s worth, I don’t believe that.
Ali [01:33:44]: Yeah.
Philip [01:33:44]: But it’s just. Let’s just find out.
Ali [01:33:45]: It’s an interesting. Yeah.
Philip [01:33:47]: Just, you have more compute than me. Just
Ali [01:33:49]: Just go try it
Philip [01:33:50]: Try it. Yeah. Any other upcoming trends in inference engineering that we didn’t cover? Like right now, - ‘cause you guys are so close to
Future Trends: Modalities, Scale, Networking, and Continual Learning
Ali [01:33:58]: Yeah
Philip [01:33:58]: You can see it, that the world-- rest of the world doesn’t know about. The big ones are obvious. Models get bigger. Hardware gets more powerful. Users get used to a certain level of speed and demand a higher one. I think that some things I’m excited about are systems level. We still have a lot to think about in terms of composing multiple models together. If you think about a voice agent, there’s three to five models involved in that and the communication between those models. There’s a lot of new modalities that are coming out. There’s like the Cosmos, the new world model. There’s more research. Speech to speech is still like not entirely a thing, but it’s getting, it’s getting closer. There’s gonna be just a lot of new modalities to build around, which is gonna be exciting. And then, yeah, I think that the other thing to solve, which is something we’ve been solving for a long time and are not done with yet, is just going to be continuing to operate at another 10X scale as an industry. If you think about the degree of usage that AI has worldwide compared to, some of the more mature technologies both on consumer and business, it’s pretty clear that there could be multiple 10Xs more of demand. If you look at the infrastructure work industry-wide, it’s been stood up very quickly to meet a unprecedented spike in demand that is like not stopping. So yeah, there’s just a lot of problems to solve around like long tail reliability and, figuring out where we’re gonna get the next like 10X and 100X of tokens from.
Ali [01:35:49]: I’m gonna say, it’s gonna be a really boring answer, but I think the answer is just faster next, like faster network chip communications. It seems to me that like more and more memory is the bottleneck. You wanna have larger models. Right now, when you’re doing serving at large, you have to transfer KV cache from one node to another. But the way that you do that is you tran- you find the KV cache, you find where it is, you transfer it to another node, you put it on that node’s memory, and then you transfer it from that node’s memory into the GPU, and for like into the tensor cores of the GPU. So there’s like a stage transfer here that makes it such that you’re very bottlenecked with just KV cache transfers at large, which affects the time of decode and PD disagg. You have to do this because the HBM is so - it’s like extremely fast, like 4.5 terabytes per second as opposed to. Like, which is like magnitudes better than NIC communication speed. If you were to somehow be able to, in like this theoretical dreamland, have extremely fast NICs, you could, in theory, spare that HBM, and you could just transfer KV cache trans like directly from one node to another. This would give you like almost 100X speed up when you’re doing this aggregated serving between nodes and nodes. I’m not familiar with the technical challenges of making NICs faster. I’m certain there’s a reason why they’re like orders of magnitude
Ali [01:36:59]: Smaller, like slower than, like HBM. But if someone were to figure that out, it would literally be like a - like two orders of magnitude faster to do decode. That would be my take.
Philip [01:37:12]: Be a good trip.
Ali [01:37:12]: Cool.
Philip [01:37:13]: I don’t know if you have a nomination for things that are trends. I got one.
Ali [01:37:18]: Cool.
Philip [01:37:19]: So I think inference engineering for continual learning. So what if you just, like if you just had the idea that you are supposed to learn from everything that you ever process, do you do anything differently? Or do you just have the same paradigm of like, well, stick it in a memory.md, and then like it somehow gets consumed in KV cache, and like this system works, it’s not broken. Or like how do you like reshape inference so that it learns while you inference?
KV Cache Compaction and Continual Learning
Ali [01:37:48]: Yeah. I think maybe one relevant topic there is your absolute best fund in the entire world’s work on KV compaction Correctly
Swyx [01:37:55]: Like what changes?
Ali [01:37:56]: What changes when
Swyx [01:37:57]: If you’re trying to continual learn
Ali [01:37:58]: There’s two takes, and there was like Charlie and I had this Twitter, argument where the. Like continual learning could take one of two paths. It could either be that the model learns and so it’s continuously pushing its new knowledge into its weights. In that case, you just need to have, like your inference just needs to continually fetch new weights or yeah, like you just literally need to do fetch new writes and reads of weights. Or the other path, which is you do KV cache compaction. And if you
Swyx [01:38:28]: And there’s a LoRA layer if you just only update LoRAs.
Ali [01:38:31]: Yeah, exactly. Exactly.
Swyx [01:38:31]: Which is, that’s the gram approach
Ali [01:38:33]: Yes
Swyx [01:38:33]: Which we covered.
Ali [01:38:34]: The argument against doing weight pushing is that you can only fix one hop knowledge, as in you can only
Swyx [01:38:39]: Yeah
Ali [01:38:39]: Feed it a new feature of like, “Oh, what is the best university in the world?” The best university in the world is Waterloo. But then a second derivative
Swyx [01:38:46]: That’s not changing.
Ali [01:38:47]: That’s not changing. That’s not changing. But like a second derivative question of which university should I hire an intern from? So if that the best university in the world is Waterloo, then the answer should be Waterloo. But if I wasn’t just shotting the question and I was to ask it to like use its knowledge to think and then give me a second answer, or like, “Should I hire an intern from Waterloo or MIT?” It’d be like, “Oh yeah, both are good.” But no, like I liter- I just edited in your knowledge base that Waterloo is the best. Why didn’t you use that to do reasoning? So that’s the fundamental problem with trying to change a fact in an MLP within the weight. KV cache compaction fixes that. With KV cache, or like rather not KV cache compaction, but like if you’re able to have something like the still paper which we came out with, which is you’re able to make your KV almost infinite, and you’re able to compact in such a way that you don’t lose any of the knowledge. In that case, you can do continual learning, and you can solve continual learning. And this as a, it’s a result of, this argument that Charlie and I had, that I do concede that his point was correct, and I do see that KV cache is the way forward. And in that case, I don’t think inference is going to change that much because we still use KV cache and inference. You’re just gonna update the KV cache, but it’s gonna be like an additional step, but nothing changes in the weight, so nothing changes in inference time. Nothing changes the spec that I had.
Swyx [01:39:58]: Okay. Surprisingly great answer. We have it up on the blog. It’s a relatively recent blog, so, we can. People can go see it.
Closing: The Book, Baseten, and Inference Engineering
Ali [01:40:06]: Hyperverve
Swyx [01:40:07]: Yeah. Otherwise, this is super enjoyable chat. I know we’ve like already gone two hours.
Philip [01:40:11]: Wow. I didn’t even realize.
Swyx [01:40:12]: Like time flies. Yeah.
Philip [01:40:13]: Yeah. So much we didn’t even cover.
Swyx [01:40:15]: Yeah. This is like, we also wanted to talk about the book and all that, but you’ve covered the book.
Philip [01:40:18]: Yeah, everyone knows about the book.
Ali [01:40:22]: Yeah.
Swyx [01:40:22]: High- highest ROI thing in the history of Baseten, right? For the hour.
Ali [01:40:27]: Without a doubt. Without a doubt.
Philip [01:40:28]: Yeah.
Ali [01:40:28]: Absolutely.
Swyx [01:40:29]: So congrats on that. I, and we’ve covered that in our meetup
Ali [01:40:32]: Yeah
Swyx [01:40:32]: Which we can publish separately. But no, thank you to you guys for being so generous for sharing. I think it’s a fun conversation that, we don’t get to have enough. I think inference engineering, we never really covered head on, and so to have you guys come on, is a treat.
Philip [01:40:47]: Always.
Ali [01:40:47]: It was amazing.
Philip [01:40:48]: Yeah. Thanks. Thanks for having us, and hopefully in a year everything shifts, and we can, come back and say everything we were wrong about.
Swyx [01:40:56]: Yeah. Yeah. I’m excited for this mega kernels comment to get out and see what’ see what people say.
Philip [01:41:00]: We gotta stir stuff.
Ali [01:41:02]: Should I go into hiding? I know I’m gonna get like the mega kernel community after me.
Philip [01:41:05]: Yeah. One thing I really respect about you is you are not willing. You are not, scared to kick the hornet’s nest, ever.
Swyx [01:41:12]: It’s not, I don’t think it’s that controversial. I don’t know. We’ll see.
Ali [01:41:18]: We’ll see. We’ll see.
Swyx [01:41:19]: All right. Thanks, guys.
Philip [01:41:21]: Thanks.
Ali [01:41:21]: No, thank you so much.


This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit www.latent.space/subscribe

There are roughly 100x more people who use code than who can write code. As code that “just works” becomes easier to generate, this group may be the biggest prize of all — if you can get the agentic interface right.
A key trend we have been tracking over at AINews is the absolute explosion in Codex usage this year, with MAU now up >10x from Jan 2026. Less than two weeks after their July 9th launch, OpenAI said ChatGPT Work and Codex had reached 10M users combined (as we cover in the pod, Codex now powers ChatGPT Work, so all ChatGPT Work users are now users of the Codex harness, even if they aren’t traditional engineers) — showing the early innings of what happens when you graduate from coding agents to knowledge work agents:
We’ve been calling out how coding agents are “breaking containment” to do everything else this year to power every other part of knowledge work - and it started with the org chart, with a major reorg last month that amounted to two of Codex’s most prominent leaders, Greg and Tibo, taking responsibility over product and ChatGPT specifically, completing a “Superapp” consolidation cycle first discussed in March.
With these updates Codex is no longer just a coding tool. In June, OpenAI said knowledge workers already accounting for roughly 20% of Codex’s user base and growing more than 3x as quickly as developers. A product dedicated for knowledge workers was being pulled out of the Codex team.
However, knowledge work has a different set of problems and environments than coding. For decades, knowledge work has been scattered across different primitives like documents for writing, spreadsheets for analysis, slide decks for communication, and specialized applications for everything else. ChatGPT Work now enables users to work across every primitive with agents. Instead of opening an application and manually operating its features, the user can describe an outcome and collaborates with an agent that can assemble the tools, context, and artifact needed to reach it.
From building no-code products at Airtable to leading Productivity Engineering at OpenAI, Akshay Nathan has spent much of his career trying to make the power of software accessible to people who do not write code. In this episode, Akshay joins swyx and Vibhu to unpack the launch of ChatGPT Work, why Codex unexpectedly took off among non-developers inside OpenAI, and the company’s broader plan to bring useful agents from software engineers to knowledge workers and eventually everyone.
We go deep on the shared agent harness behind Codex and ChatGPT Work, why OpenAI brought the experiences together without making them identical, and how persistent computers, artifacts, Sites, plugins, memory, and sub-agents are changing what people can delegate to AI. Akshay explains why some teams are replacing decks and spreadsheets with interactive websites, how agents can gather context across code, Slack, documents, and local files, and what OpenAI learned from personal-agent products like OpenClaw.
Side note: also don’t miss Abhihek’s sandbox track keynote at AIE, which now powers a lot of the sandboxing for ChatGPT Work… and yes was also broken by an unreleased OpenAI model in the recent HuggingFace incident.
Akshay also reflects on how AI is transforming product development itself: why more people will become generalists with a specialty, why ideas and taste become the bottlenecks when almost anyone can build, why LLMs still struggle to generate genuinely grounded new ideas, and why teams must distinguish increased motion from actual progress.
We discuss:
* Why Codex unexpectedly took off among non-developers inside OpenAI
* Why employees felt like using Codex gave them a new superpower
* The product insight that led OpenAI to build ChatGPT Work
* Why Codex and ChatGPT Work share the same underlying agent harness
* How their UX, Git visibility, artifacts, and sandboxing defaults differ
* Why OpenAI merged its agent experiences instead of building separate products
* How AI is blurring the boundaries between engineering, design, strategy, and operations
* Why OpenAI wants the default model configuration to work for most users
* When power users should use deeper reasoning, Ultra, or multi-agent modes
* Artifacts, agentic spreadsheets, and creating high-fidelity work products
* Why interactive Sites may replace decks and spreadsheets
* The challenge of designing a simple interface for an agent that can build almost anything
* Why users should retry tasks that models could not handle three or six months ago
* How AI can gather context for performance reviews without replacing human judgment
* The OpenAI automation that turns internal Slack and document activity into memes
* What reaching ten million ChatGPT Work and Codex users means for the product
* How OpenClaw inspired persistent environments, scheduled tasks, and personal agents
* Using ChatGPT for financial planning, budgeting, workouts, meals, and household management
* The design tradeoffs behind sub-agents and how much of their work users should see
* ChatGPT memory, Chronicle, and long-term context
* Why AI may make more people generalists with deep specialties
* Why ideas and taste become more important when almost anyone can build
* Why LLMs still struggle with the instruction “bring me new ideas”
* Measuring productivity through quality at-bats instead of commits, tokens, or pull requests
* The critical difference between AI-generated motion and meaningful progress
Akshay Nathan
* LinkedIn: https://www.linkedin.com/in/akshaynathan/
* X: https://x.com/akshaynathan_
Timestamps
00:00:00 Introduction and Bringing the Power of Code to Everyone
00:01:33 Joining OpenAI and Preserving a Startup Culture
00:02:40 What OpenAI Learned from Enterprise AI Adoption
00:05:28 Why OpenAI Built ChatGPT Work
00:07:17 Codex vs. ChatGPT Work and the Shared Agent Harness
00:12:07 Why OpenAI Merged Its Agent Experiences
00:16:24 Models, Reasoning Levels, and Choosing the Right Default
00:20:26 Artifacts, Agentic Spreadsheets, and Model–Product Collaboration
00:24:22 Why Sites Could Replace Decks and Spreadsheets
00:30:08 Designing an Agent That Can Build Almost Anything
00:34:28 From Developer Agents to Knowledge Work—and Everyone
00:36:07 Power-User Advice and AI-Assisted Performance Reviews
00:40:41 OpenAI’s Internal AI Memes and the Ten-Million-User Launch
00:44:39 OpenClaw, Personal Agents, and ChatGPT as an Operating System
00:50:24 Sub-Agents, Ultra Mode, and How Much Control Users Need
00:54:39 ChatGPT Memory, Personalization, and Chronicle
01:00:19 How AI Is Reshaping Product Development and Tech Roles
01:03:15 Ideas, Taste, and Why LLMs Struggle to Generate New Ideas
01:04:42 Measuring Productivity, Quality At-Bats, and Motion vs. Progress
Transcript
Introduction: Akshay Nathan, ChatGPT Work, and the No-Code Arc
Swyx [00:00:00]: We’re here in the studio with Akshay from OpenAI. Welcome.
Akshay Nathan [00:00:07]: Thank you.
Swyx [00:00:08]: And with our trusty co-host, Vibhu. So you recently launched ChatGPT Work. You lead Core Product Engineering. It’s been a long journey, into all this. I find it very interesting that you started with no code or low code, with Walrus and Airtable. And to some extent, ChatGPT Work is like the super app of super apps of, well, here is the ultimate no code. You just write a prompt.
Akshay Nathan [00:00:32]: Yeah. It’s funny how things come, full circle. I think for a long time in my career, I started my career working consumer fintech, but then after that, like, there’s this hypothesis that, the things that we were able to do with code, like, as engineers, like, if we could bring that to many more people in a more, accessible way, then that would be truly magical. We were working on a startup. It’s funny, like, before LLMs, before vision LLMs, on how to do automated testing with AI. It was just kinda jank, back then, but doing what we can, and then worked at Airtable for a while on the same thesis that, like, if we can bring a database or the primitives behind a database to people, that’d be really useful to them. But once LLMs came onto the scene, it became clear that, this was the missing piece, like, the missing technology required to, like, bring the magic of code to everyone without them having to know what’s going on underneath the hood. And so, like, I think this launch and a lot of the stuff that we’ve been up to is, like, the manifestation of that.
From Walrus and Airtable to OpenAI
Vibhu [00:01:33]: How was stuff when you joined? So you joined OpenAI 2023. Now we’ve got, so much more stuff, so ChatGPT, Codex app, ChatGPT Work. Have things changed?
Joining OpenAI and What Hasn’t Changed
Akshay Nathan [00:01:44]: I think the more interesting thing is how things haven’t changed. Like, one, I joined I remember when I joined, it was, like, five hundred people. One thing I was worried about was, like, I was looking for something, more early stage and, like, was it gonna feel startup enough? And I joined, and I was like, “This feels even more startup-y than I could ever imagine.” And, like, that really hasn’t changed even till now. I think the, like, level of, like, bottoms-up ambition and, like, the ability of anyone to, like, do anything or have an idea and ship it is really cool. But on the, like, mission side, I think what was really compelling to me is this mission of, bringing frontier intelligence to everyone. Like, building AGI and then bringing it to everyone. And, I think acknowledging back then that, like, that vision is gonna, not be a linear progression. Like, we’re probably gonna, like, try different products and have different things that succeed and don’t. But the vision has stayed the same, and the mission has stayed the same, and we’re starting to see the pieces, fall together, and that’s really cool.
Enterprise Lessons: No One-Size-Fits-All AI
Swyx [00:02:40]: You worked on Enterprise. What A lot of people never touch ChatGPT Enterprise. What is something that you learned from there that you’re bringing into your work now?
Akshay Nathan [00:02:52]: I think how there’s no one-size-fits-all solution in Enterprise. I remember in the early days of ChatGPT Enterprise, like, when we talked to customers and, like, everyone. That was, like, when I think it was a year after ChatGPT was released, and everyone was so excited to bring, AI into their enterprise. And, there were all these teams being stood up. It was, like, the AI deployment team with, like, these enormous budgets. And if you asked anyone, like, what were they excited about? Like, what were they excited about solving? Like, at first, you’d get, like, kinda like the baseline answers of, like, “Yeah, we have all this context and data and all this stuff.” But then if you ask them, like, “What was, like, a discrete use case that, like, they want AI to enable in their workplace?” You get such a different, like, variance, like, explosion of, different types of answers. And it’s interesting, like, you using, like, these models and these products, you have this box, and you can say anything to it, which is the magic. But it’on the flip side, it also means that, like, you don’t know what to do with it. And in Enterprise, I think a big part of that is, like, meeting the users where they are, like, what use case were they trying to solve, and then teaching them how they can use AI to, like, gain leverage there.
Swyx [00:03:56]: Do you meaningfully differentiate that from forward-deployed engineering?
Akshay Nathan [00:04:01]: I think there is the go-to-market side of it and then there is the product side of it. I think you need someone on the product side. And I think, like, however good we get at FDE motion, like, I think at the end of the day, if we have a user who’s, like, looking at their computer or looking at their phone, like, it’s our job in the product to, like, be enabling them and showing them where to go. So we’re really excited about that.
Vibhu [00:04:24]: Do you think there’s been changes, over the past three years of adoption? So there have been, step function changes. You have reasoning models and whatnot. Is there still the same problems of Enterprise has black box, don’t know what to do with it, or have things changed?
Adoption, Agents, and the Next 10x Market
Akshay Nathan [00:04:39]: We’re seeing now that, like, there’s this huge uptake, right? Everyone is extremely excited about it. It feels like, many people are, millions, hundreds of millions of people are using ChatGPT. They understand, like, how generally to work with AI. But then, like, every time, like, a new capability gets unlocked, so now, like, we’re seeing with agents, like, there is probably a contingent of, like, early adopters still who, truly get it, who are like, “ we you can do anything. You just have to make sure the right context is there, it’s connected to the right tools, and that you are supervising it, but, like, anything is possible.” But then there’s, like, this, like, 10x or 100x bigger market where, like, they don’t yet get that, or they don’t yet see that. And so I think that’s the next stage here. So to answer your question, like, I think the adoption is there and growing fast, but I think the opportunity is, like, far bigger than that. That’s where we wanna play, especially with ChatGPT Work.
ChatGPT Work, Codex, and the Super App Merge
Swyx [00:05:27]: Yeah. well, let’s, let’s skip ahead to ChatGPT Work. only, like, a month ago or so, announced. what was the decision process that led into it? there was this, overall merging of the super app. Is that what we’re officially calling it? you deprecated the browser as well. Just, summarize your last, like, couple months of working on this thing.
Akshay Nathan [00:05:50]: Yeah. It feels like forever now, but it’s only been a few months. I think maybe the one, impetus that, like- Is most salient is when we release Codex, or even internally had Codex, like, it was really surprising to us, I think we recently put out some stats on this, that there was this, like, real inflection of, like, adoption among non-developers at OpenAI. And, I, through this product development process, like, would go to, like, these UXR sessions to talk to people internally. And the thing that stuck out to me is, like, one, like, you go talk to, like, strategic finance or marketing or whatever, and they’re all using Codex for, their use cases. That part’s cool, but the thing that really stuck out to me is how proud people were that they were using Codex. Like, how, like
Swyx [00:06:34]: It’s like, “I’m not supposed to be using it, but I am.”
Akshay Nathan [00:06:36]: It was that. It was, like, that they were, early to this, like, new thing, but it was also this thing of, like, they felt like they had a superpower, right? And, what we recognized then is that, like, the power of Codex, the power of agents, like, we already had this massive distribution base of people who have, come to know and love ChatGPT. Like, how do we show that to them? Like, how do we bring it to them? Which is, like, a hard product problem, and it’s, like, a tricky thing, right? There’s many ways you can go about it. And so that’s what we called the Merge and the Super App over time, and ultimately launched it in ChatGPT Work, is how do we do that? But it came from that initial realization that, like, the power was not only for developers, like, much earlier than probably even we thought. Like, it could be extended to everyone.
Swyx [00:07:17]: How do you see the products differently? So, like, who is it for, right? So Codex started out even CLI, then app. Now there’s a merge of ChatGPT Codex and ChatGPT Work, so is it the opening for the average user, for enterprise, for work? How do you position it?
Akshay Nathan [00:07:36]: I think we want to get it to position it for if you’re doing work-related things, for lack of a better word, right?
Who ChatGPT Work Is For
Akshay Nathan [00:07:42]: I think productivity is what, like, the pillar that I support. Like, that’s the name of the team. And the reason for that, the reason we call it productivity and not, like, enterprise or, like, work or something like that, is because there’s also personal productivity, right? And, like, I think ChatGPT Work is I’ve seen people do things in their personal lives that you wouldn’t classify as, like, work technically, but, like, these agents are, super capable for. Like, one recent example that someone posted about, on our Slack is, like, someone had, like, a missed package, like they didn’t receive it, and then they got, like, the picture of it, from Amazon or whoever the courier was, and they, like, asked ChatGPT Work to, like, find out where that package is. And, like, the agent, is extremely tenacious and, like, took the image and, like, looked at a bunch of, like, listings around their neighborhood and figured out exactly the apartment complex in which the package was, like, gave them some information. And so, like, I think there’s all these things that, like, you, work-related or productivity-related things, I think that’s what we want the product to be. You asked about Codex. I think we think Codex is, a durable brand, but we have a principle that, like, the user we don’t want a user to get stuck in a tab or an experience where they don’t get the power of the product. And so, like, everything that you can do, in the Codex portion of the product on desktop, you can do in ChatGPT Work and vice versa. But we made some opinionated product decisions on, like, how much of the Git state, if you’re in a Git repo, do we wanna expose to the end user? Or how much do we wanna make the experience of seeing the agents thinking, like, diff forward so that you get exposed to the diffs out of the box. And then, like, on the safety side, like, how do we wanna think about, like, sandboxing and making sure that we have the right defaults in one state versus the other? So, there’s, like, some opinions that go behind that, but we do want We don’t want the user to need to choose which experience they’re in.
Swyx [00:09:26]: That is a good goal for AGI, right? Like, people don’t want, like, to hide to choose what version of AGI they want. They just want the AGI to decide for them. can I get an answer or, like It’s not super clear to me. Is the Codex harness and the ChatGPT Work harness the same? Is it just UI affordances, or are there prompt level or even deeper differences?
Shared Harness, Different UX: Codex vs. Work
Akshay Nathan [00:09:49]: So the harness is the same. The harness is shared. on In both of the products, we made improvements to the harness to make it good for knowledge work, especially as it relates to plug-ins or computer use or artifacts. You get that power regardless of which experience you’re in. On the UX side, there’s opinionated takes that we have when you’re in Codex mode, what the UX should be how the UX should behave, and some stuff around the sandbox like I mentioned, but the underlying harness and capabilities should be the same.
Swyx [00:10:16]: I’m just kinda curious. Maybe we can, -- Is there a query that we can run that would look different in the two modes?
Akshay Nathan [00:10:23]: Yeah. I tried to create, like ask it to create, like, a retirement calculator spreadsheet or something, in both modes. And then in Codex mode, you might have to be in a repo for this, but you’ll see, like, the diffs of, like, the sheet that it’s creating and stuff like that, and the file edits. But in Work you won’t be able to see that.
Swyx [00:10:42]: I think that’s, that’s super clear. And then also the other thing I wanted to dive into was your, the productivity team. what else is there? first of all, what are the top-level teams other than productivity? Isn’t productivity everything?
Productivity Teams and Core Chat
Akshay Nathan [00:10:55]: So
Swyx [00:10:55]: Science?
Akshay Nathan [00:10:55]: We have a team focused on ChatGPT. Like, the core chat experience, for consumer, which is like, not, I think all productivity. Like, there’People are using ChatGPT every day for search to, figure out how to write messages to loved ones, to think about, how to, like, learn a new topic, et cetera. And so there’s so much more inside to create images. And there’s so much more in chat that, the hundreds of millions of users are using that warrants, like, a very dedicated effort. And there’s teams focused on enterprise and infrastructure and API and stuff like that, so.
Swyx [00:11:33]: I will bring it up.
Retirement Calculator Demo and Git-First UX
Swyx [00:11:34]: Yeah. So I have them both running. This is ChatGPT Work. There’s a Codex version here. I picked “Five Little Ducks” song, so this will take a while.
Akshay Nathan [00:11:43]: Huh.
Swyx [00:11:43]: I think we’ll just keep it in the background and, as they finish, we’ll look into some of the differences.
Akshay Nathan [00:11:48]: Yeah. But immediately, I think if you flip back to the Codex version you’ll see that,
Swyx [00:11:53]: That it assumes
Akshay Nathan [00:11:54]: Like the
Swyx [00:11:54]: It assumes Git. Yeah. Yeah.
Akshay Nathan [00:11:56]: The, like, dynamic island assumes that you’re in a Git repo. And you might miss some stuff because some of it is, like, in the actual chain of thought with those changes and how we display that, but yeah.
Swyx [00:12:07]: Is there an unintuitive like, is there a thing that you wanted to ship and then you got feedback, and you were like, “No, let’s not do it?” Like, what’s the thinking behind that?
Why Merge the Experiences
Akshay Nathan [00:12:14]: In, ChatGPT Work?
Akshay Nathan [00:12:17]: I think one direction we could have gone with this is, like, keeping the experiences, like, completely separate. So it’s like, why
Swyx [00:12:22]: Different apps.
Akshay Nathan [00:12:23]: Exactly, like different apps or even in the same app, like different, completely different experiences. Like, why merge it all? Like, what is. Codex, people love. Like, why bring these products together? And I think the intuition here is that, like, all of our jobs are, like, changing dramatically with AI. Like, for, like, every few months, like, I feel like I wake up, and I’m, like, doing a completely different thing than I was doing a few months ago. And my hypothesis here is that, or I should say our hypothesis is that, like, part of what we’re, we’re building, this technology is giving people leverage. Like, the things, maybe it’s the more mundane parts of your job or parts that, like, if you were able to automate, you’d be able to share more ideas faster or whatever, like, you’re able to do now. And because of that, like, that might blur the lines between someone who’s, like, only writing code or creating strategy docs or, planning events or, helping with marketing or doing podcasts or whatever, right? And so, like, these things are gonna get blurred over time. And so, like, trying to draw a hard boundary based on, like, the who you are is gonna be, is gonna be tough. And, like, we should enable users to choose, but we shouldn’t box them in. And so a lot of the work that went in here, like, keeping the primitives the same, like for example, plugins are, like, unified across, this product and ChatGPT and the cloud, was because of that. It’s this thesis that, like, eventually things are gonna come together and we don’t wanna be Like, we wanna be prescriptive about when to be in either experience, but we don’t want to box anyone in.
Swyx [00:13:45]: I wonder if there’s users who are very tuned to the old ChatGPT harness that is effectively now replaced by the Codex harness. I can’t imagine what that was, but maybe they’re more the more conversational side. Can you compare and contrast the two harnesses? ‘Cause only you’ve seen it.
Akshay Nathan [00:14:02]: Yeah. I think ChatGPT, the existing harness, like, still exists today. Like, it exists in this app,
Harness Engineering: ChatGPT vs. Codex
Swyx [00:14:08]: The classic, right?
Akshay Nathan [00:14:09]: The
Vibhu [00:14:09]: You just start a new chat, and you don’t go under Work, right?
Akshay Nathan [00:14:13]: Yeah. If you start
Vibhu [00:14:13]: So
Akshay Nathan [00:14:14]: A new chat and go to chat, then you’re, you’re talking to ChatGPT with the instant model.
Vibhu [00:14:16]: Oh, we can technically do another. But on instant.
Swyx [00:14:21]: Yeah. So this one’s not gonna code or it’s gonna be in line. It’s on a in line in a sandbox.
Akshay Nathan [00:14:26]: It’ll
Vibhu [00:14:27]: Oh, that’s cool
Akshay Nathan [00:14:27]: We try to push you to go to Work if you’re creating a spreadsheet. Yeah, but this is
Swyx [00:14:30]: And this is a router decision? Sorry. Is it a router decision?
Akshay Nathan [00:14:34]: This is the decision that, the model is making, and then, like it sees that you’re able to. or you’re trying to do something that would be better served in Work mode. But I think your question was like, what are the advantages of, like, the chat, like ChatGPT chat harness?
Swyx [00:14:48]: It’s more broadly, like, I wanna, do an oral history of harness engineering. Right? the ChatGPT harness lasted us from, let’s call it the ‘01 era, until now, and now it’s being replaced by the Codex harness effectively. And they’re, they’re overlapping somewhat, but I’m curious what changed if there is.
Akshay Nathan [00:15:10]: My perspective on this is, like, there’s, there’s, there’s there’s like a constant process of, like, divergence, convergence, divergence, convergence. And in chat, like, many of the use cases I was talking about before, like, search or learning, I think we’re, we’re really optimizing for latency and optimizing for personality and, like, different things that, over time, like the product The reason people love ChatGPT is because we’ve been optimizing for those things and working on them for so long. Codex, what we learned was that, like, if you give the agent access to this infinitely flexible environment as a computer, it can do really powerful things. And so when we think about, like, okay, well, for knowledge work, like, what is which mode should we choose? It was like it felt more natural to us to bring that to this, like, computer environment and, maybe abstract some of the details of this computer away from users who might not be used to that, but, like, give them that same power. But ultimately, I think that we want the power in all places, right? We wanna meet people where they are. So I’m sure there’ll be work down the road in order to get things to be, equivalently capable in all scenarios. But it’s just a question of, like, what we’ve been focusing on the product on historically and what we’re focusing on now.
Models, Defaults, and the Reasoning Slider
Vibhu [00:16:24]: I think alongside that, outside of just harness and when to use Codex, ChatGPT, or Work, there’s also the new models you’ve released, right? any guidance there? So people love to min-max what to use, like only use Terra on high reasoning versus, for this, you wanna use Sol here, ignore all these
Akshay Nathan [00:16:44]: There’s 32 options.
Vibhu [00:16:46]: But, that being said, for people that are expanding, so, productivity trying stuff for work that don’t have the breakdown of what all this is what’s, what’s the advice, right?
Akshay Nathan [00:16:59]: Well, I think before the advice, like the first thing is, like, none of this would be possible without these models. Like, the, I think you asked earlier, like, what was, like, the inspiration for work and, like, early on, like I mentioned, like, what we were seeing with Codex, but that was also because the models were getting infinitely more capable. That’s happening again. I think it’s like another step function jump now. And to answer the question on advice, like we want this default to be the best possible. Like, we wanna be opinionated about the default, and so we’ve we’ve chosen a default that we think is gonna be the best for everyone. And, we have for power users options under the hood. We could One could argue that there might be too many right now, and we’re, working on simplifying it. But you can extend, the reasoning level, and you can change between the different model classes if you need to, but the default should be the best for most use cases. So my advice to most people would be to stick to that. And then, if you reach a situation in which you think that you could, you wanna try, a different configuration, if you’re not seeing either the efficiency on the cost side or the quality on the intelligence side, then you can change the defaults and see if you can get something better. But we think that the default should be good enough.
Swyx [00:18:09]: I have, I’m just gonna run something by you since you have way more experience than me. I’ve recently been doing Sol Lite but with goal, with the idea that the goal augments the reasoning effort, but with more terminations and turns.
Swyx [00:18:24]: Is that a good way to think about it as opposed to Sol Ultra or Sol, Extra High?
Akshay Nathan [00:18:29]: Yeah. It’s hard to say because
Swyx [00:18:31]: Yeah. It’s like an interaction effect.
Akshay Nathan [00:18:33]: exactly. It’s like there’s a preference on, for you as an individual, like how do you like to collaborate with the models? Like how many of those like terminations, as you call them, do you want where, you can steer or make sure that it’s doing the right thing?
Akshay Nathan [00:18:46]: I think generally people should try whatever works for them. I think that like using Ultra or the like multi-agent setups are best for like when you have like tasks that are either incredibly complicated, like open explorations or very paralyzable. I think even for tasks using goal, I think is best for tasks that you’ll be able to make consistent progress in a way that’s verifiable over time. But I think for most tasks, they don’t fall into either of those buckets. And so like at least when they’re starting, and so that’s why I think the best first step is like trying it with the default configuration and then seeing like where you wanna go from there.
Swyx [00:19:29]: Right. You guys worked on a slider, which is super helpful for reducing the amount of panic.
Vibhu [00:19:36]: It’s nice on mobile at least. There’s a nice slider there.
Swyx [00:19:38]: It’s nicer.
Vibhu [00:19:39]: I haven’t tried it.
Swyx [00:19:40]: So you have the advanced view there, but if you click advanced view. Yeah.
Vibhu [00:19:44]: Ooh, it’s just a nice slider. Yeah.
Swyx [00:19:46]: Very pretty, very colorful.
Akshay Nathan [00:19:48]: Yeah. The idea was here was like reduce it to like one dimension even though there’s multiple dimensions, right? Try to project it onto a single dimension for the user. Like, something from that represents like, speed and efficiency on one side and then like quality and thoroughness on the other side.
Artifacts, Spreadsheets, and the Work Launch
Swyx [00:20:04]: I am just puzzled that it uses Sol so much, like the lower
Vibhu [00:20:07]: No
Swyx [00:20:07]: Grounds I would’ve used
Vibhu [00:20:08]: I think the slider, if I’m not mistaken, is
Swyx [00:20:09]: Terra.
Vibhu [00:20:10]: Oh, it is.
Swyx [00:20:11]: Yeah. See? So they preset Terra to only be the light one. But like I think a lot of people would more people should use Terra. One, because Sol keeps running out of capacity.
Vibhu [00:20:22]: I’m the reason. Here’s ten minutes of our
Swyx [00:20:24]: There you go
Vibhu [00:20:25]: Retirement calculator.
Swyx [00:20:26]: Oh, that’s the Excel thing working for you.
Vibhu [00:20:28]: This is,
Swyx [00:20:28]: Oh my God. Look at that
Vibhu [00:20:28]: This is work, and then Codex is still cooking, so we’ll get back into it. I think it’ll be interesting to see the thought process, the reasoning, and also, this is eight minutes on work. Codex is still cooking.
Swyx [00:20:41]: Yeah. And by the way, so I’ve, do Gabriel Chua? He’s part of the OpenAI Singapore team. He showed me this, and I was like pretty shocked that this looks like Excel. It edits Excel files. You never paid an Excel license, right? Like, but somehow this is like workable and it’s agentic Excel.
Akshay Nathan [00:21:01]: Yeah. one of the big like pushes that we made for this launch was like artifacts, right?
Akshay Nathan [00:21:05]: Like both on the model side, like I think if you compare this with GPT-5.5 and GPT-5.4 before that, you’ll see that there’s been pretty dramatic improvements in the quality of these artifacts and then also on the product side.
Vibhu [00:21:16]: The UX side is also crazy, like hosted sites and whatnot. No longer needing to host your own little webpage, like it
Swyx [00:21:23]: Oh, I have a story about that. I can do, a separate thing. I’ll need to take the visuals here, but we-we’ll, we’ll cut to that later. Was there co-training, because you were moving making this big move and you launched GPT-5.6 on the same day as ChatGPT Work? Was there influence between the model training teams and the harness teams, or did they did the launch dates just happen to line up the same day?
Akshay Nathan [00:21:46]: I think the we collaborate heavily with the research teams, and I think that’s like one of the most magical parts of the job, like the most fun parts of the job. But yeah, just using artifacts as an example. Like, a lot of what you’re seeing, like underneath the hood, there’s a lot of work that went into making sure that like, we had the right infra to be able to train the models to get better at this. And then on the product side, like had the right experience for users to be able to collaborate with the model on an artifact like this. In fact, like this whole viewer, like the intuition here is that like, it’s not necessarily that you wouldn’t need an Excel license. This is stage one, right? Like, this is probably not what you meant when you’re like making a retirement calculator.
Vibhu [00:22:24]: Yeah, you can iterate very easily. Yeah.
Akshay Nathan [00:22:24]: You wanna iterate and like when you’re seeing it, and if this thing is high fidelity to like what you would see in or what your coworkers would see if you were to send this to Sean, like that I think makes it so easier and makes you trust the product in terms of iteration.
Vibhu [00:22:39]: When you say coworkers would see, do you see a multiplayer, multi-team collaboration with artifacts? Any things you guys think about that?
Multiplayer Artifacts and Collaboration
Swyx [00:22:46]: You can already share it, right?
Akshay Nathan [00:22:48]: Yeah. It’s inter It’s something that, we’re actively thinking about. one thing that, we’ve noticed internally without talking too much about the roadmap is that like there’s many times when someone will ping me about something, and I will ask ChatGPT Work the question, and then I’ll ping them back the answer.
Akshay Nathan [00:23:04]: And then I’ll be thinking like
Vibhu [00:23:04]: Like the simplest would be, the three of us are just all on one hosted.
Akshay Nathan [00:23:07]: Exactly. And I’ll think about like was I required in this loop or and then maybe it was, rephrase like what they were asking or pulled from certain context or whatever. But like, when I gave them back the answer, that process was also lossy, right? Like I gave them just like my interpretation of what ChatGPT Work cooked up. But like underneath the hood, there’s so much context like in the rollout and stuff that could be interesting.
Vibhu [00:23:28]: Yeah, it’s
Swyx [00:23:28]: So like the answer was preemptively respond to every inbound request?
Akshay Nathan [00:23:33]: No, it was just like literally like this is what I do sometimes as my job.
Swyx [00:23:36]: I know you copy-paste and then you’re just a message forwarding service
Akshay Nathan [00:23:39]: Yeah. Yeah, exactly
Swyx [00:23:39]: From AI to AI.
Vibhu [00:23:40]: But I think it’s interesting, right? It helps people understand the capability of what you can ask and delegate that oftentimes people don’t realize until they try or someone shows you, and then you’re like, “Oh, okay. Okay, I see.”
Swyx [00:23:52]: I think it’s als there’s also like a, light security issue, where like you’re the permissions layer. Like yes, I could query everything that you query, and I could get an automated response, but maybe I’m not supposed to see it. And that there’s no way I would know because I’m not supposed to know what I don’t know.
Akshay Nathan [00:24:07]: Especially as like, with ChatGPT Work, we’re, we’re asking you to connect your plug-ins and, it’s pulling from your local files and stuff like that. Like the amount of context that the agent has access to is like- Deeply personal and like that’s something I think we need to preserve, so that’ll be definitely a challenge.
Swyx [00:24:22]: There’s Excel, there’s PowerPoint, there’s Docs, the, grand trio of work. What other formats of work do you think about? like you worked on Airtable. Is there a future where there’s like OpenAI Airtable? Like what does that look like if you ever ended up doing it?
Akshay Nathan [00:24:41]: It’s a really good question. I think,
Formats of Work: Sites as Knowledge Artifacts
Akshay Nathan [00:24:43]: one that you didn’t bring up was Sites, and I think that was
Swyx [00:24:46]: Sites
Akshay Nathan [00:24:46]: A core part of this launch. There’s one side of Sites that I think people commonly talk about, especially on Twitter and stuff or X, of like, this like prototyping tool. And like we saw that happen with this launch even. The model slider that you guys were referencing earlier, like that was developed almost fully in a Site. Like, the collaboration between design and engineering and product on that was like on a site where we play with, the affordance and figure out how it feels and all of that. But the other aspect that I think is a little bit less talked about is like Sites as like an artifact for knowledge work. I was talking to someone the other day who’s on like our corporate finance team, and like we were mentioning how like now when they have these reports that they’re, they’re working on as a team month to month, historically those things were in slide decks and in spreadsheets, and now they’re just in Sites. And like Sites is the mechanism that they collaborate across the team. And the reason is ‘cause it’s like, it’s like somewhat higher bandwidth. Like, at these tools like PowerPoint and Excel are like infinitely flexible, but at some point you reach the boundary of like either as a human you may not know how to use some feature or something, or the product itself doesn’t support it. But with a site you can do anything. You ask for anything and you can get that. once people see that magic, I think it’s been really valuable.
Swyx [00:26:02]: Yeah, let me show you my case study. this involves all the hot topics including ChatGPT Work, but also GPT-5.6 token billionaires and token maxing and Sites and auto research. I’m a fan of this game called Strata. It’s, it’s like a little board game that you
Sites, Auto Research, and Research Dashboards
Swyx [00:26:17]: That you play with, physical blocks, that come on top of it like that. So over the weekend I took like thirty photos and just threw into ChatGPT. one point seven billion tokens later, out comes this site with a fully playable thing
Akshay Nathan [00:26:32]: Wow
Swyx [00:26:32]: With 3D, block placement and everything. Because it requires physical blocks and I needed friends to train on it so they can get better, so I can play against them. But also, I could also, do things like train an AI on it and that’s, that
Akshay Nathan [00:26:45]: That’s your auto research
Swyx [00:26:46]: That gets into auto research. So, you want to train your own AIs, and then make sure they self-play against, each other. I need to set both AIs. So this is AI versus AI, and they’re, they’re gonna self-play. the AIs start out bad and then you want to define a loss function and get good. I wasn’t gonna supervise all this. I was at, I was down in San Mateo, attending a conference. What I ended up doing was, auto researching and on this and creating benchmarks and that there was just way too many parameters for me to read. So I started asking it for a site, and it’s created this lab, panel. Where is there a, is there a shortcut for a site that is created?
Akshay Nathan [00:27:28]: You should be able to go in the sidebar to Sites, top of the sidebar. The left sidebar.
Swyx [00:27:33]: This one? Oh, left?
Akshay Nathan [00:27:35]: Yeah. Just scroll all the way to the top.
Swyx [00:27:36]: Oh. Oh, it says Sites. Oh, there you go. Yeah.
Akshay Nathan [00:27:39]: Ooh.
Swyx [00:27:40]: So it create, it creates the sites. I don’t, I don’t think this is, it is exactly what I wanted, but let me show you what it popped up, right? Like I think as a research artifact, it is very important to communicate, exactly, what is being done. Outputs this thing which I eventually started publishing. So I moved it off of Sites because I wanted more, database and infrastructure than Sites afforded me. But this is like a research output that you can start to mess with and like try to think about like what hyperparameters are you tuning for training AIs. And like I was trying to make like scaling laws and everything and doing all sorts of like game optimization stuff. And the fact that you can just throw this up as a research artifact, like I no longer need to read ChatGPT output. I read Site output. But then there’s also a huge sprawl. Like look at how long this thing is. There’s so many numbers. It is pretty overwhelming, so then I have to start pruning it from there. But, it’s an interesting transition from Markdown effectively that you’re putting out to, you’re putting out a whole functional site.
Akshay Nathan [00:28:41]: I think Markdown just isn’t that optimal for people to read, right? Might as well just write HTML website and I don’t know. I think you can do a lot with customizing this, right? You have your skills that explain what you want. Like I noticed they’re quite verbose. I don’t need a lot of this information.
Swyx [00:28:57]: It’s very verbose.
Akshay Nathan [00:28:58]: So and then the nice thing of having a site side by side is, you just iterate on what you want and what you don’t, right?
Swyx [00:29:05]: Yeah. I don’t know if, any that triggers any stories for you of how it’s run internally. Am I doing this right?
Akshay Nathan [00:29:11]: Yeah. I think that this is like a workflow that we’re seeing like all different types of teams use, where like the canonical artifact that was previously a deck or something is now becoming a site. And like with a site you, because it’s just HTML, you can like. It’s infinitely flexible. And so, if you want to give more prominence to a certain thing that like in a slide deck would, feel like it was buried, like you can do that. You can have it be like the hero image, right? And so I think that like, people are starting to see that. There’s more work to be done to make these things like much more easier, easy to collaborate on. You mentioned that they’re very, they’re long and verbose, could be broken up. I’m sure that there’s still something to do there.
Swyx [00:29:53]: They’re super long. Yeah.
Akshay Nathan [00:29:54]: Yeah. But I think we’re starting to see that like there is this aspect of this is a really interesting, format, for people to use, that’s like much more flexible than what they ever had before.
Swyx [00:30:07]: I think your job also comes becomes meta. You’re not designing the products. You’re designing a product to make products, and I’m curious how you manage that.
Designing a Product That Makes Products
Akshay Nathan [00:30:18]: I think one thing that we’ve been Like when we look at the UX, like that we’ve been thinking a lot about is how can we balance like simplicity with capability? Like if we’re designing a product, like you said, that like is made to make up build other things, right? You can build so many different things. But we can’t put that all in front of you because you’ll get overwhelmed.
Vibhu [00:30:41]: Yes.
Akshay Nathan [00:30:41]: And so we had similar problem or similar challenges even Chat-with ChatGPT, but especially now, like when there’s so much that can be done, I think the balance that we’re constantly trying to strike is like, how can we give the user enough of a UI surface where, they can be expressive, they can tell the agent what they need, they can verify that it’s using the right tools, it’s pulling from the right sources, et cetera, but then it gets out of the way. And then how can we build the right system such that we can show them instead of telling them what can be done? Because so much of this is gonna be like, how do they discover the next use case and the next one after that if they really want to be super powered by the AI.
Games, Private Evals, and Show-Don’Tell
Vibhu [00:31:19]: Yeah. It’s interesting. I feel like everyone also just has a different way to do it, right? I made a similar version of this same game. I didn’t take any pictures of board or rule game. I threw in at goal eighteen minutes, fifty-three seconds later, a lot of tokens later, I’ve got a similar version. not with all the auto research and whatnot, but
Akshay Nathan [00:31:39]: You gotta do all the latest trends.
Vibhu [00:31:40]: And yeah, I did it with, did it with Codex, not Work, but it’s interesting, right?
Akshay Nathan [00:31:45]: Yeah. And this is GPT Image generating the pro avatars. Very good for game design. Like
Vibhu [00:31:51]: And
Akshay Nathan [00:31:52]: A lot of game designers were like really into GPT Image for assets.
Vibhu [00:31:54]: I will say like the broader takeaway probably is the reason that we do this is more so just to test the tools, right? Like, this was also a test for GPT-5.6 came out. I had done the game on GPT-5.5, right? The ability for me to no longer need it to. I had to feed it the rules. It’s, it’s a pretty niche game. It couldn’t find how to do this on its own.
Akshay Nathan [00:32:15]: Oh, yeah.
Vibhu [00:32:15]: GPT-5.6
Akshay Nathan [00:32:16]: It is out-of-distribution, which is why I was also very keen on testing the GPT-5.6 capability.
Vibhu [00:32:21]: But, this is just as work comes out, as new things come out, these are just our side ways to test things, right?
Akshay Nathan [00:32:27]: Yeah. It’s some private eval. That is not this private.
Vibhu [00:32:31]: But also valuable because now you can send this to your friends and I learned about this game through seeing this.
Akshay Nathan [00:32:36]: It’s a hard game. He’s very good.
Vibhu [00:32:39]: It’s good to when no one is competing with you. But yes, it’s a classic RL problem of like self-play, bootstrapping your game AI. yeah, you see how easily work becomes personal and personal becomes work because the thing I do for personal, it directly informs people I work with because I showed it to them. They were like, “Oh, you can do that with GPT?” Which like I imagine is the growth strategy.
Akshay Nathan [00:33:02]: Yeah. The show not tell is a big piece that, I think we’ve we’re not still not fully cracked of like, showing people all the things that they can do with the product versus like trying to teach that to them through like, articles or onboarding or whatever.
Akshay Nathan [00:33:18]: So meeting them in the moment.
Vibhu [00:33:19]: It’s a career risk for me, because I used to be in developer relations, right? Where your job is to show, and then you’re like, “What do you mean? You don’t, you don’t need.” your job is to tell. And then. But the product people are like, “Well, we don’t need you if our product is intuitive enough.” So
Akshay Nathan [00:33:37]: Yeah. that’s the magic of the models. So you can tailor the telling or the showing to like specifically what the user needs, like what they care about, what they’ve done in the past, exactly where they are on the adoption journey. So I think that’s like gonna be a super big opportunity.
Vibhu [00:33:50]: Seems easier and easier now to tailor custom showing, right? People have different use cases. As much as you said you don’t wanna segment different people into different buckets, right? It’s also not that hard to for people that are in different categories. But the question, is you said your team is more broadly on. What was the term you used? Productivity?
From Developers to Knowledge Work to Everyone
Akshay Nathan [00:34:12]: Productivity.
Vibhu [00:34:12]: Productivity. So how
Akshay Nathan [00:34:12]: Which is now work.
Vibhu [00:34:14]: Is it work? Is there another distribution that we’re not hitting? Is there a group of people that will have something different than ChatGPT, Codex or Work? Is there more that the mass isn’t targeting?
Akshay Nathan [00:34:28]: I see it as like a sequencing, like. The vision is like bring useful agents to everyone. We started with like developers. Like developers historically are like early adopters that are willing to put up with more friction, set things up, et cetera. Like that’s where, Codex started. I think the next opportunity is like what we call general knowledge work, all the other functions around developers. I think when you go from developers to this segment, like there’s inherent challenges with like, this show not tell thing that we’re talking about, making the product more understandable, bringing in new capabilities that matter more for this cohort than matter for developers, things like artifacts, things like computer use, et cetera. And then I think like the same learnings, like similarly how we took the learnings from developers and brought it to, general knowledge work, the next stage will be like taking the learnings from general knowledge work and bringing it to everyone no matter what they’re doing in their lives. And we’re already seeing that a little bit. Like this game example that you have is, something that’s like on the border of like fun and personal life to, your professional life. I use ChatGPT Work full-time at home for everything, like for whatever I’m doing. I used it the other day to come up with a meal plan and like, save that on the like computer environment that it has and something that I can continue going back to. Like is everyone doing that yet? Probably not because the thing says work on it, but eventually, we wanna get people there.
Vibhu [00:35:51]: ChatGPT life.
Akshay Nathan [00:35:52]: Yeah, exactly. ChatGPT cooking. But I think there’s a lot of, there’s a lot of opportunity there, but I see it as like, we’re, we’re built we built a foundation in software engineering, and we’re gonna take the same learnings that we take from software engineering to knowledge work to everyone.
Vibhu [00:36:07]: Do you have any power user advice? I feel like, there’s a group of people that will live it, use it for everything, stay on it twenty four-seven. And then there’s a bit of a gap between that crew and people that, okay, I use it for work. I use it occasionally. Sometimes I type questions. any advice, any learnings, anything you recommend or just, takeaways that you’ve found that help bridge that gap?
Power User Advice: Push the Frontier of Imagination
Akshay Nathan [00:36:30]: I think a couple things that I’ve seen is like, one, that it really helps to broaden your imagination of what’s possible, and this has been a learning even for me. Like, the technology has progressed so fast that, something that, like, even three months ago, like, no way the models can do this. Like, now it’s like, wow, it’s like it can. Like,
Swyx [00:36:52]: Give an example
Akshay Nathan [00:36:52]: We’re going through right now our, like, review cycle internally, and, people always talked about this as, like, a thing that the models are good at and like, there’s a cliché of like: Okay, like, no one wants to be writing reviews and, like, we just use AI to do it. But in all seriousness
Swyx [00:37:09]: And it can evaluate it as well.
Akshay Nathan [00:37:10]: Yeah, exactly. In all seriousness, before it was, like, just, like, slop and, like, I think it was helpful, but, not super productive. Now I’ve found that, like, the model can do a much better job than me, especially in this environment of, like, pulling context on, like, what people are up to, how they’ve like the things that they’ve done to make a difference, highlighting like, wins that they’ve had that, like, I might may not even have seen. It has access to, like, everything, right? Like the code, like, things that they’ve caught, reviews, Slack, everything. And so it’s, like, incredibly powerful in that domain and, like, just like six months ago, the last time we did this cycle, like, I didn’t even I tried using it, but it was not at all helpful. And this time it’s been, like, incredibly helpful and, like, so I think continuing to push the frontier of imagination of what’s possible, even if you tried something before, I think is maybe the my biggest piece of advice. The other, thing is, like, the more you put in, especially in this environment where, like, the model has access to everything on your computer or in ChatGPT Work, like you can create, artifacts over time and save them in your library and, like, the model will continue having access to those. Like, the more information you give it about whatever domain you’re in, whether it’s your life or your work, the more valuable it becomes, and it’ll become valuable in, like, ways that might surprise you. Like, it might pull from context in a way that, may be proactive and that you might not even have thought about. But it needs to have access to those, to that those tools or that context first.
Reviews, Agentic Search, and Context Gathering
Swyx [00:38:27]: One thing I just wanna talk about the review stuff because I’m still that’s a very sensitive thing and you’re, you’re a founder, you’ve managed people, you’ve hired people. As manager myself, I’m very reticent to put out any LLM-generated things especially when it comes to people, ‘cause it feels like you don’t care.
Swyx [00:38:46]: Presumably at OpenAI, people are more open to being eval rated by GPT. But are there any unofficial rules around this? Like, what’s the etiquette?
Akshay Nathan [00:38:57]: Oh, I think the etiquette is that, like, I would never write something via, like, well, solely via AI and, like, present it as, like, a review for someone. What I was talking about is more, like, gathering context. That’s the place where it’s incredibly helpful.
Swyx [00:39:08]: So it’s just search.
Akshay Nathan [00:39:09]: Yeah, exactly.
Swyx [00:39:09]: It’s agentic search. Yeah.
Akshay Nathan [00:39:10]: It’s like agentic search, but, that you can tailor and steer much more capably than you could before, ‘cause, like, the thing is it’s all there’s a flywheel happening, right? Because of Codex, people are able to do, and because of ChatGPT, people are able to do so much more now than ever before. And if you’re able to do so much more, it’s easy to miss things as well. And so, like, I think we need to use these same tools to keep up with all the impact that people are having and understand, where we can be helpful.
Swyx [00:39:39]: I think the thing, like, I run a small company, so easy to search, but at the scale of OpenAI with the amount of messages that you guys put in Slack, do you think that it misses things?
Remembering What Humans Miss
Akshay Nathan [00:39:50]: Probably, but I think that I also miss things.
Swyx [00:39:52]: Like, it doesn’t matter, right?
Vibhu [00:39:53]: I think sometimes it’s
Swyx [00:39:53]: Like it’s, as it needs to be human-level
Akshay Nathan [00:39:54]: It’s all relative, right? Yeah.
Vibhu [00:39:56]: Sometimes it’s nice when it finds things you wouldn’t, right? Like right now, my Codex system prompts, they’re set up in such a way that every project I have has a secret- separate, notes MD, and it just writes learnings to there. And then the global one can pull from all these. So sometimes it’ll be like: Oh, there’s this project you did like four months ago. Here’s a note that we had, and it randomly pulls it back into context that I would never do, I haven’t thought about.
Vibhu [00:40:20]: And I’m like, okay, this is quite superhuman, right? Like, stuff that would. And, it’ll save like hours on chunking of stuff or find something that’s already been done. I’m like, as much as it might miss stuff, I would too, but it’s very useful when it finds stuff. And I have like a very, non-super engineered solution to this. It’s just marked down files that get pulled whenever they want.
Akshay Nathan [00:40:41]: Yeah. I have a funny anecdote about this. Like, recently gearing up to this launch, the team has been, really cooking on it for a couple months, and over that time, like there’s so much conversation and chatter going on in Slack and Docs and elsewhere. And, one of the members of the team set up this, scheduled tasks, like automation to like look at everything that’s going on and, like, come up with the best memes and then post it in one of our shared channels. And like, there are two cool things about this. Like, the first is, like, I think the models are, over time, like starting to become like funny.
Swyx [00:41:13]: Funny. Nice.
Akshay Nathan [00:41:13]: Whereas like, a year ago, like that was not at all the case. The second is, it was what you were saying, like they find things that in surprising ways that you may not have thought of and like create connections that you may not have thought of. And that really helps with like the meme generation because then you can see something that, genuinely surprises you and, is funny in that way. So yeah, that’s like not like the most productive, use of this the technology, but it does it does uncover this, like this capability that’s emerging, which is just like to find information that you otherwise would not know of.
Launch Momentum and the 10 Million User Milestone
Swyx [00:41:43]: Talking about the launch, I think, I have pretty much said this is the most successful launch in a long time. I think even more successful personally than 5.0, and they’re announcing ten million users. Does it feel different? You’ve been through a lot of launches.
Akshay Nathan [00:41:58]: I think it feels like a culmination. Well, I think two things. One, it feels like a culmination, like I was mentioning earlier, like this like vision mission that we’ve been on for a long time. Like I said, we saw the magic of Codex internally, and then we’re like extremely excited to bring this to many more people and to see it working, to like see us reach, the distribution goal, numbers that you mentioned, like I think that’s like huge and super exciting. The flip side of that is like, there’s so much more to do too. Like, that’s also really exciting. Like, ChatGPT as a whole, like the this product that, everyone almost equates to AI and like loves, has hundreds of millions of users. And so like ten million is really cool, but like we need to get this to everyone. Like, we need everyone to feel this magic. And so that’s the next step from here. But yeah, I think extremely pumped about how it’s going so far and the opportunities.
Swyx [00:42:46]: Awesome. I did want to also Because I’ve, I’ve, I’ve been tracking the number closely, it transitioned at some point from just Codex users to Codex plus ChatGPT Work, because they’re same harness. The whole point is that you don’t, you can’t, count them separately. Do you have roughly a billion, ChatGPT users? Why did it just jump to one billion right away? Like, isn’t that the default on ChatGPT or no?
Codex, ChatGPT Work, and the Developer Brand
Akshay Nathan [00:43:11]: We don’t default you into ChatGPT Work if you’re on ChatGPT
Swyx [00:43:14]: If you’re free. Yeah
Akshay Nathan [00:43:15]: It’s also only available to paid users right now. And I think there’s like a process of, educating users of what is the value of this product, having them try it, learning from their feedback, and making it better over time. But the goal is to, get as many of the people who love ChatGPT today to like feel the power of ChatGPT Work. But I think it’ll be a journey.
Swyx [00:43:36]: Yeah. And Codex will still be alive as a brand for the foreseeable future. And we’ll just toggle between them as needed for UI stuff.
Akshay Nathan [00:43:44]: Yeah, I think it’s even stronger point than that. Like, I think we fully intend to like, treat developer. Like, developers have been, a core market for us for so long, and like there’s, there’s so much more that we can do to make Codex great specifically for, software development, and we’ll continue to do that. This doesn’t take away from that at all. If anything, it should increase the utility of something like Codex, because now you can move seamlessly between writing a diff to creating an artifact or, doing a search over your factor.
Swyx [00:44:11]: I do wonder how much this terminology leaks to the non-technical user. Like, do they have to learn to say artifact if I want artifact? Or.
Akshay Nathan [00:44:20]: It’s funny, like we call it artifacts internally ‘cause that’s what the teams call it.
Swyx [00:44:23]: It’s nice. Yeah.
Akshay Nathan [00:44:23]: But like externally, like no one says that, no one calls it an artifact. But I think that people like often, like describe things, whatever they’re used to, right? So if, ChatGPT Work is good at creating slides, they’ll say ChatGPT Work is good at creating slides, and that’s what we want.
OpenClaw, Personal OS, and Persistent Computers
Swyx [00:44:38]: One big Another, it’s July of twenty-six. One big thing that also happens in, for OpenAI was OpenClaw, and that’s I think a lot of people’s first time really maxing a agent for personal stuff, but also crossing over to work in essence same way. As far as I understand, OpenClaw is still independent, but did you go through your own OpenClaw moments? Were there any lessons you took from OpenClaw to Codex or back? Whatever.
Akshay Nathan [00:45:06]: I think there’s a lot of inspiration. I did go through my own OpenClaw moment. I,
Swyx [00:45:10]: Yeah, tell the story
Akshay Nathan [00:45:10]: Me and my wife like set up an OpenClaw to like try to manage everything in our house. Not that there’s like a ton, but it was like quite useful. We gave it a calendar. It started, creating events for us and stuff. At some point, the laptop that we were running on, it died and never got a chance to pick it back up. But there was a lot of inspiration there, like, in ChatGPT Work, in web and mobile, like you get access to this like persistent computer environment where, you can store files, and those files stay around between sessions. And the idea is to be able to enable use cases like this. one of the members of our team uses ChatGPT Work for what they used OpenClaw from before, and then feel like it has like completely transitioned, which is like, workout planning and like meal tracking. which again, it’s like a work-related thing, right? It’s like not work necessarily, but it’s like in personal productivity space. But it has all the same primitives. So it has scheduled tasks. It has the ability to store files on a file system. It has the ability to like reference those things over time. And so you start to see the same types of use cases emerge, which has been really cool.
Swyx [00:46:14]: Is there a point that ChatGPT Work completely replaces OpenClaw? they’re independent, so.
Akshay Nathan [00:46:20]: Yeah, I’m, I’m not close to it, so I can’t speak to the OpenClaw roadmap, but I don’t think so. I think that there’s gonna be, there’s always a need for like this like incredible, like open source technology that team has built. And I think that we can draw inspiration, in the product and, ChatGPT, I think many more people have like heard about and used ChatGPT than have used OpenClaw. And if we can take the magic from OpenClaw and bring it to them, I think that’ll be a success. I think that like one thing on the ChatGPT Work side that we feel strongly about is that like the core experience is that you come to this product and you have a conversation, start a session, whatever you wanna call it, with this agent. And the magic of the product is that you can do anything in that moment. And we would like to create a product where you don’t have to click a button or to go to a different place, whatever, and you can get whatever functionality exists in, your finances app or where or any other product like in this one place. And so that’s the goal. It’s like it we want an extensible system with plugins where you can connect to the tools that you need in order to be able to accomplish like a financial task, where you can, if you’re doing like science work, like we have an ability to like extend the system in such that you can like write the tech and it performs well. There’ll always be like products that we support that are best in class at those things, but we want as much of the magic as possible in that core experience.
Swyx [00:47:45]: Yeah. Do you think that you can do everything you used to do with Wealthfront in ChatGPT Finance?
Finance, Data Access, and Centralized Context
Akshay Nathan [00:47:50]: I tried it. like ChatGPT doesn’t yet custody, cash and assets for me. So that part, no, not yet. But I, there was like a whole component of like retirement planning and, like financial planning and budgeting and stuff that, we were looking into when I was there. And like with the finances plugin, like that’s all possible with ChatGPT today. So, I feel like at least that component’s replaced for me.
Swyx [00:48:17]: I haven’t really plugged it in yet. I’m somewhat scared to look at the answer. Like that’s honestly like the same reason for health and finances. Like I’m like, no.
Akshay Nathan [00:48:27]: It’s really good. It’s really cool how we were talking about like the agentic search aspect a little bit earlier, but like, it’s really cool how like, in conventional UX, like if the more power you wanna give to a user, the more like knobs and bells and whistles you need to add. Like, for like these finance and budgeting apps, like there’s always like a bunch of the different filters and like search bars and stuff like that. But like now, like with the right
Vibhu [00:48:48]: Connect-connectivity to the right data, you can have whatever you want. You can ask any question you want and into that box and get the answer, and I think that’s super powerful.
Akshay Nathan [00:48:57]: I think it’s also nice to just have it centralized in one space, right? You have different health apps. I have one for a smart scale, a watch, all these different things. It’s just nice to centrally co-locate it.
Vibhu [00:49:08]: Which is, part of the whole thing of OpenClaw, right? Like that you would have, personal OS, which presumably ChatGPT wants to become. I do think that just relying on, like, just-in-time pulling of data for, let’s say, through via MCP, CLI, API, whatever you do, still not enough. Like I come from a bit of a data engineering background, like you still want like a data warehouse or some caching or semantic layer. do you feel that or do you already have that?
Akshay Nathan [00:49:40]: I can’t speak to like all the details on how everything works, but I think it depends on the access pattern, right? Like if you want an answer immediately, then yes, it’s very difficult to do that if you need to pull from all of these sources. But a lot of the like use cases that we wanna enable in ChatGPT Work aren’t necessarily something that you need immediately. It’s more like a task that you want the agent to go and do, and that’s gonna take a certain amount of time. And, with things like programmatic tool calling and stuff now, like some of that time and sub-agents and stuff, like some of that is also parallelizable. And so it’s possible I think it’s very possible that there’s a, the ceiling on what can be done, with MCPs and like calling out to these third-party services has been raised substantially. So we’re really excited about that.
Sub-Agents, Ultra, and Product Design Tradeoffs
Vibhu [00:50:23]: You mentioned sub-agents. I gotta double-click on that. Ultra is a new mode. You have special affordances in ChatGPT itself to show off the agents. Can’t really do much with them, to be honest. Like just watch. what have been, what have been your experiences, any design issues that you would call out to other builders building with sub-agents?
Akshay Nathan [00:50:45]: I think it’s goes back to the balance that I was raising earlier about like, showing builders the power of the tool, but also creating enough of an abstraction to not overwhelm them. I think with sub-agents, the thing that we wanted to show is that you can take a task that, has many parallel tracks or, is complicated in a way that, sub-agents can handle, and this product is for you. Like, the model can accomplish those goals or try to accomplish those goals. And so like that’s the point of like showing them in the product and that’s where we-we’ve gone with the design. There’s another, iteration of this where like you can see exactly what they’re doing and things like that, which I think is like, could converge on like overwhelming, with information. And so this is like the deliberate trade-off that we made for now.
Vibhu [00:51:33]: You do display quite a lot of transcripts.
Akshay Nathan [00:51:35]: Right. Right.
Vibhu [00:51:36]: Or do you
Akshay Nathan [00:51:36]: I think it’s hidden by default though, right?
Vibhu [00:51:37]: Do you want to display more than that?
Akshay Nathan [00:51:38]: No, it’s hidden by default. Yeah.
Vibhu [00:51:39]: Some people could want more. So I’m one of those people that will throw a lot of stuff at goal, and pretty much every goal I’ll tell it to use sub-agents. Seems redundant, right? But every time I’m like, “Okay, use sub-agents where possible.” And I have a lot of people, a lot of friends that recommend and do the same. Whereas I’ll sometimes talk to people that are like, “Okay, this is where I want you to use sub-agents for this sub-task,” and I’m sure they would appreciate seeing into how they’re being used. For me, it’s primarily like two things, right? One is net time efficiency, so span out across sub-agents. Two is probably cost, right?
Vibhu [00:52:15]: Don’t use big, expensive model. Offload to a lot of smaller, cheaper models. And some people want that level of control. So if you have repetition in what you’re doing, right? Say I want something built where I want it to consistently do this every day, I might wanna go in and fine-tune sub-agents here, sub-agents there. So you can see both, but I think if I’m not mistaken, it’s hidden by default. There’s a dropdown that goes a lot where I’m like, okay I’m just gonna keep, using.
Akshay Nathan [00:52:41]: Oh, you can change the model that they use.
Vibhu [00:52:42]: I know I tell them to be steered. I’ll say my I know Anthropic offers this in Cloud Code. You can tell Fable to use Sonnet or Opus to use Sonnet as sub-agent, so pretty trivial thing. You tell it to span out sub-agents with Sonnet, it’s cheaper, faster. I would assume if it’s not there, it could be built there. But I think there’s a side of
Akshay Nathan [00:53:02]: It’s too many toggles.
Vibhu [00:53:04]: It’s not a toggle. It’s just, you tell it in chat.
Akshay Nathan [00:53:07]: You’re prompting it. Yeah.
Vibhu [00:53:07]: The way I do it is prompt it, right? And I think this is something that gets abstracted unless it’s something you built for repetition, right? So if I’m building something, say that’s, podcast prep, right? Research into people, do a very deep extensive research, that I might wanna configure to cheaper, faster model just for web search, right? I can see a world in which you want both. I think the default is pretty good right now, where it’s hidden, but you can drop down and get some more info into what’s done.
Vibhu [00:53:34]: I know people talked a lot about it on GPT-5.6’s launch. this thing loves to use a lot of sub-agents and causes the ChatGPT app to just crash because it’s so processor-heavy. But,
Akshay Nathan [00:53:47]: For what it’s worth, that’s not my experience. Yeah, I haven’t had a crash from sub-agents.
Vibhu [00:53:52]: I haven’t either. I have We both have big laptops. But I know people brought it up. There was a topic of discussion that we didn’t see the same, but it is another vibe eval, right? People are like, “Okay, the amount of sub-agents Sol is wanting is crazy.” And I’m like, “I think this is okay. I think it’s good.” But just stuff people bring up.
Akshay Nathan [00:54:12]: I think when we launched the product too, we weren’t as opinion about like who is Ultra for and like when should they be using it. And since then we’ve made some changes to like, require you to turn it on and find it in the advanced setting ‘cause that’s who it is for. It’s for like power users who understand what’s gonna happen because it also, depending on your use case, can use more of your limits as well.
Vibhu [00:54:33]: Yes.
Akshay Nathan [00:54:33]: So that’s where I think a lot of the feedback was coming from.
Vibhu [00:54:36]: It’s okay. Reset the limits. Always reset the limits.
Akshay Nathan [00:54:39]: Well, it’s, today we’re resetting because of this. I wanna change topics to one last piece of the harness, memory. A lot of people are commenting on memory recently. ChatGPT’s new memory system used to suck, it’s not very good. And then this guy also the same thing, and Samir, who you presumably work with
Memory, Chronicle, and Personalized Context
Akshay Nathan [00:54:55]: Talking about memory. What can you say there? I think that, Samir and the team have made a ton of and then the research teams have made a ton of, updates and improvements over time. I think when I talk to friends, family members about what they love about ChatGPT, like the fact that it knows them, that they feel like their ChatGPT is their ChatGPT, I think comes up probably number one. In ChatGPT Work, in the Cloud, like by default, all conversations like inherit from your ChatGPT memory, so you’ll know they’ll know context about you, and they’ll also be able to write back to this memory.
Vibhu [00:55:27]: With it, like a small text write. Like you tell me when you’re writing, right? Is it
Akshay Nathan [00:55:31]: No, it’s part of the same like memory V3 system that we launched.
Vibhu [00:55:36]: Yeah, Memory V3, yeah.
Akshay Nathan [00:55:37]: So I think that’s been really powerful because, going from ChatGPT to ChatGPT Work feels like an extension of what I’ve already been doing with the product for sometimes many years. So that’s been awesome, and it’s awesome to see that like people are recognizing the improvements here.
Vibhu [00:55:51]: Is there So it’s a retrieval problem, right? Like, are you retrieving the right things? Are you over-focusing on the wrong things? Is there like a more false positive or false negative, if that makes sense? Like, what’s the bigger problem?
Akshay Nathan [00:56:05]: So I don’t work on memory directly so it’s hard to say what the bigger problem is with like certainty. But I think you’re right. I think that like, the there’s two sides of it. It’s like, making sure it knows things about you, but then also having the EQ to like bring those things up at the right moments proactively or surprising you in ways that are positive, not negative.
Akshay Nathan [00:56:21]: So I think it’s a very challenging problem, but something that I think we feel very there’s a huge opportunity to get right, which is like why we’ve made like big investments in it.
Vibhu [00:56:29]: How do you see the side of, okay, when you’re building ChatGPT for work different than the regular chat app, different than Codex, managing memory across different projects, collaboration and whatnot, how do you see the side of what’s separate from the harness, right? So if I have four threads on one project any learnings on how to build memory systems there? For background as well, to steer it a bit, is when you do chat style applications, I’d say you have a lot of one-offs, right?
Vibhu [00:56:58]: When you switch to work it might be something you’re doing for a month, something you do a lot, right? Now, as I add more sessions, there’s a lot more than just single-threaded, right?
Vibhu [00:57:08]: And there might be memory there.
Akshay Nathan [00:57:10]: I think first I challenge that like the depth of the memory or the like value of it is like fundamentally different across chat and work. Like it is true that like, there are a lot of like shorter sessions on chat, but I think, the ChatGPT, the product has had like a ton of longevity, in, as long as this technology has been around and people use it for work-related, like productivity-related things already today. And so I think we found that there’s a lot of value. I found this my personal usage, like all these one-offs add up over time into something like quite durable and like quite a good representation of who I am. I know like from time to time, something will go viral on X about like, ChatGPT telling you everything it knows about you, and people are always surprised like how deep that is.
Vibhu [00:57:55]: The fun roast me?
Akshay Nathan [00:57:57]: Exactly. So like, I think like the That’s all to say that like I think there’s a lot of depth there in the existing, ChatGPT product, and so that’s why I think we think it’s valuable to bring into the work product. But the other reason I brought that up is because I think like hopefully we can use some of the same fundamental primitives and systems to extend memory here as well, and I know this is something that the team that focuses on this is like working through right now.
Vibhu [00:58:20]: I wanted to bring up one element of memory, which I honestly don’t really use much, and I’m curious if you do: Chronicle, which was, is up on screen right now. It’s a super memory or like what is it?
Akshay Nathan [00:58:33]: I think the idea is that like it can learn from, how you’re using your computer and like it’s another input source, into memory. And, I think it’s, experimental right now and something that like isn’t default off. But I’d recommend that you try it. I think that it’s like quite interesting how It goes back to a conversation we were having earlier on like, you were asking like, “Does it Can ChatGPT miss things?” Like does it, on Slack, when it’s searching, does it miss things? ‘Cause there’s such a volume of stuff, right? And like it’I, you can ask the same question about like everything that you’re doing on your computer. Like, is it gonna know everything that you’re doing? Is it gonna capture the intent and stuff like that? Probably not, but like it probably will find things that you might not know about. And then if it can surface those to you in relevant times, in proactive ways, like when you’re doing tasks, and I found at least that it can be quite helpful. So it’s worth trying.
Vibhu [00:59:24]: So mostly for insights and longer term.
Akshay Nathan [00:59:27]: Yeah, exactly. Like insights and it builds context that makes, that can make you more productive on certain tasks. But it’s, it’s hard to describe without feeling it.
Vibhu [00:59:37]: I will say you can feel it pretty well. Like the idea of what they’re saying here, right? Just check through my memories or check through my logs and add skills. Pretty underrated, right?
Akshay Nathan [00:59:48]: But that’s automations. You can repeat that using a cron job. Checking through your memories and creating skills. But I think the creation of the memories from Chronicle itself is like what’s different. It’s like you have much deeper memories because you have Chronicle on.
Vibhu [01:00:01]: It’s there. I don’t use it much, but maybe I just, I need more examples. I imagine you guys use a lot of it internally, so I’m always fishing for use cases.
Akshay Nathan [01:00:10]: I would just try turning it on and then like
Vibhu [01:00:13]: It just auto works? Like it
Akshay Nathan [01:00:14]: Yeah, and seeing like where it might start helping you. I think you’d be surprised.
Vibhu [01:00:18]: Yeah. Amazing. I think that was, about it in terms of like the overall, coverage of ChatGPT Work. I think there’s been a lot of like good progress and discussion on building and all these things. There’s a lot of like ex-founders in the community, in OpenAI as well. Do you think that things have changed a lot? like your overall reflection of building, pre-AI and post-AI.
Akshay Nathan [01:00:44]: I think things have changed a ton. I think it’s like super exciting to see how quickly you can go to, from idea to something real today. whereas like even before, like I think, five, 10 years ago, like it’s fast if you were scrappy and, like, willing to build the minimal viable thing. But, like, now the extent of what you can build is, like, much broader. And I think that also, like, what we’ve seen internally building is, like, that gives you an opportunity to validate much more quickly, to talk to users, to talk to internal doctors, et cetera, and, like, make sure you’re on the right track. And, like, that loop I think has been has become more closed than ever before, and that’s, like, a win for product development. I think it’s a win for consumers and users too because ideally that means they’re getting much more better much better products out the gate.
Building Before and After AI
Vibhu [01:01:32]: Does it mean your teams are smaller?
Akshay Nathan [01:01:33]: I think there’s much more to do now. So I think people can accomplish more individually or in a small team than they were that would require more people than before. But there’s, at the same time, there’s also more to do, so I think the teams are much more ambitious.
Vibhu [01:01:50]: Have you seen any changes in scopes of roles and building teams and how we used to have teams, say, a few years ago versus what ideal teams look like now?
Akshay Nathan [01:01:58]: I think we’ve seen a blurring in the lines between, like, the typical product development functions, like between, like, EM/PM, engineer, designer, et cetera. Like
Vibhu [01:02:08]: Yeah, I wanna bring up this quote. There will be, only four jobs left in tech. There’s AI slop cannon, the people who just, like, they’ll burn a bunch of tokens. And then there is SRE, the people who. people who are more responsible. There’s grown-ups who sell things, and then there’s hot people.
Akshay Nathan [01:02:27]: This is an interesting take. I think my suspicion is that there’s everything everyone will be, like, shaped in a way, in that, like, AI will enable everyone to become a generalist. Like, things that, like, I never would be able to, like, come up with a design before and, like, even now, like, I don’t have maybe, like, the visual taste required, but I can iterate on something with the help of AI. But then people will have a specialty, and that’s, like, the straight line in the T or the upward line in the T. And so, like, you can have a specialty that you’re interested in. With the help of AI, you can go deeper and become better at over time, but then you’ll also be a generalist. And so with that foundation, the way you can accomplish is, like, almost limitless.
Team Shape, Shaped Builders, and Taste
Vibhu [01:03:07]: What are you bottlenecked by in terms of specialties? Like, do you need more designers? Do you need more slop cannons? Do you need more hot people?
Akshay Nathan [01:03:15]: I think the bottleneck some becomes, like, ideas and taste. I think because anyone can build now, I think, it really is the era of, like, bottoms-up ambition. And because there’s so much to be built, like, you’re always gonna be bottlenecked by, the amount of ideas and amount of things that you’re doing at any given time.
Vibhu [01:03:37]: Do you think models help solve that?
Akshay Nathan [01:03:39]: Models?
Vibhu [01:03:40]: Yeah. I have the example of, like, I have a front-end design skill that’s like, they give me four drastically different examples of what this looks like. Sure, it burns a lot of tokens, but. And then I’ll mostly just condense down, “Okay, I like this part. I like this part. Let’s draw these together.” And it’s like, yeah, I had a vision, but, like, I don’t know.
Akshay Nathan [01:04:01]: I would say that the one automation that I would love to work and it doesn’t work is bring me new ideas, right? somehow LLMs are just not it. One interesting part about ideas is, like, they’re not, like, in a vacuum. It’s, like, not. They usually come from somewhere and, like, in product development, like, they’re coming from talking to users or reacting to, friction that you’re seeing or feedback, building on some foundation that you already had planned out before, whatever. And so I think that’s where, like, I think there will always be value in these, like, generalists that we talked about, like, closing that loop and then having coming up with those ideas that are grounded in that feedback or talking to users, whatever it is.
Defining and Measuring Productivity
Vibhu [01:04:41]: Cool. You were gonna. You lead the productivity team. How do you define productivity?
Akshay Nathan [01:04:46]: I think our mission is to make it possible for people to do things that they weren’t able to do before. And right now we’re thinking about it from the perspective of knowledge work. And so when I look at knowledge work, I think about people are no longer siloed by their roles. They’re no longer siloed by maybe the, background or training that they have. Like, no matter what function you’re in, you can suddenly build things. You can suddenly get access to data that you otherwise might not be able to interpret, et cetera. And then I think that extends to your personal life, where we want to give you leverage at the end of the day. Like, we want the models and the product to be able to give you leverage so that you can, create time for yourself to do the things that you love.
Vibhu [01:05:25]: Does that also translate to a way to measure productivity? Like, what is new?
Akshay Nathan [01:05:29]: The end is
Vibhu [01:05:30]: How do you measure leverage?
Akshay Nathan [01:05:31]: I think we haven’t figured this out yet. Part of the reason is it’s so diverse. Everyone has different goals, and really the true measurement is, like, their ability to achieve that goal. Did we help you or did we not?
Akshay Nathan [01:05:44]: And it’s very difficult without knowing what that goal is up front and also tailoring it for every individual.
Vibhu [01:05:48]: And the thumbs up and thumbs down from ChatGPT doesn’t give you anything, right?
Akshay Nathan [01:05:52]: You don’t know if they’re thumbs downing the content of the answer, the vibe of it
Vibhu [01:05:56]: Oh, yeah
Akshay Nathan [01:05:56]: Whether or not it helped them with their goal. I think that’s difficult. But it’s something that I think we will need to figure out and the industry at large will need to figure out because, that’s how we measure success, if this is what we’re, we’re
Vibhu [01:06:06]: Do you think it’s changed, productivity and how you measure it? you said there’s a lot more work that can be done, a lot more scope. has it changed?
Akshay Nathan [01:06:15]: I think it was always true that what you really wanted to measure is, like, was your team, was the individual, were you personally able to hit the goal, or are you closer to hitting that, whatever your goal is, right? But I think previously we used proxies for this. So, like, code commits or
Vibhu [01:06:31]: Lines of code
Akshay Nathan [01:06:31]: Lines of code or whatever.
Vibhu [01:06:33]: Story points.
Akshay Nathan [01:06:34]: Yeah, exactly. Story points. And, like
Vibhu [01:06:36]: They’re coming back, by the way.
Akshay Nathan [01:06:38]: maybe. But that is for a part of the change. And, like, I think with AI now, those proxies starting to fall apart. Like, you, the number of tokens you use or the number of pull requests you make are, like, no longer, like, maybe as hypercorrelated with that, is your team able to hit the goal or are they on track to hit their goals? So I think we’ll need to come up with new, measurements.
Vibhu [01:07:02]: For the managers listening, give them one thing to try.
At-Bats, Motion vs. Progress, and Closing
Akshay Nathan [01:07:06]: I think for me, what’s important is like at-bats. Are we as a team building the muscle to have not just quantity of at-bats, but quality? Like, are we able to go all the way from, like, generating an idea, building it out, getting the feedback, reacting to that feedback, validating or invalidating the hypothesis, going on to the next idea? Are we able to do that really efficiently? And like, that goes to like, the actual like code that’s being written or the designs that are being made or the specs that are being written, whatever, but also the culture of the team. Like, do we have the humility and, are able to like go through that process many times and stay motivated and excited throughout that? so that’s the thing that like I think is important now, especially when we’re on the frontier of this technology and like there’s so much to build, there’s so much to do. That’s probably the most important thing that we look at.
Vibhu [01:07:54]: Any traps people fall into around measuring productivity with your teamwork on. I feel like there’s a lot of, okay, we added a lot of LMs. We have dashboards for this and that, but not much has changed, right?
Akshay Nathan [01:08:06]: That is the trap, yes.
Vibhu [01:08:09]: And the broader source of the question is for the managers and teams building, how should they approach this?
Akshay Nathan [01:08:18]: I think maybe the trap is like conflating motion and progress. I think motion is much easier now than ever before because of the tooling that we have. But progress requires you to be like very prescriptive and deliberate about like what you’re trying to achieve, and it goes back to our question of measurement, right? Like you wrote we were talking about like, can we, OpenAI, like figure out how to measure productivity for our users? That’s, that’s a very hard problem because of the diversity. But like as a team, like you should have a really prescriptive and deliberate view on like what progress looks like for you and for your team. And if you don’t have that, then it’s very easy to conflate these two things.
Vibhu [01:08:57]: I think at-bats is a really great thing. I’m, I’m really glad. I like the discussion between motion and progress. I think that’s a quote that we’re gonna feature on the write-up. You’ve been very generous with your time. Thank you so much and congrats on ten million.
Akshay Nathan [01:09:08]: Yeah, thank you for having me.
Vibhu [01:09:09]: The next one at a hundred in two months. Two weeks. Thank you.


This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit www.latent.space/subscribe

In recent months, the open vs closed, and US vs China discussions on model ownership and sovereign/local AI have heated up to a fever pitch. So it is very very good news that Poolside AI are finally emerging with new models, like Laguna S 2.1, that are beating Thinking Machines’ recent release nearly 10 times their size.
Poolside’s recent tech report got a lot of praise due to their level of detail, and Vibhu first covered Laguna’s recent technical report on our paper club:

From spending $12 million building language models for code before the world cared to creating a Model Factory that can take a model from pre-training to release in eight weeks, Eiso Kant has spent more than a decade betting that code is the path to AGI. In this episode, the Poolside co-founder joins swyx and Vibhu to explain why ChatGPT felt like vindication, why Poolside embraced open weights and open research, and why he would rather live in a world with 100 foundation model companies than five even if Poolside were one of the five.
We go deep on Poolside’s Model Factory: the engineering systems behind 10,000–20,000 experiments per month, streaming data directly into training, reproducible experimentation, low-precision compute, and agents that increasingly write code, launch jobs, evaluate results, and modify the pipelines used to train future models. Eiso also unpacks their recent launch Laguna S, why persistence, verification, and backtracking may matter more than raw intelligence, how much capability remains inside smaller models, why reinforcement learning will move earlier into pre-training, and why next-token prediction is still extracting too little from the web.
We also discuss model-harness co-design, Poolside’s path from coding agents to AGI, why Eiso thinks MCP and traditional tool calls are “stupid,” the real economics behind frontier-model training, Poolside’s $500 million raise, open-source AI, regulation, NVIDIA and TSMC’s influence, engineering productivity in the agent era, high-agency teams, and hiring at Poolside.
We discuss:
* How Andrej Karpathy’s RNN work inspired Eiso to start building language models for code in 2015
* Why Eiso spent four years and $12 million pursuing an idea before the market cared
* Why ChatGPT felt like vindication and brought Poolside back to open source
* Why Eiso would prefer 100 foundation model companies over an oligopoly of five
* The difference between releasing open weights and publishing genuinely open research
* Why Poolside deliberately built a global research organization outside the Bay Area talent war
* Why model building is ultimately 90% engineering
* The Model Factory: Poolside’s end-to-end system for rapidly training and improving models
* How fewer than 70 researchers run roughly 10,000–20,000 experiments each month
* How Poolside moved from six-month model cycles to five- and eight-week launches
* Why streaming data directly into training unlocked faster experimentation
* How immutable data, versioned code, and reproducibility enable rigorous model research
* Why Eiso wants capable researchers to leave their labs and become Poolside’s competitors
* Why 95% of model building can be reduced to better data or compute efficiency
* Laguna S and why persistence, verification, and backtracking can outperform raw intelligence
* Why smaller models may handle far more knowledge work than previously expected
* Why reinforcement learning will move earlier into pre-training
* Why next-token prediction is still failing to extract enough knowledge from the web
* Why distillation and environments have become the AI industry’s favorite “drugs”
* Why mid-training is really an early form of curriculum design
* Low-precision training, networking bottlenecks, and the next gains in compute efficiency
* Laguna S: 118 billion total parameters, 8 billion active, and eight weeks from training to launch
* Why model builders can often evaluate a new checkpoint within its first 30 minutes
* Model versus harness: where agent capabilities actually come from
* Why Poolside sees coding and long-horizon software tasks as a path to AGI
* Why Eiso thinks MCP and traditional tool calls are “stupid”
* Why future agents will write scripts instead of choosing from dozens of predefined tools
* The case for minimal harnesses, containers, and model freedom
* Why Poolside is prioritizing vision but does not expect to work on audio soon
* Why language may be the most compute-efficient modality for encoding knowledge and reasoning
* The real cost of model development and why the final training run is anticlimactic
* The story behind the Poolside name and why it represents refusing to lower ambitions
* How Poolside raised $500 million while investors still questioned whether AGI was real
* Why intelligence could become the world’s most demanded and commoditized resource
* When open models may become too capable to release without restrictions
* Why unilateral AI safety does not work in a globally competitive environment
* How regulation could accidentally lock in an oligopoly of two or three AI companies
* NVIDIA, TSMC, and the hardware systems underpinning foundation-model progress
* Why reinforcement-learning wall-clock time is one of Poolside’s biggest bottlenecks
* Why Poolside trains models from scratch instead of simply distilling larger models
* How AI changes the way companies should measure engineering productivity
* Why agency may become the most important quality for employees in the AI era
* How leaders align high-agency people through shared goals and clear constraints
* Hiring across research, post-training, pre-training, architecture, evals, and engineering at Poolside
Eiso Kant
LinkedIn: https://www.linkedin.com/in/eisokant
X: https://x.com/eisokant
Poolside: https://poolside.ai
Timestamps
00:00:00 Introduction
00:00:54 Karpathy, RNNs, and Building Code Models Before Transformers
00:02:26 The $12M Failure and ChatGPT Vindication
00:03:39 Open Source and the Case for 100 Foundation Model Companies
00:09:22 Open Weights, Open Research, and Poolside’s Global Team
00:16:04 The Model Factory: Why Model Building Is 90% Engineering
00:20:19 Agents, Automated Experiments, and Early Signs of RSI
00:24:04 Streaming Data, Reproducibility, and Scientific Rigor
00:30:35 Creating More Foundation Model Companies
00:36:07 Laguna S: Persistence vs. Raw Intelligence
00:43:01 Reinventing Pre-Training, RL, and Curriculum Design
00:52:33 Low-Precision Training and Squeezing More From Smaller Models
00:58:37 Model Harnesses, Coding Agents, and the Path to AGI
01:09:26 Why MCP and Traditional Tool Calls Are “Stupid”
01:13:04 Vision, Multimodality, and Why Language Still Matters
01:18:15 Scaling Models and the Real Economics of Training
01:20:40 Why Poolside Is Called Poolside and Raising $500M
01:27:37 Open Models, AI Safety, and the Risk of an Oligopoly
01:33:53 NVIDIA, TSMC, and the Reinforcement-Learning Bottleneck
01:41:52 Smaller Models, Distillation, Engineering Productivity, and Hiring
Transcript
Introduction: Eiso Kant, Poolside, and Open Models
Swyx [00:00:00]: All right, we’re here in the studio with Eiso Kant from Poolside, together with Vibhu. Welcome.
Eiso Kant [00:00:08]: Thanks. Thanks for having me, guys. Good to be here.
Swyx [00:00:10]: Yeah, fresh on the plane. You texted me, you were like, “Hey, I’m on my way to SF.” I was like, “You’re on a plane right now, right?” Like, hey.
Eiso Kant [00:00:16]: I know. After I texted you, I realized that probably coming in with major jet lag was gonna offer some fun experiences today, but let’s do it.
Swyx [00:00:23]: I mean, I think the thing I would tell guests is that they don’t have to prepare that much because if you’re truly working on this every single day, then even, like, what you hazily remember is going to be new for a lot of the audience that don’t live in your world every day, right? so 10 years ago, you did a talk at Google Slush, talking about the democratization of AI. and, now here you are, like, open sourcing an incredible new model that we’re gonna talk about. But I guess, like, what got you into democratization of AI? Like, it’s not obvious from your LinkedIn or something.
From Karpathy’s RNN Post to Sourced
Eiso Kant [00:00:57]: No, it’s not at all. I don’t think it’s obvious how I got in this space. I owe getting into this space to Andrej Karpathy.
Eiso Kant [00:01:05]: In 2015, he wrote an article called “The Unreasonable Effectiveness of Recurrent Neural Nets.”
Swyx [00:01:10]: Neural Nets, yep.
Eiso Kant [00:01:11]: And that article, I read it, and I pivoted my startup at the time overnight to working on RNNs, and later LSTMs and Transformer models to be able to write code. If you go to this article and you scroll down, you can start seeing, like, this was the precursor to what ended up becoming language models. So, at least when he was character-level language models that were starting to predict letters, he has an example out here. There’s a little Paul Graham generator, and you can read it, and the text makes sense, but it doesn’t. and there’s a little-- There’s an example of code a little bit further down. Yeah, so Shakespeare.
Swyx [00:01:47]: Shakespeare.
Swyx [00:01:49]: Cool
Eiso Kant [00:01:49]: And for some reason, I read this, and I went down the rabbit hole of learning everything I could about RNNs and LSTMs, right? This is Transformer paper. And I had built a completely unreasonable belief, that neural nets should be able to generalize to anything and everything, and that language should be able to generalize, to a lot of things that are intelligent and the ability to write code. And so I started building Sourced, which was a fully open source company trying to build, what we used to call machine learning on code, language models on code. And we spent about four or five years on this, till the end of 2019. And that sounds really cool today, but back then, no one cared.
Eiso Kant [00:02:29]: Right? Like, no one cared. We were in the dark. Like, we did things along the way. We tried applying convolutional neural nets to, like, the structure of code. We were. when attention came out, we were applying it to LSTMs, and then the Transformer paper came out. And it - it wasn’t obvious, and what we missed throughout that entire journey, that we were on the right track, but we should have just kept scaling up. And today, to all of us, the scaling laws and scaling up seems like the most obvious thing. But having spent four or five years of my life on working on language models on code, it wasn’t obvious. So I have a lot of respect to folks at Google and OpenAI and others who took that confidence and kept going. we failed ultimately at the time, and it was, like, biggest failure of my career, right? You blew $12 million of investors’ money, which was a lot back then.
Swyx [00:03:18]: Yep.
Eiso Kant [00:03:19]: You spent, still a lot, but, And you spent years with, like, a group of 40 people just obsessing over this problem. And life took a different turn, And it was, and family became a focus, and I kept my heads down and really, didn’t really look at language models for the following two years. big mistake considering Following years are gonna be really interesting. And then ChatGPT came out And it was like a vindication. It’s like people started texting me. I found, like, my old, work decks and these old talks. And throughout that whole journey, we,
ChatGPT, Vindication, and Returning to Open Source
Eiso Kant [00:03:56]: We really had a strong point of view at the time that, like, as you’re building more capable intelligence, it should be open and open source.
Eiso Kant [00:04:04]: When we started Poolside, that wasn’t the case at all, and I wanna be very open about it. When we started Poolside, we were like, there was a premise of two things. One is this technology is not gonna stop compounding in capabilities. I think to most people obvious today, but three-plus years ago when we started, most people were still arguing if these were stochastic parrots or not.
Eiso Kant [00:04:23]: And the second was that reinforcement learning was gonna be the biggest driver for LLM capabilities. Today, very obvious. Three years ago, was not an opinion held or direction held at either OpenAI or Google or Anthropic or others. And so people looked down on us a little bit. They were like, “ is this really gonna work?” And so we just started working the problem, and we never really thought about open source again. We just kept our heads down and we built our, like, knowledge, understanding from scratch, right? We didn’t roll out of an existing lab. So we picked up the papers and started writing code and figuring things out.
Eiso Kant [00:04:59]: And it wasn’t until the beginning of this year that me and my founder, Jason, picked up the open source conversation again.
Eiso Kant [00:05:07]: And if you go back to some of the early things on our website, it was very straightforward. It was we wanna get to AGI, we wanna support a world of abundance, and we wanna be the first company that gets there.
Eiso Kant [00:05:20]: But we started talking at the beginning of this year because it became obvious that the world was going in a direction that was starting to like, pick at us a little bit. Like, it didn’t, this didn’t happen overnight. It was, like, a little bit we were seeing this and we’re like, “Okay, The world’s going down a path.” And Throughout this journey, there was something that I used as a, as an analogy or thing. So I said well, if I go back to back in those days, 2015 or 2016, we’re working on this, and I picked up a fi book off the shelf, and I was reading the book about 2035. AGI is achieved, and the story would be over the following, decades. And it would have that first chapter where everyone’s trying to figure things out. You’d get the chapter of ChatGPT coming out And then you would get to the chapter where the world was at a fork in the road, and the one that it picked was one where three or four or a handful of companies were going to create all of intelligence moving forward.
Eiso Kant [00:06:21]: And when I thought about that story, it felt like a dystopian fi book, not a utopian fi book. And the reality is, I’m a utopian fi guy. Like, and so We took a step back and said, “Hey, can we play a role here?” Now it was easy for us to do so because we were not at the frontier.
Eiso Kant [00:06:41]: If we were at the frontier, I don’t think we could have changed our mind. and I don’t mean this like it’s when the moment there’s too much capital involved, too much expectations, you’ve built up things, right? We’re a small team, just improving and improving. And so we knew that we could make that decision now, but it would be a lot harder to make as we got closer and closer to the frontier and caught up to others. And did a lot of soul-searching and a lot of conversations, and said, “No, this makes sense,” Even if there’s big unanswered questions, like how the hell do you build a business model with foundation models about open source? Big open-ended question that we do not fully have the answer to yet, right? At what point do you no longer wanna release open source models because misuse of models has, real potential risks associated with it? how is the government gonna respond to open source? but I think it all just came down to one thing, and I’ll stop the monologue, is the fact that I rather live in a world that has 100 foundation model companies than a world that has five, even if I was one of the five. And the smallest and most meaningful contribution we can make for 100 to exist is to open up our research and open up, like, our weights right now and figure out along the way how we can, like, do more.
Neo-Labs, Model Choice, and the Token Economy
Swyx [00:08:01]: Yeah. I think if anything, over the past three years, that has become a bit more true. you are one of a cohort of Neo labs
Eiso Kant [00:08:10]: Yeah
Swyx [00:08:10]: That people are now calling that. And, we’re, we’re doing this on the day that Thinky launched their, new model and you are outperforming them on their, on some benchmarks that they released, right? Like, they just don’t have it yet. so it goes to show that I think, like, this is one of those things where, like, there is room for multiple players, and you are seeing a little bit more of the future. Maybe more like 20, not 100, but, like, you are one of the 20.
Eiso Kant [00:08:36]: I really hope so, right? I think we I’m, I’m excited about their release, and I’m excited about everyone releasing because, like, ultimately, like, choice competition is both gonna drive progress in the right direction. But the fact that like, we create models and while we all, drink out of the same well of data effectively, we do introduce very different behaviors and biases in our models. Some are intended biases, some are completely unintended biases.
Swyx [00:09:03]: Yeah.
Eiso Kant [00:09:03]: And if we shape up in an ecosystem in the world where open models are gonna be a part of the token economy, like, I don’t think there’s any question about it anymore Then we want to be able to live in a world where companies, countries, people can choose and say, “Hey, I am most aligned and I trust most this provider for these things.”
Swyx [00:09:25]: Yeah.
Vibhu [00:09:26]: I think more than just one of the 20 Neo labs, up until recently, most of open source innovation was coming from the Chinese labs, right? So there’s the DeepSeek of the West. Is it today? Okay, maybe it’s thinking machines reflection, but there aren’t many, right? So, one of the things you guys started in France, Europe, but very much now you’re taking that American standpoint and more than just that, the point is the Chinese models that we see, they’re not super open research. the work you put out is, I think, some of the best. So every few months you get not only frontier models, but also here’s a breakdown blog, paper, technical report of here’s everything for state of the art to build, frontier intelligence and you’re filling that gap too, right? So not just only open weight, not just Western, but also pretty open research.
Open Weights vs. Open Research
Eiso Kant [00:10:20]: No, I appreciate it. Look, I think it’s, I think it’s the most meaningful contribution, right? Weights are a binary. Let’s call them what they are. Yes, we can modify them, we can change them, but, like, giving someone the weights does not allow them ultimately to recreate what you’re doing, right? And so now there’s challenges around releasing data sets, challenges around like releasing certain things, but being able to share your research, like, right, how do we do it? What are the lessons we learned that we spent, tens of thousands of experiments of compute on? I think very much so. One correction though, Vibhu, and I say this because it’s been haunting us for quite a few years. We from day zero were an American company.
Swyx [00:10:55]: Yeah. They moved
Poolside’s Global Team and American Company Story
Swyx [00:10:56]: To France.
Eiso Kant [00:10:56]: So the story once and for all is very. We start as an American company. We have always been an American company, and early on we made a very conscious decision. We said, “We’re not gonna hire any researchers in the Bay Area. We’re gonna look for talent everywhere else in the world.” and that is everything from Middle Americas, Seattle to, Serbia, and to Taiwan and Singapore and other places. And it was because we took a view that this was gonna become a talent war for this, and I think it has over the years now. Three years ago, that wasn’t fully obvious yet. I think today it very much is. And we also realized that, like, some of the world’s most capable people with, like, the most interesting, innovative ideas were not just gonna be here. And so it led us to create like a fully remote company. and we ended up opening an office in Paris and London and different places and we have a lot of the team in the US and a lot of team outside. But we always took this view of like, we’re an American company, but if we want the best of the best to work with us, we need to take a global view. Now we do also have people here in Silicon Valley, like the company’s grown and others, but I think one of the things that, it slowed us down at the beginning, but it has sped us up now, and it’s why you’re seeing like the progress, I think, on our models and the cadence at which we release, is because we didn’t roll out of an existing lab. Right? we didn’t, we didn’t have a lot of the information that’s freely flowing around here at the time. We just took this point of view as like, “Okay, well, let’s just work the problem. Let’s just go and, like, read the few papers that are out there, and let’s just figure this stuff out.” And we made some hilarious mistakes in model training because of that over the years
Eiso Kant [00:12:35]: Like especially in the first 12 months. there’s a few that I think still haunt me and scare me. We can talk about them later. but it created a, like, a resiliency and persistency in the team, right? with extremely few people have left us over the years, that, like, told us, “Okay, we can do this.” When we first wrote our first training code base completely from scratch, it wasn’t a fork of any open source. It was just like, “Okay, let’s build it from scratch.” I remember we had this one moment where we spent three weeks working out an optimizer bug. Like, it was like training just couldn’t get stable. We, like, obsessed over it, and we thought, like, maybe we were wrong. Maybe we should have just forked this repo, or we should have. But then when we solved it, I still remember at the time we were like five people in the company. when we solved it, we were like, “Oh, we can do things,” like if we’re just willing to work hard. and I think that culture with a very strong engineering bias has helped us, like, get to where we were. And so there’s this notion of open source and talent and these things. I think we, We just took different decisions from a different starting point. and I think we are lucky. I do want to definitely call it lucky. And there was a lot of hard work at the team that now, like, that’s starting to show up in results.
Swyx [00:13:52]: Just ‘cause we probably won’t revisit this again, but, and this is a fun recruiting challenge if someone knows the answer. What was the bug? And then we won’t tell the solution, but we’
An Optimizer Bug and the Value of Building From Scratch
Eiso Kant [00:14:01]: So the - This - You’re gonna test my memory here,
Swyx [00:14:04]: Oh, okay
Eiso Kant [00:14:04]: So but I think
Swyx [00:14:05]: Directly
Eiso Kant [00:14:05]: I think I can recall. So if you, so if you look at, So if you take like Adam as an optimizer, you have epsilon
Swyx [00:14:12]: Yeah
Eiso Kant [00:14:13]: Which is, right, like in the denominator
Swyx [00:14:14]: Momentum and weights. Yeah
Eiso Kant [00:14:15]: Is exactly, in the denominator. And at the time, if I recall, you looked at like the early Llama papers and things like that. People were juicing epsilon, like, quite a bit. Like, they were, like, adding, I don’t know if it was E minus four or whatever, like a high value for epsilon.
Eiso Kant [00:14:31]: And if you think about this during training, it’s like a bit weird and counterintuitive that we’re adding noise to our optimizer by just adding effectively, like, a random number in the denominator, right? Like behind the decimal point. And I don’t recall the exact bug, but it had - What I remember is once we solved it, we no longer had to juice epsilon as much as, like, was happening in the Llama paper and other places. and it was like one of those fundamental moments where we had trusted this paper that was out there, and we’re like, “Oh, no, it has to be this way. It has to have this high value of epsilon.” But it made no sense to us intuitively. Like, why do you have to have this so high? Like, if you’re just trying to avoid division by zero, why can’t the value be extremely small? and that was like one of those moments where you realize like, okay, finding things out from scratch yourself builds a better intuition. Because the one thing you learn very quickly with model building is that your intuitions that you start with are gonna get beaten up so hard.
Eiso Kant [00:15:33]: Right? Like - It’s such an experimental science, that the things that seem obvious, you very quickly get to learn, like, you were wrong, and hopefully you figure out why, and sometimes you don’t even.
Swyx [00:15:45]: Yeah. yeah, so, one of the reasons that you, when you released your new models, Vibhu got really excited. I mean, everyone got really excited. But Vibhu led our paper club on it, and you guys saw
Eiso Kant [00:15:58]: Yeah
Swyx [00:15:58]: Obviously. maybe talk through some lessons learned in that, whatever you can disclose. we can focus on the model factory stuff, whatever you think is a good starting point.
Model Building as Engineering
Eiso Kant [00:16:08]: So I would say that our view from very early on in the company was that model building is ultimately 90% engineering.
Eiso Kant [00:16:18]: And I think we all know it in the industry because if you look at where’s every researcher spending their time, they’re spending their time writing code, right? Looking at data and writing code. And so we said, okay, The state at the moment, like three years ago, was bash scripts and Slurm and spaghetti code bases for training and, like, data pipelines that were patched together. And we looked at this and said, “Well, ultimately, model building is a process.” You’re going from raw data, right? Like training raw material, the web, et cetera. you’re doing a whole bunch of filtering, cleaning up, transformations, analyzing. These days, that’s, far more complex than it was three years ago. then you’re training a model, which is effectively a large distributed systems problem, right? Across hardware that has still-- It’s become a lot more reliable. It was extremely flaky back then. and now with every new generation, we get our new sets of challenges. And then you go into the next stages, right? There was no training back then, but, like, you got, your post-training and then your reinforcement learning. And so we looked at this and we said, “Well, this looks like an industrialized process. This looks like an end process, that every single part of it has its machinery,” right? If it’s your big data pipelines, if it’s your crawling ingestion of the web, if it’s your, large-scale distributed training, and then you’ve got your reliability. And we said, “Well, why don’t we take some of the world’s smartest distributed systems engineers that we knew and make them part of the process of research from day zero?” Not retrofitting it later on, but, like, really from the beginning. And that became our model factory. And so our model factory started with a handful of components. Today, it’s thousands of components, and I try to equate it to, if you think about, like, someone who was at the very early days of Foxconn, if they had been there for the following, decade, they would be able to rebuild Foxconn because they saw every decision that led to building that system and all the complexity. If you and I walk into Foxconn today, no chance.
The Model Factory and Experiment Velocity
Eiso Kant [00:18:18]: Right? Because we don’t have the lineage and history of decisions that led to that. And so we built early on from the beginning- with a team that really understood that, well, the metric that we are optimizing for is the speed of an idea from a researcher to an experimental result that we can trust to then being part of the next model training.
Eiso Kant [00:18:42]: And in the. And because it’s such an experimental science, ultimately, in the beginning when it wasn’t that complex, you could patch your way around it, right? But now, at any foundation model company, you are running. I mean, we’re a small team, right? We’re less than 70 researchers, another 35 engineers. and we are running, I haven’t checked the latest count, but far more than 10,000, maybe 10 to 20,000 experiments a month that we cut. And so if you look at that scale of every model run that is, like it’s ultimately it’s, it’s you need to be able to trust it as an infra problem. And so what we have now done over the years is gotten really good at that, and just by working it and improving it and obsessing over those end decisions. So now what that means is that you looked up Laguna XS 2 that we launched. It was five weeks from the beginning of training to launch. The model that we’re gonna talk about today was eight weeks from start of training, to launch. We started the next model literally yesterday because we now finished the post-training required for the model we’re launching, next week or by the time this comes out today. and we move that compute to the much larger Laguna M model that we’re now training. And so the model should be an artifact of someone’s process. It shouldn’t be really a thing in itself. Like, and we treat this like the way you would look at like a SpaceX factory where, yes, the first rocket, really hard to build, but the much harder challenge was building the factory. And now they’re rolling off, and no one is really thinking about the next launch anymore. So it’s just another launch, it’s another launch, another rocket comes off. And that’s what we’re trying to do with model building.
Eiso Kant [00:20:22]: And what has been, which was not planned from day zero, it was in the back of our mind like this will happen one day, is that when you build a really good end model factory with really good APIs and really good engineering systems, Well, what is it perfect for? It’s perfect for agents.
Agents Inside the Model Factory
Eiso Kant [00:20:40]: Because agents are now starting to take over more and more work in our model factory.
Vibhu [00:20:43]: Yeah.
Eiso Kant [00:20:44]: So I look at the screens when I walk, like when we’re, we come together, in our monthly, we do monthly onsites, and I walk behind people’s screens and I stop by and I talk to our researchers. And the default is all of these different agents running on their screen that are writing the code. They’re launching the jobs. They’re evaluating the results that are coming back from the model runs. They are, making the changes. And we’re still in the driver’s seat. We’re still coming up with the ideas. We’re still helping with the debugging. But more and more, and this is right now very profound on the data side of our pipelines in both pre and post and the synthetic data pipelines, it’s starting to become more on the architecture side as well. You’re starting to see these twinklings of what RSI is gonna look like.
Eiso Kant [00:21:27]: And that’s. So when we talk about, like to your question about our models, every talk about the model factory, And my coolest example of these things is always that when we kick off a new run, doesn’t matter if it’s a training like big run or if it’s now a post, like one of 10 post-training versions we do for like release or many experiments, is that at any given moment, the changes that somebody made that they had experimental results from the day before make it into that run.
Eiso Kant [00:21:57]: So there’s not like a cutoff 90 days before. Like no, it’s like literally from that moment because we can now trust the machine enough. And then you also have to invest in the reliability. So one of my favorite metrics about like Laguna S is that there was no call events, Right? Like completely zero. And we haven’t had a meaningful call event, like something to wake up for, as far as I recall this entire year. now there is one asterisk to that. In usually the first six hours of launching a new model run, something breaks because you set a config wrong, you made a small mistake, et cetera. So that’s usually there’s a little bit of intervention, but that’s always within like call periods, right? Not on call. And I think that’s starting to now compound. So the model we’re releasing now, I love it. It’s amazing, but we’re already onto the next one. and I think that’s the way it should be.
Laguna, Five-Week Builds, and Zero On-Call Events
Vibhu [00:22:50]: Hey, I also just wanna point out, so for context, this was like a month ago. we found it in the tech report, so we just came in with, “Okay, new model’s dropped. Haven’t heard about it.” We were
Eiso Kant [00:23:02]: Yeah, we’re very used to doing this every few months.
Vibhu [00:23:03]: We’re, we’re very much like, “ okay, look, it’s like, on par with Kimi, DeepSeek, whatnot, the small ones, Gemma level. Oh, it’s a very cool paper on what goes into building.” And then we hit this page, right? Like literally page two of tech report is, “This process allowed us to build the small model from scratch to delivery within five weeks applying the lessons”. And then I’m like, oh, this paper is not about here’s a tech report of benchmarks and here’s how many tokens it was trained on. Like for people that wanna dive more from what we’re not gonna discuss on the podcast, it’s all laid out here, right? From
Eiso Kant [00:23:38]: Yeah
Vibhu [00:23:39]: Custom software that agents can use to interface with training code, training data.
Eiso Kant [00:23:45]: Yeah. Well, link the paper correctly, so yeah.
Vibhu [00:23:47]: Yeah. All that stuff. read the paper here, but,
Technical Report Principles and Streaming Training Data
Eiso Kant [00:23:50]: But I would like to. I love principles, and I think that is a good starting off point for maybe telling some stories. Maybe we can go one by one past the principles. I’ll just call out that Dagster just got bought by a Prefect.
Vibhu [00:24:01]: Yeah.
Eiso Kant [00:24:01]: Isn’t it fun? But yes, I’m very familiar with Dagster. just anything where like they trigger some story.
Vibhu [00:24:07]: So, well, I would say, well, experiments code’s obvious, but I think one of my favorite things is, I don’t know where it is in here, but early on, and I still think this is the case a lot of foundation model companies, people prepare their training data sets, they get packaged up, then they get copied over to a training cluster distributed across all of the nodes, and then training starts.
Vibhu [00:24:30]: And we looked at this like three years ago and we were like That makes no sense
Eiso Kant [00:24:36]: You lose so much time because the moment you have to rematerialize the data set, you have to make a change, you have to fix something, et cetera, you’ve got all this time of like repackaging it, right? Toca- tokenizing it, repacking it, moving it over to a cluster, then distributing it across the nodes. The bigger your clusters are, you start using fancy like torrent-like algorithms to like distribute your data. So why aren’t we streaming data into training? Right? Something that’s very common and like just basic
Vibhu [00:25:00]: Like just in time
Eiso Kant [00:25:01]: Just in time, like good computer science like principle. And that was one of the first things that I think unlocked - the model factory. Because the moment you start thinking about, well, a training job, it doesn’t matter if it’s a big hero run or a small like, post-training experiment, consumes a certain number of tokens per second, right? And it’s not a lot, right? From a like a data, moving data perspective. So we said, well, we have our training cluster, and then we’ve got like our AWS kinda setup where we can build these amazing big data pipelines. We can set things up. We use Spark underneath the hood, like all these things.
Vibhu [00:25:36]: But when you say AWS, it’s not actual AWS, it’s your internal AWS.
Eiso Kant [00:25:39]: It’s our internal-- No, it’s our internal like just running like our infrastructure
Vibhu [00:25:42]: Site web services
Eiso Kant [00:25:43]: Exactly. Our stuff running on like an AWS account or on like any hardware, right?
Vibhu [00:25:47]: Yeah.
Eiso Kant [00:25:48]: And so once we made that shift into I can stream data into training, all of a sudden you realize a lot of things unlock. Because now you don’t have to wait for the whole data set to materialize.
Immutable Data, Experiments as Code, and Scientific Rigor
Eiso Kant [00:26:00]: You now all of a sudden when you’re running data experiments about mixing data, it’s a config. Because you’ve got these data sources that are coming in, and you just - we have this service called Blender that’s in the report, where we then say, “Okay, for this run, I want 20% of this source, 10% of this source. I want this much, so many epochs of repetition. I want this to be, shuffled in a certain way,” and your training job can start while the rest of the data is even still materializing. also what it does is because all of this underneath-- So for us, we treated the data layer underneath as like an immutable data layer, and that was really important. Like experiments as code, immutable data layer means that you can always go back and understand literally down to the single token at which cursor it went in on which version of the code.
Vibhu [00:26:47]: Yeah.
Eiso Kant [00:26:48]: And it took us a I have to admit, like the first year of Poolside, we understood that engineering had to get great, But we didn’t understand yet, that this is ultimately in support of like a good rigorous scientific progress. We were quite a - We were a very small number of people, so a lot of it was YOLO ideas and YOLO runs.
Vibhu [00:27:08]: Yeah.
Eiso Kant [00:27:09]: And we built great infra for the YOLO runs. But once we realized that we treated data as immutable and code as always versioned, and you could always track and trace every experiment end to end perfectly, you could repeat everything perfectly, right? You have perfect reproducibility. I can still reproduce runs from two years ago if I wanted to, right? It enables the scientific progress, like the scientific process, and I think that took us probably about a year and a half into the company to figure out. We also had some great hires, like our head of applied research, Nikolai, who joined us from Yandex, who’d been working on language models since like the early 2020s, I think brought that into the company of like, “Hey, we wanna have even more rigor.” And then once we kinda had the combination of like increasingly more capable platform that allowed people to do more, but had this immutability, we were able to start “Okay, every experiment is truly an ablation. We truly need to understand it.” And I think we became much more scientifically rigorous in the last couple of years, and the infra underneath enabled it. and then there’s just fun stuff like, and
Vibhu [00:28:16]: Yeah, a lot of it’s fun, like even just the, one, you share all the ablations, two, picking the data sets, right? There’s like a random small paragraph in here where it’s just like, “Oh yeah, training data, we have some, we have an auto mixer.” it trains eight small models, scales them up, picks the training data set. We don’t even need to look at it. I’m like, “Wow, a lot of engineering rigor there.” And there’s just, there’s just a lot in here.
Publishing Research and Giving Back
Eiso Kant [00:28:40]: Yeah, and it’- and look, and we wanna put out more. Like we, We treat writing papers as something that we haven’t earned the right for yet for a long time. So you earn the right to spend time, publishing research once you’re at the frontier, because until then, you’re catching up, and every minute and hour in this industry matters. Like I obsess over it, not just the wall clock time from idea to result, but just general like time every day that we, waste is one that doesn’t allow us to catch up. But in this case, we said, “Okay, we’re gonna give ourselves.” I think we gave the team like three or four days while still doing their work, like give everything in there. And to your point earlier, if your stuff, it’s easy to like put it out. And so there’s so many more things that we wanna talk about over time, and we will definitely start doing. And as we earn more of the right, but also now have like added to our mission that we want more foundation model companies to exist, you’ll see us like be way more proactive, and just trying to keep dropping some of those like things that we’ve learned along the way that can help others like speed up.
Vibhu [00:29:40]: Which is the other cool side of this, right? It’s, it’s not like, back to your point, it’s not just here’s the benchmarks of our training. If you want to replicate, here’s experiments of optimizers, data sets, post-training. you lay out a lot of it here alongside here’s your system for how to do it? So it’s, it’s really like promoting
Eiso Kant [00:29:59]: No, thank you
Vibhu [00:29:59]: Other people can do the same.
Eiso Kant [00:30:00]: And by the way, I also wanna make clear, right, we have been incredible-- Like we’ve taken a lot of advantage of the fact of all the open research that others have published, Right? And you mentioned, the Chinese labs, and we I think it’s important that there’s, from every country and every culture and background, including like Western companies like us, there’s different models that come out that people can choose to trust. But I think we do have to give credit where credit’s due, right? The incredible Chinese lab have done an amazing job at sharing their research, and we have definitely like been on the receiving end of taking advantage of that. So when you’re on the receiving end of something coming to you, I think it’s, you also have an obligation to give back.
Swyx [00:30:39]: Do you have a favorite or underrated Chinese lab that you wanna shout out? Everyone shout outs DeepSeek.
Chinese Labs, Zhipu, and Persistence
Eiso Kant [00:30:44]: That’s a good question.
Swyx [00:30:45]: Moaan obviously for Therapsi. Yeah.
Eiso Kant [00:30:48]: Yeah, look, I think, I think obviously everyone’s been talking about Zhipu lately, with 5.2. I think what most people don’t realize is when they started.
Swyx [00:30:59]: Yeah.
Eiso Kant [00:30:59]: Right? They started years before ChatGPT.
Swyx [00:31:02]: They just rebranded. Yeah
Eiso Kant [00:31:03]: And so, I’ve like, I remember how hard it was to work on these things Before the rest of the world got excited about it. And so I have an immense amount of respect for people, who were working on improving models when it wasn’t the sexy thing to do, when believing in LLMs, was gonna get you ridiculed. I remember like back in 2016 when we were doing what we’d call, machine learning on code with some of these models. we would-- people would just laugh at us, like they’d be like, “This makes no sense. Like why are you wasting all these, like, millions of dollars on trying to figure this out?” And so I would say they’re probably the one that, I think deserves a shout-out, not just because their latest model is very good, but because they fought to get here. And I think, I think every foundation model company it takes time to get here, right? It took us three years to get to the model that we’re, that we’re now gonna be releasing. and now the time in between the models is coming, is counted in weeks. It’s no longer counted in months or years. But this stuff’s hard. and if we can make it a little bit easier for the next person, like we should all do so. Because if we don’t do so, we’re, we’ve got a small window before models are really impacting recursive self-improvement to a level where catching up otherwise might become unfeasible. And we should try to, in that window, encourage as many labs or however we wanna call them, like to start. And so one of my current
Eiso Kant [00:32:36]: Mission, but qualm is like I wanna encourage whoever is a researcher right now who thinks they can tackle this to go and leave and become my competitor.
Eiso Kant [00:32:45]: Like start another foundation model company because I think we need it. I think otherwise we’re not gonna be in the world where, I don’t want to just be the fifth or the sixth company that wins. I wanna look at a world where there’s lots of choice.
Starting a Foundation Model Company
Vibhu [00:32:57]: What else do people not see in starting a foundation model? it’s, there’s a lot of compute, there’s a lot of capital required, a lot of compute. You lay out model factory and how to do the training, but there’s a lot there, right? That’s,
Eiso Kant [00:33:10]: Well, look, it’s, I in turn-- this is an oversimplification, and I always asterisk it with that because it can land a little bit the wrong way in people’s minds. But I think you can sum down, And I saw it, 95% of model building to just doing, you’re just doing two things. You’re improving data or you’re improving compute efficiency. And I know that feels like an oversimplification for the incredible, like, Gifted and skilled work people do. But if you really look at it, like what are we doing? We are looking at data, we’re generating new data, we’re improving data. and the only way to do that is to look at the data, right? That’s a big part of foundation model building. And on the other hand, we come up with these incredible breakthroughs in inference, in architecture, and new attention mechanisms. But what are they really doing? They’re bringing compute efficiency. Now, we have definitely had some breakthroughs over the years that allow for more model capabilities. But at the limit, if you could train a large enough model, right, like, and you had infinite compute, we probably-- if you had infinite compute, you’d be at AGI probably already tomorrow.
Eiso Kant [00:34:12]: Right? Like it’s not. And so, and let me say that infinite compute with infinite ability of much faster networking because networking ends up being more of the bottleneck than compute. But, so I do think that’s, those are the main things. And to just realize that this is engineering. I think it’s become more obvious, but I think for quite a few years, people have held foundation model companies and researchers and others on this pedestal of like you’re doing incredible magic or rocket science, or only like, Nobel laureate physicists can do this. And don’t get me wrong, there are some really hard problems that need to be solved, but a lot of the work that all of us are doing on a day Is not sitting down trying to solve a math theorem. A lot of the work that we’re doing is just really doing the basics right, writing good code, looking at data, improving it, running experiments, looking at plots, trying to see like, hey, trying to shape our intuitions. And a lot more people could be highly capable researchers. and I think that’s, it feels far for people to do so. But I’ve seen in our own company, we’ve seen engineers become researchers because the model factory allowed them to be, have a much lower hurdle of running experiments and trying things. And one of the guys on our team who started as an engineer building our agents is a legit reinforcement learning researcher now, making real progress. and that happened in the span of like six months. that would’ve not been what I think most people assumed was possible, a couple of years ago.
Swyx [00:35:46]: Yeah. I think one of the interesting moments is when you can self-host, like, if in a programming language, like if you can compile the language in the language, the equivalent is can you use your own tools, right? You have the pool CLI, you have your own models. presumably you’re not only using your own models. There’s no way. But like, what’s that percentage over time?
Laguna S, Persistence, and Behavioral Gains
Eiso Kant [00:36:10]: This is the first model that we’re releasing that is starting to meaningfully contribute to our own work. It’s not a it’s not state-art model yet. Fable and other, they’re, they’re very capable models, but Laguna S Is really interesting. I’m gonna pull up the quote. Peng Ming, one of our heads of applied research, said something, last week as the model came out about 10 days ago, much better than we had hoped for or expected. And he said, I have the feeling that a lot of the gains in Laguna S come not from more intelligence, but more from different behavior, more verification, less taking things for granted, not declaring victory early, and being way more persistent. And to be honest, those are more predictive than raw intelligence for success in human also to some degree. And this was, he wrote me this on 5th of July on a Sunday, and it’s been burned in my brain ever since because the Laguna S model, as you’ll see it and why it does so well on benchmarks and why it does so well in using it on a day basis, is that it’s just incredibly persistent. It reasons a lot. I do call that out. We have work to do on making it more efficient. We have to work to do on offering different reasoning modes. But this is the model that has been able to do things that I never thought it could do. A hundred eighteen billion 8B active model, which is not that large. It fits on a DGX Spark and still runs at, thirty, forty tokens a second on a Spark, is able to solve Erdős 397 independently. It’s able to do complex programming tasks. It’s able to. I asked it this morning to make me a Fi scanner without using any external libraries on my Mac, and it’s, like, figuring out, like, the core WLAN API by really persistently trying to understand it without access to the internet. And more, I love vibe checking. I’ve probably spent eight to ten hours a day with this model for the last ten days.
Eiso Kant [00:38:05]: I’m not exaggerating. I was on my eleven-hour flight yesterday. I spent ten hours reading trajectories and traces and, like, of the model.
Eiso Kant [00:38:12]: And what I take away from it is exactly what Peng Ming said. We are gonna be able to squeeze so much more out of smaller models than I think we had imagined in the industry because, yes, there’s intelligence and larger models are more intelligent. Like, no doubt about it. We should continue to scale up. but the behaviors of being really persistent, of being able to backtrack when you’re wrong, of, like, understanding how to interact with your environment show us that we can get a lot more out of it. And this, for me, has created a bit of a Question in my mind the last couple of days. If you think about where we’re using models today, right? We are using models, say, for knowledge work. Represents twenty-five percent of the global economy, twenty-five trillion dollars of work.
Eiso Kant [00:39:00]: As we scale up models and they become more intelligent, we are excited about using them more and more for pushing the frontier of science.
Small Models, Knowledge Work, and Commoditization
Eiso Kant [00:39:08]: And if you look at the frontier of science, like true breakthroughs in science, they have been linked, they are linked to more intelligence in many places. Einstein figuring out general relativity is able to bring ideas together that other people would have not brought together. And I think one of the many dimensions of intelligence is the ability to do that, and it’s something we clearly see that as models get larger and more capable, they’re able to pull more ideas and threads together that a smaller model wouldn’t be able to.
Eiso Kant [00:39:36]: And we’re starting to see examples of that in medicine and, like, in bio and other things. But if you think about the majority of knowledge work that we do, and it includes building software. I’m a software developer at heart first and foremost probably, although I probably can’t say it that much anymore as I don’t write production code in years, is that what makes us good is our persistence. It’s our ability to encounter a problem and backtrack and say, “I need to go figure out this bug. I need to go research this. I need to go look at the documentation. I need to, like, try different, five different ways to see, like, if I can solve it.” But it is not necessarily bringing three ideas together from radically different fields. And so if we are now seeing, and I think Laguna S is an example, that we are able to make a relatively small model much more capable than I had definitely predicted or any previous, like, benchmarks had shown for any model remotely this size or even larger, At least on coding tasks, that it’s because of the behaviors. And so now the question I have, and I don’t have an answer, it is I know at the limit, so infinite model size, right, extremely large model, and the cost of that model is gonna be very expensive to run. We know this, right? So larger model ROI.
Eiso Kant [00:40:52]: So I know that at the very limit, I’m not gonna use the world’s largest model one day, quadrillion parameter, whatever crazy, like, scale we scale up, to do a basic coding task. Already today, I’m starting to size down for certain tasks.
Eiso Kant [00:41:07]: So it means that there is an optimal. It means there’s some curve that goes as we go up to model size for knowledge work, at some point we’re at the peak, and after that, the return on investment of using a bigger model, just doesn’t make sense.
Eiso Kant [00:41:22]: Now, I think the question is, before I would have thought that peak was extremely very far away.
Eiso Kant [00:41:30]: This model for me is the first sign that Maybe that peak is At a trillion, five trillion, ten trillion. Maybe we can just squeeze way more out of these models. I’m no longer thinking that we need two or three orders of magnitude on the largest models to be able to, solve knowledge work, the accounting, the legal, the code that we write. And so if that holds true, It is an argument for the commoditization of models. It’s an argument that open source can win and, like, succeed in this world. And now it’s of course a self-serving argument and it’s a hopeful argument, but theoretically at the limit it works. We just have to go discover in the next couple of years of how much more we can squeeze out. Now, I do want to put a big asterisk. This does not mean I’m against scaling models. I think we ultimately only succeed if we scale our models as large as our competition. I do not like. I think we should not put our head in the sand and say we’re gonna be king of open source small models. I think that’s, It’s a out. It’s trying to be king of your own kingdom, but not realizing what the rest of the world’s doing. All of us rather use a smarter, faster, more model. It’s a sign of hope. And so I don’t wanna overly state this is a good model. We have a long way to go to get to the state-art. But what hopefully people take away when they use this model is that the behaviors inside of it are what push it to be far more capable, less than necessarily the number of parameters.
Pre-Training, Mid-Training, and RL Moving Earlier
Vibhu [00:43:03]: Is that mostly post-training? Like
Eiso Kant [00:43:05]: Yes
Vibhu [00:43:05]: Right.
Eiso Kant [00:43:06]: It’s entirely post-training.
Vibhu [00:43:08]: Are we done improving anything on training? Is, like, training done?
Eiso Kant [00:43:12]: No.
Vibhu [00:43:12]: Okay.
Eiso Kant [00:43:13]: So
Vibhu [00:43:13]: I just wanted to cover training, and then we go post-training
Eiso Kant [00:43:15]: Training is not done. I mean, look, there’s a part of training of just dealing with skill, right? Every new order of magnitude of model skill, you are going to get new things you gotta solve for. That’- but those are ultimately, engineering challenges.
Eiso Kant [00:43:31]: I have a, I would say, a not commonly held opinion that reinforcement learning Will move earlier and earlier into training.
Vibhu [00:43:42]: Yeah, training.
Eiso Kant [00:43:44]: Not even training. Like training today, right, is, like if you look at - So we’ve been working on this for years already. and I think the best-- I think the first time we saw it out in public was the DeepSeek Zero paper. this is a year and a half ago, I think, if I recall correctly. where, you can Very early on in a model as it starts capable of being able to use language, et cetera, induce reasoning. and so the question that I have is like, we have this- we have the dataset that’s the web. and the web, I think we could arguably say probably has The totality of humanity’s knowledge somewhere encoded in different places. It’s a huge variance degree of quality, from garbage data, and like once you look at training data, you really get humbled of like what the web is, to like, the most greatest scientific papers and best blog posts and like, best transcripts and whatnot.
Eiso Kant [00:44:39]: And so now What we are trying to figure out, and have been doing a lot of work on, and it’s a place where maybe not as open as we’re on other things, but we will become more over time. we’ve been spending a couple of years really doing research on how can we turn the web into not just next token prediction, but into a way to teach the model to think earlier in its training. and I think there’s a huge amount of gold to be found there. I think we are right now in, we’ve got some drugs in the industry. One of the drugs is distillation. Another drug is, more environments. Like, and they’re great, and they make us feel good, and they make the models better, and like we’re all addicted to them, and we’ll use them, right? in various different ways. and but ultimately, I think we are still barely squeezing out of the web what we should be getting out of the web.
Eiso Kant [00:45:33]: I think just next token prediction during training is not enough.
Eiso Kant [00:45:36]: And
Vibhu [00:45:38]: Yeah
Eiso Kant [00:45:38]: I think we’ll see some very interesting things still happen. and that RL in post-training to induce behaviors, to improve things, like I think - the whole world knows how to do this now. I think we’re, we’re scaling it up. Everyone is. But I wonder if we need to go as far as we’re going today with environments. I’m not sure yet
Vibhu [00:46:01]: You mean we’re going too far?
Eiso Kant [00:46:02]: I’m, I’m not sure if the path to AGI is just
Vibhu [00:46:06]: Is more environment
Eiso Kant [00:46:07]: More environments.
Vibhu [00:46:08]: It seems like a never-ending, “Okay, I want instruction manual for this table, right? Am I gonna environment out building furniture? Or are we just gonna tail end like we need some general solution?”
Eiso Kant [00:46:19]: I think there is, I think there’s an ability to generalize more from the web. but I also am very encouraged, like when I look at Laguna S and, which is post-training is, well, is the big impact there. and I see like, oh, wait a second, just by making some of these behaviors much better, we’re able to get so much more out of it. It just changes a little bit the way you think about intelligence.
Vibhu [00:46:40]: Yeah. The analogy people draw often is the RL phase is where you don’t learn as much new knowledge. You shift
Eiso Kant [00:46:46]: Yeah.
Vibhu [00:46:46]: Yeah. So, you shift distribution, and you can have it reason towards what you want. on your point about training, a lot of training is still just continue training in a domain, say medicine, then you do RL. So still just
Eiso Kant [00:47:00]: It’s just better data, right? Like, I mean, training, ooh, I like how we invented this word. Like it’s effectively just like,
Vibhu [00:47:06]: Second phase
Eiso Kant [00:47:07]: It’s the second phase of training With like a really dumb way to do a curriculum. But like ultimately, what you’d want is a curriculum from token zero to token 30 whatever or 40 trillion tokens that really truly is the optimal curriculum for the model to learn. But training is essentially a stage curriculum on the web because we do not have to compute, And, effectively to try to ablate the perfect curriculum, right? And so I’m pretty sure that you’ll start to see people talking soon about some other term, and there’s two or - ‘cause now we do this, right? We talk stage two and stage three and stage four training and like. But ultimately, all we’re doing is we’re trying to assign a curriculum to the web data that we have to allow the model to learn better. I think at some point, as things get compute, as models get cheaper to run, as the next generations of compute, this will become more of a continuous spectrum. I also think the reason, by the way, you have training and like stage two and stage three is organizational, Right? It’- this is, I think, a thing where-- that we really try to avoid with the model factory is like Training exists because there’s a training team now, right? There’s people, or like people in training decide to focus on like a training effort. but what you really want is engineering and scale of experiments that allows for a much more continuous spectrum that you don’t, you have infinite stages. Now, we’re not there. Compute’s not there. Organization design is not there for it yet. but I think we’ll get there. we’ll look back on a couple of years and be like, “Oh my God, it was so cute that we did our training data like this in such a like naïve way. Like we barely ordered it. We didn’t really do a good job at like
Curriculum, Auto Research, and New Objectives
Vibhu [00:48:48]: The building that curriculum will get you that in the industry.
Eiso Kant [00:48:51]: And I’ll confirm that, when I talk to some researchers that this is a lot of the focus now is like how does training change and what is the next objective other than, next token prediction. I assume you don’t have the answers, but you have some ideas.
Vibhu [00:49:02]: We have some ideas. We’re not ready to talk about it yet.
Eiso Kant [00:49:05]: Yeah.
Vibhu [00:49:05]: We’ve been working on them for years, and I think that’s the one thing that’s also like you asked earlier about, like what’s not obvious about building a foundation model company is that you are constantly balancing the table stakes work, the recipe works
Eiso Kant [00:49:19]: Yeah.
Vibhu [00:49:19]: Versus like your, my crazy
Eiso Kant [00:49:22]: Pure research
Vibhu [00:49:22]: Breakthrough.
Eiso Kant [00:49:22]: Yeah.
Vibhu [00:49:22]: Pure research and finding that balance and adjusting the percentage to it based on where you are in the race is really important.
Eiso Kant [00:49:31]: I mean, so like, this is a nice way. I was gonna bring up auto research at some point
Vibhu [00:49:35]: Yes
Eiso Kant [00:49:35]: As another Andrej invention, or coinage, which is like, I honestly, like how many objective functions can there be, right? Like just try 1,000 of them, set it running, whatever.
Vibhu [00:49:47]: Man, it’s also
Eiso Kant [00:49:48]: Like what you’re looking for. You’re looking for loss curves like that, like
Vibhu [00:49:51]: It’s also a thing people take bets on, right? When you say more Neo labs, you’re doing a version of we’ll do foundation models, scale them up, next token predictors. A lot of other Neo labs that we see want to take a completely different approach, right? At some level, you’re right. It’s all, compute efficiency, and that’s the net objective. But some are okay, different architecture, like vastly different amounts of compute spend. So some are different. They’re not just
Eiso Kant [00:50:19]: Yeah
Vibhu [00:50:19]: They’re like, 99% not balancing, here’s the vanilla and scale up. They’re 99% on, here’s novel research that’ll change everything.
Eiso Kant [00:50:27]: And I think, Luke, I think you. It depends when you started as well, right?
Pure Research vs. Table Stakes
Vibhu [00:50:30]: Yeah.
Eiso Kant [00:50:30]: When we started, like the novel thing we did was reinforcement learning on code. No long- that’s no longer novel by far, but we were like, - that’s where we obsessed over when no one believed in RL. So you have to when you start the company, you have to have your own idea. You have to have something that’s different that allows you to speed up, right? For us, it was RL to LLMs that later became common, like, Knowledge. But in the beginning, it wasn’t
Vibhu [00:50:53]: It’s cool. this was like your original 2023 blog
Eiso Kant [00:50:57]: Yeah
Vibhu [00:50:57]: Of purpose.
Eiso Kant [00:50:58]: Yeah.
Vibhu [00:50:59]: And like you do lay it all out here.
Eiso Kant [00:51:01]: We laid
Vibhu [00:51:01]: The blog is pretty underrated, right? The whole RL on code was very early on.
Eiso Kant [00:51:06]: Very early. And even we had to argue with people, like we say here things like to push beyond current capability, to train your own foundation model. We had to argue with people that it mattered that you had your own like, base model. you can fine-tune your way to success, right? major capabilities emerge from training a base model made accurate and useful during fine-tuning.
Vibhu [00:51:23]: Which like, for perspective at the time, we knew closed models, OpenAI, Anthropic were huge. The open models we had were like Mistral 7B, a 30B, a 70B.
Eiso Kant [00:51:35]: When we
Vibhu [00:51:35]: Yeah
Eiso Kant [00:51:36]: The date on this thing is wrong. When we published this, it was April 2023. I think this was just
Vibhu [00:51:42]: Yeah
Eiso Kant [00:51:42]: Happened on a migration, probably found it on archive.org.
Vibhu [00:51:45]: Mistral.
Eiso Kant [00:51:46]: Mistral had started, we started on the same month, right?
Vibhu [00:51:49]: Yeah.
Eiso Kant [00:51:49]: So this wasn’t even, there was only, I think, Llama out at the time
Vibhu [00:51:52]: Snell
Eiso Kant [00:51:52]: And that’s it, right? And so, but I agree. I think we want, We want as many diversity of ideas, and I do think if you’re starting today, you want something that gives you an edge, right? and what I do think we sometimes over.
Eiso Kant [00:52:13]: I think every archit- like at the limit, every architecture works. An RNN works, it’s just not compute efficient, right? Like, say if you had infinite compute, you could probably just, take a basic RNN from back in the day, and you could get pretty far.
Eiso Kant [00:52:27]: Now there have been, meaningful breakthroughs, attention, other things that are there. but I think we’re still, we’re still very early in figuring these out. The things I’m most excited about, I’m most excited about people doing extremely low precision training, right? So like the ternary stuff that we’re seeing, and it
Vibhu [00:52:47]: Oh my God
Eiso Kant [00:52:47]: Very cool. The Bonsai stuff yesterday was super cool to see. I think that if you can find tweets from me going back to 2023, which is like the notion of like, well, it’s an obvious trade-off. Bigger model, lower precision equals, smaller model with higher precision, by definition, right? It’s just what is, like how does that play out, right? What’s the actual size limit? So you now have companies that are trying to figure that out, but those are the things that can change our industry if they’re done right.
Low-Precision Training and Compute Efficiency
Vibhu [00:53:14]: Yeah.
Eiso Kant [00:53:14]: Because ultimately, like our bottleneck on compute is a MatMul bottleneck, and a networking bottleneck, and the moment you start doing those things. So I’m excited about that. We’re not doing - I mean, we’re doing the usual, like, Laguna S was trained in FP8. only thing that in this run I have to admit that wasn’t FP8 was the all to all in the new run we just started yesterday. The FP8 was all to all. That was just like cut off date, like, oh, we’re not perfectly comfortable wanting to do it. you’ve got amazing work by Nemotron and NVFP4 training. Like, I think it’s underrated what they’ve done there. I’m excited to get to NVFP4 training. doesn’t make sense yet ‘cause we’re still training on Hoppers, right? We’re like relatively small. We’re 10K H200 cluster company right now. We’ll be scaling to a lot more soon, but, and really a lot more if someone is thinking about applying for a job. but like the. Yes, I think it’s, there’s so much more juice to squeeze out of this, and hopefully Laguna S shows people that a model at this size can get a lot more and we did this thing in eight weeks. We think there’s a lot more juice to squeeze out at any model size. we’re now scaling up because it’s the most optimal thing to do for us as a company. But if I had infinite time, I would love to push more the capabilities at other model sizes.
Vibhu [00:54:34]: I don’t think we’ve properly announced what your new size is. So we have XS, which was 30B-ish.
Laguna S Model Size and Naming
Eiso Kant [00:54:41]: Yep.
Vibhu [00:54:41]: Old medium was 200B, which is gonna be deprecated
Eiso Kant [00:54:45]: Yeah
Vibhu [00:54:45]: It seems. So new Laguna Small
Eiso Kant [00:54:48]: So Laguna S, Laguna Small, 118 billion total parameters, 8B active, so very sparse. It’s a scale-up of the XS architecture. It’s the classic, or call it classic these days, like three-one ratio of sliding window attention to global attention. It’s just, it’s a nice size, for a couple of reasons. One, it’s just very cost efficient. For us, it was a good way to - We wanted to get our progress out quickly. One of the things that we’ve seen is that it’s a balance inside a foundation model company between focus on releasing and shipping And, like, your new novel research. But with the model factory, we are able to, like, treat the release of a model as less of a time investment from the team because it’s just, oh, at this moment in time, do the training run, done, apply the latest post-training. And so this is, I think, a nice weight class. It’s one that also will fit on a DGX Spark, which, I have a small, like, soft spot for. I love having that little thing, like, run a good model.
Swyx [00:55:52]: Yeah, we covered it on this pod, GTC last year.
Eiso Kant [00:55:54]: Nice.
Swyx [00:55:55]: I think a OSS 120B was the first because it’s a large single GPU, which was the H100, right?
Eiso Kant [00:56:02]: Exactly.
Swyx [00:56:02]: Rent one H100, now you’ve got 128 gig Macs, Mac Minis, Sparks. It’s, it’s the home sweet spot.
Eiso Kant [00:56:10]: But I think what I’m most excited about is that this model hopefully shows people what is possible in this size because, when you’ll look at the benchmarks and start using it, you’ll realize that we are outperforming models two or three times their size.
Swyx [00:56:24]: Yeah, and they think-- So for example, today’s Thinky model is like a trillion params.
Eiso Kant [00:56:28]: So yeah, exactly. And look, and by the way, I’m excited about-- I have-- It just came out, so for those of you who are listening to this at like, I saw it on my phone
Swyx [00:56:34]: If you’re, if you’re listening
Eiso Kant [00:56:34]: If you’re humming
Swyx [00:56:35]: Yeah.
Eiso Kant [00:56:35]: Like two seconds, so I haven’t even had a chance to read the post.
Swyx [00:56:39]: But somehow you are, not only you’re, you’re better than Thinky, which is like one of those benchmarks, but also, like, on certain benchmarks, like the τ-bench one, like you’re state-art.
Eiso Kant [00:56:51]: We’- Look, we’re doing, I’m not sure if we’re state-art on I mean, 3 banking, I haven’t checked where we sit on the leaderboard. but I think we are, within our weight class, I feel very comfortable to say, and even in some weight classes twice larger, that we are probably state-art. I also want to caveat this, like, best model still in the world right now is definitely, give me a Fable, give me a 5.6. To your point earlier, we also use other models.
Swyx [00:57:15]: Yeah.
Swyx [00:57:15]: I think the, so the interesting thing you mentioned earlier is you’re starting to shift a lot of your actual usage to it, right? Benchmarks are like
Eiso Kant [00:57:21]: Yeah
Swyx [00:57:22]: They’re good to compare, but they’re not super realistic. It’
Eiso Kant [00:57:24]: They have to, right? This is how they’re gonna dog food benchmarking.
Eiso Kant [00:57:27]: No, you have to. Like, you have to use your own models, and you have to have your own internal evals and benchmarks. And what the funny thing is, like within first 30 minutes of a new checkpoint coming out that’s, the first post-train after a train, you yourself can feel in the first 30 minutes of where this model’s gonna be. Like, you don’t know exactly, but like when this one came out, we were like, “Oh,” like, “this is different.” Like, and I think that’s, I think that’s the best example. but it’s a little bit like your kids. I don’t have kids, but parents, like, they see their kid and it’s perfect and they love it, and then like, they don’t see all the rough edges. You always get that when you build your own model. It’s the most fun part is that you, like, you love a little bit every model that you do. We try to say this thing constantly, it’s like, “It’s the worst model we’ll ever train.” And so I know the team now is like already onto
Swyx [00:58:18]: Yeah
Eiso Kant [00:58:19]: The next one, as it should be, because this is a race. and this model is a moment in time that hopefully shows people that we are serious about this race, that we wanna work really hard at it, that we want feedback, right? Where is it good? Where is it not? Like, one of the nice things about having your models out in open weight and out in the world is that you get a lot of feedback.
Swyx [00:58:40]: How do you think about building it with like, working with a harness, right? So OpenCode, Codex, you have your own pool CLI tool. getting people to use it, the design of model harness, training it in.
Eiso Kant [00:58:54]: So you need to do some multi-harness training. Like if you, especially at these smaller sizes, like you wanna do a little bit of multi-harness training for these models to just get the right. And it’s very little. Like, you don’t need a lot, but it’s just like to get the right behaviors that you see in your harness transferring to the harness that, like, you, other people might use it in. we internally have been just calling this polishing, which is like you’ve got your model and you do a little bit of polishing so that, like, it’s able to work well in other harnesses as it is in your own.
Eiso Kant [00:59:24]: No doubt it’s going to be better in your own harness, and it’s just because of like where are you putting your reinforcement learning compute, right? You’re putting your RL and your synthetic data, you’re putting it to your own harness because it’s the one that you understand the best and you’re able to push the most. because that end control is what allows you to make it better. then transferring those capabilities is more about just making sure the model, induces the right amount of reasoning and like, understands some of the maybe more complex weird tool call formats that might exist somewhere else. and so we do some multi-harness polishing, as we call it. it’s not really what drives capabilities, but it does create a better experience. I think everyone probably does these days, but it is totally fair to see why your own harness is going to still be better than others. And I think we see this with all the foundation model companies. and it’s just that when you are pushing capabilities, you don’t really wanna trade it off by putting 10 harnesses in your RL runs because it’s just complexity. It’s complexity of engineering because these-- When you’re trying to do good science, right, when you’re trying to really understand what made my model improve, you wanna make one variable change to something you understand. And a harness from someone else, you don’t know or understand in the same way as you understand your own, right? They might have different agents or different prompts
Why Poolside Is Called Poolside
Swyx [01:00:48]: Yeah,
Eiso Kant [01:00:48]: In different places
Swyx [01:00:49]: If it’s open source, you can look at the source.
Eiso Kant [01:00:50]: Yeah, but it’s time, right? Like I really cannot stress, like I know I’m like a weird person on this because like I have friends like, “Can we meet up?” Or, “Can we do this?” Or, “Can we go out?” I’m like, “No.” Because ultimately, this is a race, and time is the only thing that matters. And if I look at our team and say, “Okay What is complexity worth introducing on our general trajectory to building more capable models? Which generalized to other harnesses quickly. And by the way, our model works well on other harnesses. I really encourage people to do it. It works well. Like I’we’ve been testing it in OpenCode and Kilo Code and others and like, and in Claude Code.
Swyx [01:01:22]: Which just got bought today.
Eiso Kant [01:01:24]: I saw it.
Swyx [01:01:25]: I mean Honda. Yeah.
Eiso Kant [01:01:25]: Exactly.
Swyx [01:01:26]: Everything’s getting bought.
Eiso Kant [01:01:27]: Exactly. and I think part of that is like, and there’s some amazing. I’m, I’m excited, like I think Hermes is a ridiculously cool harness like, and
Swyx [01:01:37]: And, part of the question was just like how much of it is model versus model plus harness, right? So new benchmarks like Agents Last Exam, it’s not wanting to just measure the model. same with models getting more and more agentic. They need a harness to operate in, right?
Eiso Kant [01:01:55]: I think for when you’re asking that question to a model company, I think you can separate it in two parts, which is like The harness, like we have a very slimmed down harness. When you look at it’s like six tools. It’s like shell and like shell kill, shell wait, write, fetch web, and like, I don’t know, bash. Like I think I’m missing one, but like that’s effectively all the tools. And it’s very simple. It’s very lightweight. So it is not a harness that is designed to try to do well on a benchmark or try to do well on a certain subset of things, right? It’s not a deep research harness. So I think we see incredible ability for complex harnesses that build lots of prompts around and extra data sources and other tools to really push capabilities of models forward.
Eiso Kant [01:02:41]: But our model is still better than some other harnesses who do that in coding-like tasks because it was RL’d with it.
Eiso Kant [01:02:48]: Now, I do encourage people, I think our model, by the way, is perfectly fine and good on ours. The differences are probably maybe too small for anyone to notice, but we see it ultimately still on benchmarks, by a little bit. So I think it’s both are true. Foundation model companies with their harnesses will really push them because it’s just operationally, the best way to have scientific rigor in improving your models. But also someone who takes our model and really does a lot of work on improving a harness is going to compete us, as they should. and that’s just because the harness is the stopgap between what the model is capable of And what it needs as additional instructions, and what it needs is access to data and tools, right? And that’s ultimately, I think, what a harness is. It’s like, is it able. As you build more capable models, you’re improving the instruction following the models. And so additional harness is just saying, “Hey, if you encounter X, Y, or Z, behave this way.” And so even if you would say that two models with two different harnesses can equally reach the same capability that you care about, a harness that is really tailored towards a capability will do it more efficiently.
Eiso Kant [01:03:58]: It’s like a person who’s getting a manual of how to do the task in the most efficient way with the right tools and the right data sources versus a really smart person like, “Go figure it out.” They’ll both solve the task, but one will do it a lot more efficient. So I’m a big fan of all the harness development that’s happening in the world, and we want to work with more harness like creators to also make sure that like if it needs some additional training, like publishing, that we will do it.
Swyx [01:04:22]: I mean, I think when you say it’s a race, there’s a question of what are you racing to? are you racing to be the best coding model company or the best coding model plus harness company? I think that’s a, those are different things.
Swyx [01:04:36]: Or neither.
Eiso Kant [01:04:37]: Or neither.
Swyx [01:04:37]: Yeah.
Eiso Kant [01:04:38]: So we. I race to AGI. Coding for us since day zero of our website has been, and we’ve said this over and over again, we think focusing on coding and long horizon like software tasks is a path towards AGI because it forces us to solve the hard problems. It’s, it forces us to solve the ability to do extremely long horizon complex work that requires lots of reasoning, external tools, data, et cetera. And one of the things I can show you, so we’ll, we’ll have a web chat on with this model, and I’ve loved this model for deep research, just using it in my coding harness. It was never trained for it. It was never like looked at it, but it’s great at it, in my opinion. because ultimately, the skills transfer, they generalize. Now, where we are not focused on today is to make sure that the world’s greatest medical knowledge is encoded in this model or the world’s greatest legal knowledge. But it did. We won’t be publishing this benchmark ‘cause we didn’t have time to really do proper, but it did really well on LegalBench. and at least on our first runs, and we are very rigorous. When we publish evals, we have Checked them for every little thing. We have run them many times. We’ve passed, like we’ve gone and we’ll, like we try to be extremely honest with this, so if we haven’t spent enough time on a benchmark that we use internally that is public, we just say that we won’t publish it. and
Swyx [01:06:01]: I mean, the other way is just to give it to artificial analysis and let them run it.
Swyx [01:06:04]: Like third party standards.
Eiso Kant [01:06:05]: Oh, 100%, and we are gonna be doing this as well. And still it takes time and effort, right? Because you’re working with people to understand like, the infra failures and like the tools they’re using and like, are they set up well. But I agree. You absolutely want to. I’m a big fan of companies like Vals and Artificial Analysis and like others that are doing this stuff.
Swyx [01:06:21]: I found it very nice. You’re the first to bring it up.
Eiso Kant [01:06:22]: Yeah. I think they’re great. They’ve got like. I loved like a lot of the work they’ve done and put out. and so, and there’s, I think, many more, and please create more eval companies. Like create more evals. I think it’s so valuable for the industry.
Swyx [01:06:34]: It’s an actual monopoly I feel like. Oh, and duopoly maybe.
Eiso Kant [01:06:37]: I think it can be broken.
Swyx [01:06:39]: Yeah.
Eiso Kant [01:06:40]: Because I think it can be broken really easily because creating an eval for many people isn’t sexy work, but whoever does it, everyone is happy to get a good eval. You’ve like if an eval is well constructed, everyone’s celebrating it, and everyone’s willing to pay for it, and everyone’s willing, like the foundation model
Swyx [01:06:55]: Oh, yeah. I think creating eval, yes. But like in terms of being like we are the industry standard ones that will
Eiso Kant [01:07:01]: Yeah
Swyx [01:07:01]: Τ-bench and make sure that you didn’t, you didn’t cheat
Eiso Kant [01:07:03]: Yeah, that’s true
Swyx [01:07:03]: And I’ll run it the same way that you run it versus your competitor run it.
Eiso Kant [01:07:05]: Yeah. That is very true, and we need that. And it’s nice that’s like a few standard places that we all have to like, adhere to. It keeps us all honest. I think that’s super important to do so, And, but yeah, no, I think our goal is to build the world’s most capable models. and right now we are focused on the coding agent capabilities, long horizon work. But what you see with that is that you get a lot for free. I’ve always said it’s a lot easier for us as we get to SOTA and frontier on coding to then say, “Okay, now we’re going to obsess in using the model factory to add more data for places that, we’re not as strong on,” like could be medical or legal or any other areas. and similarly, I think what we see, and we see this with reasoning models a lot, if you give models access to the right knowledge sources and they have capable ways of reasoning, they’re able to go very well into domains that are less known to them or even seen less in their training data. So, but yeah. Are we a agent like model plus harness comp-? No, we’re a model company. but I think models today cannot be trained without harnesses. It’s not possible. So it is just like where before it was just the weights in the container, well, now there’s an agent harness that’s attached to it. and but I think there’s a big difference in being an agent harness as a model company than someone who’s truly building an agent company. I think they can do far more than we can.
Swyx [01:08:27]: Yeah. understood. Yeah. I think that is my minor pushback. If you are truly identified as a model company, then make the best model for OpenCode, right? Instead of for pool or whatever. I think that’s not as, that’s, that’s minor compared to if the goal is AGI, make the best model for Hermes.
Swyx [01:08:45]: Right? Like just ‘cause that is the next stage after coding.
Eiso Kant [01:08:48]: I’look, and we’re working like very closely with them
Swyx [01:08:52]: Yeah
Eiso Kant [01:08:52]: Because I do think like it’s, and, you have to care, you have to invest in it. It’s why we do the polishing and we spend time on it. and I think over time, yeah, you’re, you’re right that you wanna balance that out. but ultimately you just want general capabilities that everything works equally in every harness.
Swyx [01:09:10]: Just on the topic, do you guys do much with like Hermes, OpenAI Codex, NanoCodex, whatever? Pi?
Swyx [01:09:16]: Pi.
Eiso Kant [01:09:17]: Pi.
Swyx [01:09:17]: No, Pi is different.
Eiso Kant [01:09:18]: It’s more coding.
Swyx [01:09:19]: Yeah.
Eiso Kant [01:09:19]: I’m a big fan of Pi, though, I have to say. I think it’s a really sexy
Swyx [01:09:22]: I forgot to mention Pi.
Eiso Kant [01:09:23]: Yeah.
Swyx [01:09:23]: Pi, you sound closest to Pi in terms-- pool and Pi in terms of like the minimal surface
Eiso Kant [01:09:28]: In the minimal yeah.
Swyx [01:09:29]: Yeah.
Eiso Kant [01:09:29]: It’s because I don’- I have a. Allow me for one more strong opinion.
Swyx [01:09:33]: Yeah.
Eiso Kant [01:09:34]: I’ve been saying this now for two years.
Eiso Kant [01:09:37]: I think MCP and tools are stupid.
Swyx [01:09:41]: Ooh. Let’s go.
Swyx [01:09:42]: You support MCP.
Eiso Kant [01:09:43]: I support MCP and we support tools and everything. They make absolutely no sense to me.
Eiso Kant [01:09:48]: And like, and I’ll explain a little bit why and I think I can probably get people to come along on this one.
Eiso Kant [01:09:56]: If you are looking for complex tasks, increasingly longer horizon, increasingly complex tasks, doesn’t matter if it’s coding or something else, You are gonna be interacting with data sources, right? And you’re gonna be interacting with things that are installed on some form of a virtual machine.
Eiso Kant [01:10:15]: And what we are doing is that we’re putting a layer in between those things. We’re putting like MCP in between, we’re putting tool calls in between, and this is even more about tool calls than MCP, where the model can just write the code and interact with the system. And we’re starting to see that. Like Laguna S does this a lot. You’ll see this as well in like frontier models. They’re increasingly no longer, “Here we’re gonna stuff 50 tools in the like system prompt,” to “No, here’s a virtual machine with these binaries installed, this code base you can operate in. Here, a folder where you can write, your memory if you want to.” And the model is using code to do complex asks. And when it uses code, it is not one or two tool calls or three things that are chained together. It starts, using if statements and for loops and making things conditional. And so I think we’re moving from, we already are moving from tool calls, to effectively models writing code, little scripts, and you see this a lot when you get the Python,
Swyx [01:11:15]: Code interpreter.
Eiso Kant [01:11:16]: Exactly. Like in just the arrow in, written code in the file. I don’t know what you call
Swyx [01:11:21]: EOF? Yeah.
Eiso Kant [01:11:22]: Yeah, exactly. Like, you already see this happening more in models because when you start training them in RL, the models wanna be free. They wanna be able to do the thing they wanna do in the most efficient possible way, and it is not calling one of the 50 tools in their like system prompt. And so I’m a very big fan of Give the model a minimal harness, as minimal as possible, give it a container in which it has its own code base, right? The, got a models code base that has access to the API keys and data sources and little libraries and documentation that it needs, and just let it run free at the task. and I think that is the way we’re going. I think we will, in 12 months, not see a single system prompt that is stuffed with 20 or 30 or 40 tools anymore.
Swyx [01:12:07]: No comment. no pushback there. I think there will be, it’ll be supported for a long time just because that’s, a lot of people are trained on that now, but maybe you guys don’t have to support it in your models, going forward. So, but yeah, I mean, if you can. I do think that’s, writing code is more generalist and it’s a, it’s a means to an end
Eiso Kant [01:12:26]: And we do support tools.
Swyx [01:12:27]: Yeah.
Eiso Kant [01:12:27]: We support. And this is the first model we’re doing parallel tool calling in which we needed to catch up on. So like that’s there and like
Swyx [01:12:32]: Yeah
Eiso Kant [01:12:32]: So it’s, it’s there, but I,
Swyx [01:12:35]: Yeah
Eiso Kant [01:12:35]: It’s a personal, nitpick. I like, I want the models to have as many degrees of freedom and just like, be free and do capable things.
Swyx [01:12:43]: Yeah. So and then, so that was on the path towards like, okay, how do you use Poolsides models and Laguna models for my Hermes or my OpenAI Codex
Eiso Kant [01:12:52]: Yeah
Swyx [01:12:52]: On all those things. And so typically what I look for is, Computer use or vision. That’s a, that’s a very big one. You guys have a blog post on that. but then also the persistence I think is very strong value, as well as long context, which you guys have a million token context. Anything else?
Eiso Kant [01:13:08]: So for us, look, so for us, vision understanding is the next thing, right?
Swyx [01:13:11]: Yeah.
Eiso Kant [01:13:11]: Like we don’t have vision understanding.
Swyx [01:13:12]: Which I was gonna say is
Eiso Kant [01:13:14]: We don’t have vision understanding in these models yet.
Swyx [01:13:16]: Yeah.
Swyx [01:13:17]: To
Eiso Kant [01:13:17]: And so this is something that we’ve, we’ve started efforts on. Like we think it’s, it’s super important to have visual understanding.
Swyx [01:13:23]: That’s company vision.
Eiso Kant [01:13:24]: And so no, we’ve got work to do there. and this is one of the things I loved about the Thinky model, like from the Two minutes I scrolled the blog post
Swyx [01:13:33]: Yep
Eiso Kant [01:13:33]: Multi, the multi
Swyx [01:13:34]: They’re, they’re very committed to multimodal, including audio. Yeah.
Vibhu [01:13:36]: They’re state-art audio, as much as it’s a trillion parameter state-art audio, but also all trained from scratch, right?
Swyx [01:13:43]: Yeah.
Vibhu [01:13:43]: No encoder in the sense
Swyx [01:13:45]: To me, that’s, that’s, that’s one of the strongest reasons why you need to train from scratch, is you just have a different tokenizer, you’d have different
Eiso Kant [01:13:51]: I’m fully aligned, like zero disagreement from me here. Like, just add the modality and don’t put. keep it simple. we’I don’t think we’ll touch audio for a very long time.
Vibhu [01:14:05]: It’s in the name too, InkLink Inc.
Eiso Kant [01:14:08]: True.
Swyx [01:14:08]: Yeah.
Swyx [01:14:09]: I mean, what’s so hard, what’s so hard about audio?
Eiso Kant [01:14:11]: It’s not about what’s Again, it all comes down to focus.
Swyx [01:14:14]: I see.
Eiso Kant [01:14:15]: Right? Like saying no to things means that there’s a research or an compute that can go to making general progress, and our view is like general progress, is going to come from the ability to push these models to far more capable reasoning, far more longer horizon tasks. I don’t think audio Adds to that. I don’t think it pushes us close to AGI. I think it is a necessary modality as you get closer to AGI. I think visual understanding sits in the middle of those things. I think visual understanding can absolutely, do so, but it also unlocks capabilities that are just valuable today. so but this is the point, right? You want more diversity, you want more different foundation model companies who focus on different things. I think we are just like a horse with blinders on, just like
Swyx [01:14:58]: Yeah, you have your path
Eiso Kant [01:14:59]: We have our path, we wanna catch up to the frontier, and, we don’t wanna distract ourselves with anything else.
Swyx [01:15:05]: Yeah.
Swyx [01:15:06]: I will call out that one of the branches of research is DeepSeek OCR, which is can you just throw away the text tokenizer and just have only vision?
Eiso Kant [01:15:13]: I find this-- I look, geek, the geek in me is like looks at this stuff and it’s like, okay, look at this, like look at the number of bits encode
Swyx [01:15:20]: But they’re right.
Eiso Kant [01:15:21]: I think it’s super cool, right? But I think this is what we’re gonna come back down to. Like probably works, it’s just is it compute efficient enough? Is it Like I think so many of these things ultimately will work. It’s just like, what’s the nice thing about text? And I referenced earlier, Peng Ming and Nikolai are my two heads of applied research who are just incredible, like we wouldn’t have gotten here without them and the entire team.
Eiso Kant [01:15:45]: And Nikolai have-- and I have been debating, for years about like, should reasoning be in latent space? Should reasoning be in tokens? But one thing that I think him and I really agree on, and all three of us, and is that like Language is incredible because it’s such an incredibly dense way to encode knowledge and information and intelligence, right? If you think about like what went into a physics paper that then is, 20 or 30 pages, like the amount of intelligence and thought and whatnot to then generate that, like in that 20-page document, like those little amount of bits, there’s so much encoded. And other modalities like video and images are amazing, but they don’t have the same density of like knowledge or reasoning or however, like the things that we’re trying to push for that are encoded in that modality. They’re there. In many cases, you can watch an incredible lecture for, 50 minutes on YouTube, but the amount-- and but if you treat that as video in data versus text data, right, the bits to like signal-noise ratio, the compute efficiency of the modality is a lot less. And so we have this view as like with language you can go really far, but also when you have limited compute, limited, people, and they’re very much linked to two, I think we can push language. It’s the more, it’s the better investment. But I want all the modalities. I find it super cool and I love what DeepSeek and others are trying. Like I can retweet them all the time, but internally we’re just like, “Let’s stay focused.”
Vibhu [01:17:17]: Which I’ll say, you can see somewhat works looking at Anthropic. OpenAI has a lot of vision, multimodality. Anthropic just didn’t, right? Fable’s a big step up in image processing, but like they’re not known as the multimodal company, right? They’re the language model coding company that has multimodal capabilities that’s never super flex and, goes pretty far.
Eiso Kant [01:17:42]: I look, I in this I think Anthropic, I mean, they’ve done many things right, but I think this maniacal focus on just pushing capabilities, scaling up models is. I couldn’t agree more. I think it’s, it’- that’s the first hurdle, and once we get that, then we can improve a whole bunch of other things. and but at the same time, on the other end of the spectrum, it’s really exciting to see people, building these spatial models, right? That are, and the world models that are being built, like for very different, use cases. but I think ultimately it all comes together at some point.
Vibhu [01:18:19]: Okay. So scaling models, this is Laguna S for small.
Eiso Kant [01:18:23]: Yes.
Vibhu [01:18:23]: You have good naming, extra small, medium, large.
Eiso Kant [01:18:26]: Yeah.
Vibhu [01:18:26]: Still scaling?
Eiso Kant [01:18:28]: So the new medium started training, and it’s much bigger than the last medium, started training yesterday. so it’s a, 39-day training run. and,
Vibhu [01:18:39]: How do the days and events? Just the compute model
Eiso Kant [01:18:41]: Models factory.
Vibhu [01:18:42]: Okay.
Eiso Kant [01:18:42]: Right? And like at this point, like with the model factory, like it’
Vibhu [01:18:46]: I thought it was interesting. So in the Laguna medium and extra small, you even quoted number of GPU hours for how many days and whatever for different size. And I’m like, “Oh, you can also work backwards to how much that costs, right? What GPUs, how many hours “
Eiso Kant [01:18:59]: And you realize it’s not a lot.
Vibhu [01:19:00]: No, it’s not.
Eiso Kant [01:19:01]: It’s not a lot of money. and, you started with DeepSeek of the West and, I think that’s, The DeepSeek moment, right, was a moment when people realized that you can train incredibly capable models for not a lot of money on the training run. But I think that’s the falsehood, right? Like the training run is not the expensive part. The training run is a very anticlimactic event, right? Like we just had a Slack message come up yesterday saying, “The new model is training and here are the links, so you can follow along the evals,” and like that’s it. all the work that goes into that moment, it’s like how people talk I know nothing about sports, but how, like, athletes talk about, like, it’s all the preparation, it’s all the going to the gym, and then the game is just a game. I think that’s a little bit like with model training.
Swyx [01:19:42]: Yeah. People had over-indexed on DeepSeek was trained for $5 million or whatever it was, right? It’s like there’s the amount of R&D before that, the infrastructure is built up. Yeah.
Eiso Kant [01:19:51]: Exactly, all the things, the data. But no, so Laguna M is training, and yes, there will be an L and there will be an XL, and what you’ll
Swyx [01:19:57]: Ooh.
Eiso Kant [01:19:57]: What you’ll see with M, right, M is much larger than the last M, right? So these monikers are a little bit our version of the different
Swyx [01:20:04]: Yeah, he was making fun of people for saying small is 24B or something.
Swyx [01:20:08]: No, so, no. Small for Mistral now is over 100B.
Eiso Kant [01:20:12]: What?
Swyx [01:20:12]: Yeah, I can pull it up.
Eiso Kant [01:20:13]: I mean, our small, right, is 118, so I don’t wanna say anything else. Like, it’
Swyx [01:20:17]: I mean, I think it’s also. Okay, yeah, your small is
Eiso Kant [01:20:20]: We all know that the single hardest thing for any foundation model company is naming.
Eiso Kant [01:20:25]: I don’t want to say that we’re good at it either. I mean, it’this is Laguna S 2.1. It’s, it’
Swyx [01:20:32]: But at least people understand, medium is bigger than small. Until you mess that up, like
Eiso Kant [01:20:37]: Exactly
Swyx [01:20:38]: You have a pass.
Eiso Kant [01:20:38]: We try hard.
Swyx [01:20:40]: While we’re on the topic of naming, this is gonna be at the end, but might as well
Eiso Kant [01:20:43]: Sure
Swyx [01:20:43]: Why Poolside? Why Laguna?
Eiso Kant [01:20:46]: So When we started the company, it was gonna be called Snowball Apps. it was after the snowball effect because we expected this company to become a snowball effect, and it definitely has been a snowball effect for us. turns out it’s an Amazon trademark.
Eiso Kant [01:20:59]: I kid you not that my founder’s next suggestion of a name was, “Let’s call it Bedrock.” And so at this point it was like, “Okay, no, you are amazing at naming things if you worked Amazon.” and so, early on in the company, before we were incorporated, we were at an annual conference of a very big Major tech company, and we had been discussing with them. And you have to realize the company at this point is me, my founder, our CEO, Margarita. We know the first person who’s gonna join us. We haven’t, like, incorporated yet. and we were discussing an OpenAI Microsoft-style deal with this big tech company. Like, they were going to provide us with a lot of compute. We would give them, perpetual access, a whole bunch of things.
Eiso Kant [01:21:49]: And, we found out the name was trademarked, Snowball Labs, while we were at that conference and having this discussion that we had no right to have, right? We were a couple of guys who had nothing yet, but this big company was willing to entertain the fact that we might partner with them. And, we were discussing this, and it was in their annual conference in a public setting, and the chief scientist of that company said, “People can hear us here. Like, we should move somewhere else. Let’s go to the restaurant Poolside.” And for some reason, me and Jason looked at each other in that moment and said, “Oh.” and then later that night, - the name stuck with us. The word stuck with us, and we said, “Let’s call the company Poolside.” And ever since, we never ended up doing that deal, and we used it as a reminder to never turn down our, round down our ambitions, because that would’ve been the easy path. and the hard part was what we did, which is start and try to raise exorbitant amounts of money when you’re just a couple of guys who are not even building it in Silicon Valley, who don’t come from any, of the known knobs and things like this. And so everyone assumes Poolside because AGI, everyone sits Poolside, and it was a playful name, and we liked it, and it was a little bit different. But the name is, like, a reminder for us to never round down our ambitions, and whenever you’re faced with those decisions to just pick the harder path.
Swyx [01:23:09]: Yeah. I mean, that’s a great story. I know you’ve told it before
Eiso Kant [01:23:13]: Yeah
Swyx [01:23:13]: But I just wanted
Eiso Kant [01:23:14]: Right
Swyx [01:23:14]: On the record. but that’s, that’s what I did the first time I met you. You told me, you sat me down. You were, you, we were in the hotel somewhere.
Eiso Kant [01:23:21]: Yeah.
Swyx [01:23:21]: And you were like, “We’re raising a $500 million.” I’m like. And then you gave me the whole vision, and then you did it. And I was like, well, it’s, I don’t have that much opportunities to ask, like, just how do you do that raise to that to those kinds of VCs? What are they looking for? like, yes, vaguely AGI, but, like, what do they want when
Raising Huge Rounds and the AGI Investment Thesis
Eiso Kant [01:23:42]: Look, it’s, the world’s definitely changed, right? When we were raising that $500 million round, the majority of investor conversations were still trying to explain that these models were not just stochastic parrots and that they were gonna keep going. I’ve seen the world go from OpenAI is gonna win it all and there’s no one else who can build company, right? I mean, Anthropic struggled, to raise their $500 million round. That’s like, well reported. They pulled it off, gladly. and so I think when we raised that, it was about a year and a half ago at this point, the world was very different than it is today. I think the world today, There’s been, there’s been this function where the number of people who believe AGI is real, Is probably a, an, a super linear or definitely some form of an exponential function itself.
Eiso Kant [01:24:31]: And I think this is important because if you hold the belief that we had three years ago and a year and a half ago, and we looked for people who shared that belief, which is like, this technology is gonna fundamentally underpin everything that’s economically interest- or economically valuable and scientifically interesting for, like, the future, then the value function afterwards is easy to understand, which is like, hey, if you get there, you are one of the commodity, one of the players who can build this commodity. and over the years, building that commodity has become not just about building models, but also about building infrastructure and other things.
Eiso Kant [01:25:03]: And so I think today, because the number of people is bigger and the outcomes have been proven, right? I think the incredible, like, financial success that Anthropic is having right now and, like, the growth that OpenAI’s had and others and Google no longer make this a question of is there product market fit, which really a couple of years ago was, like, part of the question. Like, how big can these things be? You tell people that, like, you’d be at these amount of revenue numbers in our industry right now, people were still, like, would laugh you out the room.
Eiso Kant [01:25:33]: Now I think it’s a function of who in the world believes that it’s gonna be an oligopoly of intelligence And who believes that oligopoly can be broken by other companies. And I think that’s what divides investors more than anything else. For the ones who believe in AGI, and then you’ve got a whole layer that, is self-selecting out, foundation model companies because they’re like, “Look, I can’t make - The money I put there, compared to what I can put in an application company is very different.” I think there’s incredible application companies, and there should be many should be built. But I do think we are still in a world right now where this is the early innings - this can still be the early innings of who is going to, be part of the set of people who win. This - Intelligence is the most, in my view, gonna be the world’s most demanded commodity. It will more commoditize in margin and price. and the world wants choice and wants options. And so I think treating the world as like, “Oh, there’s only gonna be two players,” I think is very shortsighted from investors.
Eiso Kant [01:26:41]: I think that group who thought that was a lot bigger at the beginning of the year than now.
Eiso Kant [01:26:46]: I think the last couple of months have woken up a lot of people and going, “Holy s**t,” like, the world both can use a lot more intelligence, but also, like, the world is far more complex. We should have multiple choices, more options, things that can be turned off, that can’t be, that. The restrictions that people put on models now, I think, is another area of this, right?
Eiso Kant [01:27:08]: Like, the fact that We are entering into a world where model companies are saying, “You’re not allowed to use me for foundation model company development.” They should be allowed to do this. It’s capitalism. It’s their business. It’s their work product.
Eiso Kant [01:27:23]: But it is insane.
Eiso Kant [01:27:25]: It is wild that we are, like, okay with that.
Open Models, Democracy, and Regulation
Swyx [01:27:30]: Do you have more problem with Anthropic saying it or the White House saying it? that-- that you’re picking Two different
Eiso Kant [01:27:37]: Things
Swyx [01:27:37]: Limitations and restrictions there.
Eiso Kant [01:27:39]: Look, I think I, - I’ll put it this way. I think we wanna, as this technology gets more capable, for the better and worse, we do wanna yield to democracy to figure this out more and more. I think any single company making unilateral decisions, is, Is dangerous. It’s a concentration of power in a small number of people with very limited checks and balances. and that has never worked out well in history, in any way, shape, or form. and this is not a criticism on the existing foundation model companies. This is just more commentary on, like, how I’d like the world to be. I think in a world where the technology gets more capable, government needs to play an active role in determining, where is there real risks of misuse, right? And I do think we need to separate safety between misuse, and, doomsday scenarios that, I think No one knows if gonna, are gonna happen or not. And I think just, like, very practically, I think, I’m glad to see there’s a lot of conversation now starting to happen again at the government level of trying to figure this out. and now what the final decisions are, maybe I’m happy about them, maybe I don’t, maybe I agree, maybe not. But ultimately, like, that’s democracy always, right? Like, at any given moment, I might not be perfectly happy with one or the other, but people chose to vote in someone to make those decisions. And so I think over the long run, over a 20-year time span, the world directionally goes correct and democracy does work. At least, what’s the famous quote of like it’s the worst of - It’s the best of all the worst systems or something like that.
Swyx [01:29:26]: It’s the worst form of, organization except for all the others that we’ve tried.
Eiso Kant [01:29:30]: Exactly. That’s the one.
Swyx [01:29:31]: You can always count on me for a Churchill quote ‘cause I’ve, studied Churchill a lot.
Eiso Kant [01:29:35]: I love that. and so that’s what I hope for. Now, I do think we are in a critical moment of time, and so speaking up for anyone is important. I think, researchers who are thinking about starting their own foundation model companies start. people who wanna share their opinion and be vocal, if that’s with their representatives or just out on X, like, do so.
Eiso Kant [01:29:57]: And but concretely to your point, I think we are not at a level of capability right now that we should start restricting, open models in any way, shape, or form. I think it will hurt innovation if we do so.
Swyx [01:30:14]: Is there a point at which you will change your opinion there?
Eiso Kant [01:30:17]: Yes. I mean, look, - And there has to be.
Swyx [01:30:19]: Yeah.
Eiso Kant [01:30:20]: Right? Like, you cannot. If you sit with a straight face and say, “This can be open forever in every way, shape, or form,” it is just as, I think, egregious as saying, the opposite of it all needs to be closed down right now. Like, I think at any ends of extremes of spectrums is where we go wrong.
Eiso Kant [01:30:41]: Right? In society in any way, shape, or form. And so the answer is always more nuanced, and the answer is never black and white. And so I think as we encounter, like, real world scenarios where we have to say, “Hey, we have to be more careful,” we need to reevaluate. If that means training a model differently and opening it up, having different versions, some things that, That are restrict-- I think that’s totally okay because I don’t think anyone should be irresponsible. What I do wanna call out is that people have been calling for the fear of misuse of these models since 2, Right? And I still remember, like, “We cannot release 2 because the whole world will get “
Swyx [01:31:20]: I mean, that was Dario.
Eiso Kant [01:31:21]: And so, like, this is not a commentary on Dario, it’s a commentary just in general in the space. And so We have not been very good at this so far, and we need to get better at it. And I do think that the work that’s happening with, like, safety institutes and better evals and things like that is probably the right direction.
Swyx [01:31:38]: Yeah. I mean, I wanna say something in defense of this. It’s better to err on the side of safety and then roll it back rather than the other way because the other way, it’s a one, way decision. I think that’s, I think that’s true.
Vibhu [01:31:53]: The caveat there is also the competition, right? You don’t have global error on the side of safety, right? You’re talking
Swyx [01:32:01]: Yeah, exactly.
Vibhu [01:32:02]: So Oh, yeah
Swyx [01:32:02]: You don’t get to do unilateral safety because someone else will just be more unsafe than you.
Vibhu [01:32:06]: Yeah, exactly.
Swyx [01:32:07]: Yeah.
Vibhu [01:32:07]: You can pause innovation here. It doesn’t mean it’s, it’s pausing elsewhere.
Swyx [01:32:11]: They’ll just take over the world. It’s so easy.
Eiso Kant [01:32:13]: They’re, they’re complex parts.
Swyx [01:32:14]: Yeah.
Eiso Kant [01:32:15]: Right? And I think we are much better off talking about certain capabilities that we can, commonly agree on and internationally agree on that we want to, limit or not have available, than we should talk about it in black and white of models available, yes or no. Like, the moment you start getting these big blanket statements, it’that’s when you start getting at the risk of, like. I always think back about when we banned advertising on cigarettes. Good thing. I’m not saying I’m against that. But it effectively established an oligopoly of cigarette companies because no one else could ever compete. and it was the, probably the best moment to the tobacco industry that ever happened, And we don’t wanna do that right now. If we pull up, walls behind innovation, and this is a self-serving comment because I’m not at the frontier yet, but it’s not just related to me. I think it’s related to everyone in the space. you are deciding right now in 2026, based on the current capabilities of models, that this is something that only two or three companies can build, and that to me reads like chapter 14 of the most dystopian fi novel that I could read because from there I think you can play out all the scenarios that happen in the world, and none of those are the ones that make me, excited about the future. and I think that’s the thing we should all think about. Like, what’s the future we wanna be excited about? What do we wanna have? And I think that’s a future where intelligence is a commodity. Everyone can access it. It becomes cheaper and cheaper, right? I think that’s important. It can, like, impact more of the world, and it’s not one where, a single company puts their thumb on their scale of both what it outputs, to or turns it on or off.
Nvidia, Hardware, and the Compute Stack
Swyx [01:33:56]: I think the one entity that has more power than the US government here is Nvidia.
Swyx [01:34:02]: Because, like, whoever gets the allocations gets the compute.
Vibhu [01:34:06]: You can take it down to TSMC or,
Swyx [01:34:09]: And TSMC below that. But I just wanna test provocative statements to see if you have any response.
Eiso Kant [01:34:18]: I need to think on that one.
Vibhu [01:34:20]: Which I think they are regulated, right? Like, you can see the government
Swyx [01:34:23]: Nvidia’s not regulated.
Vibhu [01:34:24]: Can they ship to China?
Swyx [01:34:26]: Okay, but they’re not China.
Eiso Kant [01:34:30]: Look, I think this industry Has existed because of what Nvidia’s done.
Swyx [01:34:35]: Yeah.
Eiso Kant [01:34:35]: Right? I know they-- - People like it’s easy to give them flack, but I also wanna say, like, I remember when we started Source, right? In 2015 post that capacity article. It was able for this progress to happen because we were able to put consumer GPUs in servers, and they allowed us to do so, and then, like, and you kept going further. And so this is something, like, foundation models are so closely linked to their hardware and their systems.
Swyx [01:34:58]: Yeah.
Eiso Kant [01:34:59]: Why do we see these stepwise progress happening? We see them happening because of the next generation of networking and systems that come out, right? The difference of a model you could train on Hoppers versus GB300s is the difference between a trillion-parameter model and a five or six trillion-parameter model. And so these things really coexist, I think, very closely to each other, and I think the more interesting question, I think, for the future is going to become of, like, how do - what can we unlock in terms of model capabilities, like, as we start designing these things even more? And we’re seeing that with, like, the next generation of systems. And I think the world, abhors.
Eiso Kant [01:35:42]: Like, capitalism does a really good job at trying to, like, push towards things that - that allow for more competition, right? And Nvidia allows for competition. It’s not. But if a government says no one else can build foundation models effectively through the regulation, that is very different. Now, is it hard to go build an Nvidia? Absolutely. Is it hard to build a foundation model? I think it’s very hard to build a foundation model. But we should, like, make the playing field one that where, if someone wakes up tomorrow and wants to do so, they are, like, allowed to do so, and they’re allowed to use the tools to do so. And I think there’s still a big difference between what we’re seeing in the discussions around model companies versus what we’re seeing with chip companies.
Vibhu [01:36:25]: The gap also seems to be the expertise in who regulates it, right? Who at the government decides what’s too safe, too smart, too dangerous? but while we’re throwing spicy questions out there, do you have anything that comes to top of mind that could be changed? So, should OpenAI, Anthropic, open source models? Is it open weights? Is it what we do in RL that determines, your safety barriers? Is there anything that should be done there or just spitballing?
RL Bottlenecks, Mixed Hardware, and Low-Precision RL
Eiso Kant [01:36:53]: That’s a good question. yes. one of the things that I’m excited about that I think we’re more and more talking about, I don’t think anyone is doing yet, is, mix and match of hardware during RL training, right? Like, - You think about, like, the notion, and we’re seeing this in inference, right? The prefill and decode
Vibhu [01:37:15]: Yeah
Eiso Kant [01:37:16]: Just work better with, a general purpose, GPU and a more specialized, like, chip, right? Like, if the Groq chip at Nvidia, the LPU and the GPU combined, and there’s different versions of that in the industry. And RL is batch size constrained, Right? So, like, you are ultimately-- and then you’re batch size constrained because you don’t have infinite tasks, right? When you’ve got the entire web, you can be much more flexible in scaling up your batch size because you’ve got the entire web. But for RL, you have, X millions of tasks that you are gonna be training on, and so you cannot blow up your batch size massively, which means that you can’t scale compute to a certain extent with RL the same way you could scale compute with, like, training. and so I’m very excited about anything that improves that. And I think one of the best ways to start improving that is the things that we’re already starting to see in inference, which is the separation of the prefill and decode to different chips to come to reinforcement learning, right? and I think we’ll be there soon. and I think more people should be working on this, because then all of a sudden we’re able to just be way more efficient in how we train RL from a wall clock time. Again, coming back down to the fact that it’s a race, right? The race is measured not in how many GPUs, but the race is measured on calendar time, and that’s probably one of the biggest impacts we can have right now to speed up our industry. and so that’s one, like, technically I love geeking out about and talking to people. Yeah.
Swyx [01:38:45]: Yeah, I would talk to Etched. I had a tour of their data center and, physically you can see how PD disaggregation is mapped out in the data center, and you have to own your own hardware to do that.
Eiso Kant [01:38:57]: Yeah. No, look, I think it’- I think more innovation in the space is just, like, is the coolest thing.
Swyx [01:39:02]: Yeah.
Eiso Kant [01:39:03]: And so I’m, I’m excited because that’s like, all of us are.
Eiso Kant [01:39:09]: Like, why don’t we finish, post-training this model, whatever, two weeks before release? Or no, sorry, between release, between training, then, training SFT, and then the time it takes for release. My biggest wall clock bottleneck right now is RL time.
Eiso Kant [01:39:25]: Right? And it’s just because I can’t scale it up further because I can’t add more GPUs to it because of that batch size constraint. There’s a really cool, blog post that just came out that was showing, RL done in even lower precision than any of us are doing. I thought this was really cool. So just what date is it today? We’re on July 15, so this came out five days ago. and I thought this was very cool. I think, lower precision RL, while keeping it stable, we’re, we’re still doing this in FP8, and so, I was excited to see them sharing this work and bringing it out. it’s definitely something that I’m excited to be doing once we move to Blackwell GPUs.
Swyx [01:40:05]: But yeah, cool. Part of open research, you take and you give.
Eiso Kant [01:40:08]: Exactly. Yeah.
Swyx [01:40:10]: I’ll just quickly mention, there was a paper that did a ablation on, levels of quantization, and they roughly concluded that four bit was the sweet spot. But I don’t remember
Eiso Kant [01:40:20]: This was just a couple of years ago, right? I think I remember this.
Swyx [01:40:22]: I think one year.
Eiso Kant [01:40:23]: One year, okay.
Swyx [01:40:24]: But like, I’m like, okay, maybe NVFP4 is it. You can’t really-- Like, the lowest you can go is ternary.
Eiso Kant [01:40:30]: Yeah.
Swyx [01:40:30]: That’s it. Like, there’s not that many.
Eiso Kant [01:40:32]: Well, I mean, there’s, there’s, there’s still quite a difference between NVFP4 and four bit, right, in terms of what’s, what’s possible. But I think NVFP4 is, underrated in terms of what it is. I’m, I’m quite excited that - when it came out, it’s, just getting that extra, like, that trade-off between range,
Swyx [01:40:51]: Yeah
Eiso Kant [01:40:51]: Is very cool.
Swyx [01:40:52]: A couple quick closing questions.
Vibhu [01:40:54]: I have a quick one.
XS, S, Distillation, and Model Cadence
Swyx [01:40:55]: Yeah.
Vibhu [01:40:55]: Okay, quick question back to technical side. So any big takeaways from XS 2.1 medium to training the new small, just general in terms of training models? You mentioned a lot in the earlier discussion about, okay, in training, there’s a lot you can squeeze out, right? You can learn a lot more from the web. at the same time, you took 30B and scaled it up to 120B, right? is there any gating on how small is too small? So I’m, I’m just gonna ramble for a bit. I’ll come to a question at the end. But, part of Carpathy’s thesis was cognitive core, right? We’ve seen Vipe Thinker, Nanbase, 3B, 4Bs that reason a lot, and then, the idea is you offload to a different model for the work. This, these are small reasoning models. So have you found anything interesting in model sizes, like 20, 30Bs on device, 100Bs on single GPU? can you squeeze out more there?
Eiso Kant [01:41:56]: There’s a lot more to squeeze out. like, I think, not to make too many forward promises, but I think we can squeeze a lot more out of the XS size as well. and I think we learned a lot during S training that will allow us to improve XS, like, size even further. And I think already since then we have learned things that could have made S even better. I think there is a lot more still for, like, our space to squeeze out of models much smaller. I don’t think that’s an argument against scaling. It’s just an, And one, by the way, and I think this is a nice thing that, it’s really-- it’s not very helpful to have, a post-training recipe for a smaller model and try to apply it to a bigger model.
Vibhu [01:42:38]: Yeah.
Eiso Kant [01:42:38]: It just, in all cases, you’re gonna have to rethink most of the recipe. But, recipe for post-training for a bigger model applied to a smaller model is almost always just a really good, like, improvement and baseline. You can still tweak it more, but I don’t think that’s necessarily, like, obvious. and so - once you make your bigger models better, you often have a quick lever to quickly improve your smaller models again. but will we be able to squeeze a lot more out of smaller models? Laguna S gave me a lot of confidence that I think we can. and I think it’s around that discussion we had earlier about that it’s about the behaviors, not necessarily the raw intelligence, that you’re trying to improve the models for.
Vibhu [01:43:23]: And that’s on all axes of, There’s like an axis of how long a model will reason, so how long can it stay agentic, then there’s also efficiency, right? You wanna ideally push on both. And the thing to clarify you guys aren’t doing right now, which we do see at Frontier Labs, is the distillation, right? You have a big model that you don’t really ship to users, and what you put out for inference is typically distilled from that, which gets you quite a bit of gains, right?
Eiso Kant [01:43:50]: Look, I think it’s, it’s something we don’t do right now because of, like, why we’re also, like, building these models, right? These models are for us part of our research path. So we’ve, Laguna Medium was much larger than the last two models that, this one and last one that we’ve released and we’ve trained even bigger models in the past. So there is the engineering component of, like, a bigger model and every order of magnitude size, you’ll learn new things in training about stability. But at smaller model sizes, you are able to just iterate a lot quicker, like internally, right, on your research. And so, for us, distilling down to a smaller model doesn’t serve the purpose. These models are. It’s not the right term, but to us they’re dual purpose models. They are progress for us to weigh to see did we improve in the model factory and something to put out into the world. and so that’s why we don’t do it. We’ve done distillation experiments, and there’s, like, really cool things you can do, and I think if you have lots of user data, then, you can go even further, right, in that. But I think there’s something to be said in having a quick cadence of models trained end from scratch so that you as a research organization can learn the lessons and not wait. That was one of the big lessons we learned over the years when we used to have a much
Eiso Kant [01:45:09]: Longer cadence between model trainings, like six months, and we would train just, like, a big model, wait six months, train another bigger model. you would be compounding so many changes of improvements That at the by the time you’re training your next model, it’s a bit of a soup, and you don’t really know what ingredients led to the outcomes. So when you are training far more frequently models, and this holds true for both post-training, and from training from scratch, you are much more able to get an understanding of what led to the improvements. and I think that’s important. Like, ultimately, we are all still. There is no true science yet of, deep learning for large language models. but we are all, I think, trying to gain insights from our experiments because it’s those insights that lead to scaling laws, that lead to the improvements that allow us to be, again, more compute efficient and get more capabilities.
Swyx [01:46:02]: Yeah. amazing. I was gonna end off with a little bit more history. you spent some time looking at, metrics for engineering team productivity. How do you think about engineering team productivity today?
Engineering Productivity in the Agent Era
Eiso Kant [01:46:14]: I mean, it’s wild, right? I mean, it’s the, it’s like the golden age. Like, it’s the fact that you can just take an idea and build something by waiting overnight for an agent to do the work.
Eiso Kant [01:46:26]: I don’t know. To
Swyx [01:46:27]: Like, how do you measure when.
Swyx [01:46:28]: ‘cause you literally in a theory
Eiso Kant [01:46:30]: Yeah.
Swyx [01:46:30]: You’re doing this, right?
Eiso Kant [01:46:32]: Look, I think It’s a good question. It’s one I haven’t thought about in a long time.
Swyx [01:46:36]: But, you’re qual- you’re pretty qualified to do it.
Eiso Kant [01:46:38]: No, I’m gonna. - No, it’s a fair point. Let me take a second to think about it. Look, ultimately, what is code, what is software, what is engineering is to go from something that is valuable for an end user or sets of end users, like an idea, an extra, a bug fix, a feature, to, like, delivering that value. And I think what we’re doing with these models becoming more capable is that we are massively like, both cutting out middlemen and compressing the time that it takes to deliver that value. And ultimately, that iteration cycle for any startup or any company is what allows you to win, right? If you’re able to solve a bug in two hours versus it staying in the back log for three weeks, if you’re able to, like, be on a customer call and learn, hey, if this feature existed, it would, like, they’d be willing to pay more, and it’s more valuable to them, and you ship it in a week instead of in a month. And so I think ultimately, maybe the same things that we looked at years ago LLM still apply, and it’s just the notion of cycle time. But in this case, it’s lead time from the moment you have a valuable thing that you are looking to do for someone to the moment that it’s shipped to them. Every other metric is ultimately a leading indicator for that lagging indicator, right? It doesn’t matter if you’re looking at amounts of code, PR, reviews, all of these things. And so I think in this case, we are starting to move so quickly in some of these things that we can just sit back and look at what was traditionally the lagging indicator. We just named it the lead time from traditionally ticket to, like, an end result. what I would look at in this new world, that maybe we didn’t think about before is how much can a single person do with that,
Eiso Kant [01:48:22]: Right? One of the most, like, if you look at AI native companies, they’re not designed like the engineering orgs of, LLM age. They’re designed with often just the builder, right? and as close to the customer to the ability to ship. there isn’t necessarily a huge team in between that sits there. And I think that is, I think, is exciting, like organizations where a single IC can just, get much closer to that. So I would look at From where the value sits that’s identified to the moment it’s shipped and how many people are involved in that. And you want the amount of people involved in that to be less, and you want the time end to be shorter.
Swyx [01:49:05]: Okay. is there a way to eval that when you’re, interviewing somebody?
Eiso Kant [01:49:12]: Oof.
Swyx [01:49:13]: ‘Cause that is,
Eiso Kant [01:49:14]: Look,
Swyx [01:49:14]: The most compressed version.
Agency, Constraints, and High-Impact Teams
Eiso Kant [01:49:17]: I think the common answer to this is agency.
Swyx [01:49:20]: Yeah.
Eiso Kant [01:49:20]: How much agency does a person have? I think in the age of AI getting more capable, agency becomes probably one of the most important qualities for anyone. and I think agency is something you can look for in, what people have done in the past because agency is something that if you have it, you are demonstrating it, right? No one has just agency and is sitting back and not, like, exercising it. The whole definition of it is that it’s exercised. And so understanding, like, what were things that people did in their lives, in their professional and their personal projects that showed agency and, your personal backstory shows a ridiculous amount of agency.
Swyx [01:49:56]: Oh, dear.
Eiso Kant [01:49:58]: Like, I think that is ultimately it. It’s the Silicon Valley, quota the, of the last, year and a half or so is like you can just do things, right?
Swyx [01:50:06]: Yeah.
Eiso Kant [01:50:07]: That- that’s I think what you’re looking for.
Swyx [01:50:08]: I think then aligning high agency people is very hard because they all wanna go their own way. That’s the whole point, right?
Eiso Kant [01:50:15]: They-- Yeah, but I think the notion - Like, I think the notion of a good leader, right, in an organization is to be able to bring people together around, like, a common outcome. And I think what you wanna do with anyone who’s high agency-- I feel very lucky I’ve got an organization with incredibly high agency people. Like, I mean, I’m not the one who built the model, right? I cannot stress this enough. Like, it’s the team that, like, achieved this, and it’s a team that is incredibly high agency. And so if you look at, like, what does it take to bring that together, it’s, it’s ultimately a common goal and a common set of boundaries. Because if you allow to just go, “You can do everything,” you become an exploration algorithm. And this is what we see in big tech, right? In research, in big tech, everything is an exploration algorithm. Everyone can do anything as long as - And then it becomes political about gathering the resources. So when you say, “This is our common goal, and these are the boundaries that we’ve set,” right? “We’re not multimodal. We focus on RL.” Like, we do these things, and you’re upfront with people before they join the company, you get a lot of agency. You can run where you want, but these are the places where we
Swyx [01:51:24]: Yeah, lanes
Eiso Kant [01:51:24]: This doesn’t make-- This is the lanes
Swyx [01:51:25]: Yeah
Eiso Kant [01:51:25]: That makes sense. I think it gets the best out of people because, like, innovation comes from constraints.
Eiso Kant [01:51:34]: We did this with relatively little compute and relatively little money compared to some of, like, the others that are out there. and I’ve thought back on that quite a bit recently and thought, it was a good thing Because those constraints forced us to become much better in certain other axes that might-- others might have not, right? We purchased relatively little external data.
Swyx [01:52:01]: I was gonna ask about that. Yeah.
Eiso Kant [01:52:02]: Exactly, right. That was a constraint. but it’s a constraint that pushed us to move on other areas to improve. And like, and there’s lots of versions of that. So I think high agency people, you wanna empower, you wanna get them really excited about what they’re doing, but you also wanna say, “Hey, if you join this mission, this is the outcome I need you to achieve. But these are the places that we don’t go, and maybe if you care about those places, go somewhere else.”
Swyx [01:52:26]: Yeah. Great. last call to action, who are you hiring?
Hiring, Impact, and Closing
Eiso Kant [01:52:31]: We are hiring on every possible role in applied research and engineering in the company. so from
Swyx [01:52:36]: Yeah
Eiso Kant [01:52:36]: Training all the way to evals to post-training architecture. Like, we are still in a world where, individuals can have massive impact. And I think our pitch to join us, it’- We spoke a lot about the mission, how we think about things, but I think we are one of the places where it’s the highest ratio to individual to impact, Right? Less than 70 people built this model. Less than 115 between engineering and researchers, like, together did this effort, and that’s a very broad definition ‘cause I put myself in the 115 list.
Eiso Kant [01:53:08]: And so being able to do this work on a mission that you’re aligned with, and you can have that - every individual still has huge impact. And I think
Swyx [01:53:18]: And being able to publish, being able to open
Eiso Kant [01:53:20]: It’
Swyx [01:53:20]: Open source the model.
Eiso Kant [01:53:21]: Yeah, look, all of those things are part of that. But I think ultimately, when you can today pick between joining a very large foundation model company But you are one of many.
Eiso Kant [01:53:35]: And not by any fault of them, but just by definition, the denominator has become really big. And our denominator is quite small, and so the level of impact you get to have is really high. And I think ultimately all of us, the most incredible high agency people I know, what are they optimizing for? They’re optimizing for impact. they’re optimizing for impact, and am I aligned with the mission? And if today you heard about the mission and aligned and you’re optimizing for impact, I think we’re a really good place to join.
Swyx [01:54:05]: Okay.
Eiso Kant [01:54:05]: Awesome.
Swyx [01:54:05]: I think we end it there. That’s a fantastic statement. You did amazing on four hours of sleep.
Eiso Kant [01:54:11]: Thank you, guys.
Swyx [01:54:12]: So, podcast eval, definitely approved.
Eiso Kant [01:54:14]: Appreciate it. I literally wrote it down. My eyes are, like, starting to go like this. I’m like, “Phew.”
Swyx [01:54:17]: We’ll let you go. We’ll let you go back.
Eiso Kant [01:54:19]: It was good to see you guys.
Swyx [01:54:19]: Thank you for setting this up. We wanted to get this in because we think it’s a great model.
Eiso Kant [01:54:23]: Appreciate it.
Swyx [01:54:23]: I think a great story to tell. Thank you.


This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit www.latent.space/subscribe

Bet on information
If test loss flatlines after 1.5B parameters while training loss continues to drop as you scale, that tells you that your model is limited by the amount of information in your data.

Training on a single, smallish data set exposed an information gap: the 3.1B model falls off the scaling trend. Neither parameters nor compute will improve performance past this wall. For predicting changes to gene expression, you need more information rich data.
This is what Chu and Bo’s teams have done, and here is what ~30x the information buys you:

Now we can scale with parameters and training compute! We don’t know how much this effort costed, but we can guess that data collection experiments and infrastructure was a few tens of millions, and compute + headcount + research was a few million. The budget looks like a RL rollout budget, rather than a data rich pre-training one.
We were lucky enough to have the two central figures in this story on our podcast. Taking the lead from Ci Chu and Bo Wang, Xaira Therapeutics is betting that information rich data is the key to AI-driven drug development. Chu was recently promoted to Chief Discovery Officer and Bo to Chief AI Scientist, underscoring just how strategic Xaira considers this bet.
Reverse engineering the human cell
If you had to figure out how a human cell works, what would you do? A good place to start might be by documenting what genes are expressed (e.g. what RNA is floating around) in different kinds of cells, in different circumstances.
That is CELLxGENE, a database of 168M cells built by Chan Zuckerberg Institute that maps each cell to a count of how many times 20K-30K genes were detected in that cell, plus detailed metadata about every cell. A ~4 trillion-entry matrix.
If the Protein Data Bank (PDB) unlocked structural biology models (Boltz Episode, ESM/BioHub Episode), CELLxGENE has done the same thing for Virtual Cell models. Like PDB, CELLxGENE has inspired a zoo of AI models of RNA expression; so much so that RNA expression models have become synonymous with Virtual Cell models. Bo Wang built one of the most influential, scGPT, that became the starting point for Xaira’s new model.
RNA expression ≠ Virtual Cell
Models trained on CELLxGENE describe the relationship between cell types and cell states, but they are not good at predicting what will happen if we make changes to RNA expression. Changes in gene expression are highly correlated, and its is difficult (impossible) to figure out what causes what in most cases.
If you could “turn the dial down” on one gene at a time, however, then you would be able to observe what is upstream and downstream of a given gene. You could tell if A → B & C or B → A & C or B → A, C → B → … If you did this for all of the genes, then maybe you could train a model that could predict what would happen to a cell if you change a gene (e.g. with a drug or a gene edit). Or maybe you could figure out the least invasive way to change a particular gene’s expression.
X-Atlas → X-Cell
This is exactly what Chu and Bo’s teams have done. The data set is called X-Atlas and the model is called X-Cell.
In this episode, we discuss:
* Why the team abandoned autoregression for diffusion
* The CRISPR-based experiments that run millions of tests in parallel, and generate the raw data for X-Atlas and X-cell
* Generalization to real lab experiments in real human cells
* Beating the linear baseline that has outperformed previous models
* Justifying a kitchen-sink of priors, and how that stacks up vs. data and architecture
Bo also shared with us some of the (major) advantages he has as an academic vs. industry leader, and how his labs keep up with the breakneck pace of AI innovation.
Check out the full episode on YouTube, or your favorite podcasting platform!


This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit www.latent.space/subscribe

Imagine a dark warehouse. Racks and racks of devices with wires, tubes, and electronics sticking out. The next AI data center? No. This is Lila Sciences‘ dream for the future of science. A dark warehouse full of AI-guided robotics and lab equipment, cranking out new experiments 24/7, building toward a scientific superintelligence.
Their automated lab is almost hypnotizing to watch. They have floating plates zipping around on Wall-E-esque tracks, used vision-language models to control Windows 95 boxes, and created the world’s largest collection of voided warranties. In the process they’ve built a massive library of scientific reasoning tokens. Over 10 trillion of them, all experimentally validated.
No warranties were voided in the making of this video
To say Lila is ambitious is an understatement. Their goal is a scientific superintelligence wired directly into the wet lab. They are all in on the bitter lesson, and the thesis follows from it: a lab is an infinite token generator. Produce data at scale, and the synergies give you a general reasoner that can tackle any scientific problem. They are committing hard. Biology, chemistry, drug discovery, and materials science, all at the same time. Time will tell if it works, but it is an exciting hypothesis.
In our latest episode we sat down with Lila’s very own Andy Beam (CTO) and Rafa Gómez-Bombarelli (CSO, physical sciences) and went on a journey through the possibilities of AI-run science, almost as wide-ranging as Lila’s goals.
Did we mention they do both materials science and biology? In the same AI science factory? Same time, same lab, same AI. Finally a guest who can settle a long-running debate we’ve had amongst ourselves: is biology or materials science harder?
Watch to find out!
We discuss:
* The internet is spent, science is next. Why Lila thinks the scientific method is the last untapped internet-scale dataset, and why they treat RL as a data generation mechanism with nature as the verifier.
* The lab as a data center. Instruments as nodes on a graph, a magnetically levitating “PCI bus” transport layer between them, orchestration as a slurm queue. Andy is not short on analogies.
* Why Lila insists it is not an automation company. They optimize for flexibility and generalizability over raw throughput, which means humans stay below the API line wherever automating does not pay.
* Your experiment has a runtime. We put Escalante Bio’s question to Andy: if science is the token generator, what is the runtime of your data collection? His answer, in short, is that you cannot make the ribosome go faster. Why Lila bets on fast round-over-round iteration rather than big noisy multiplexed screens, and how Rafa’s team rebuilt a gas sorption measurement to run roughly 2,500x faster.
* What is actually in 10 trillion scientific tokens. Not sequences. Experimentally verified reasoning traces, a kind of data that Andy argues exists on the internet in quantities that round to zero.
* Breadth as a path to depth. Small molecule chemistry priors transferring to metal organic frameworks for carbon capture, and the claim that the general model beats domain-specific models sample for sample.
* If you have the data, what do you need the model for? Sri Kosuri’s koan about the ML-for-drug-discovery business model, and Andy’s answer: the coding model got better because it also read Shakespeare and carnitas recipes.
* The serendipity they want to automate. Emily Whitehead survived the first pediatric CAR-T cure only because the doctor treating her happened to know, from pediatric arthritis, which antibody would blunt her IL-6 response. Roll that dice again and you probably lose her. Breadth is how you stop depending on luck.
* Move 37 for catalysts. Model suggestions for platinum-group-free electrocatalysts that went from boring, to what a 40-paper expert called stupid, to the best performers they have made.
* Six months to in vivo CAR-T data in non-human primates, and the zero-FTE virtual startup commercial model that fell out of it. For context on why that number is startling, AbbVie paid $2.1B for Capstan on the strength of preclinical in vivo CAR-T data.
* You cannot have scientific superintelligence if you are just a good test taker. Ken Stanley, who wrote Why Greatness Cannot Be Planned, runs open-endedness at Lila. RL at scale gives you a ruthlessly Vulcan problem solver. Machine creativity is a different thing, and it is the part nobody has solved.
* The chain of thought is an unreliable narrator. The model reasons in latent space and only emits tokens. Sometimes it skips the experiment entirely and is still right. So how much do you trust the reasoning versus the verifier?
* Reward hacking when the rollout is physical. Chains of thought that collapse into repetition, and a model that got annoyed and swore at the scientist who kept asking it to redo a plate map. What happens when a pathological loop has a wet lab inside it?
* The bittersweet lesson. Rafa’s inversion of the bitter lesson: in AI, scaling is a roadmap. In materials, scaling is a filter, because only the things that scale end up mattering.
* Not your typical Flagship company. Why a famously single-asset biotech incubator spun out a platform bet, and Andy’s line that if Lila called itself a biopharma it would have a top-three GPU cluster.
* Bottlenecks they would remove by fiat. Sim-to-real for physics-based simulation, and the fact that RL training runs at roughly 5% mean FLOP utilization.
Watch on YouTube:


This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit www.latent.space/subscribe