AI Agents That Reason and Code with Imbue Co-Founders Kanjun Qiu and Josh Albrecht

The future of tech is 25-person companies powered by AI agents that help us accomplish our larger goals. Imbue is working on building AI agents that reason, code and generally make our lives easier. Sarah Guo and Elad Gil sit down with co-founders Kanjun Qiu (CEO) and Josh Albrecht (CTO) to discuss how they define reasoning, the spectrum of specialized and generalized agents, and the path to improved agent performance. Plus, what’s behind their $200M Series B fundraise. Kanjun Qiu is the CEO and co-founder of Imbue. Kanjun is also a partner at angel fund Outset Capital, where she invests in promising pre-seed companies. Previously, Kanjun was the co-founder and CEO of Sourceress, a machine learning recruiting startup backed by YC and DFJ. She was previously Chief of Staff to Drew Houston at Dropbox, where she helped scale the company from 300 employees to 1200. Josh Albrecht is the CTO and co-founder of Imbue. He also invests in other founders via his fund, Outset Capital. He has published machine learning papers as an academic researcher; founded an AI recruiting company that went through YC and a 3D injection molding software company that was acquired; helped build Addepar as an early engineer; and served as a Thiel Fellow mentor. He started programming as a kid and began working professionally as a software engineer in high school. Show Links: Kanjun’s LinkedIn | Website | Google Scholar Josh’s LinkedIn | Website | Google Scholar Imbue raises $200M to build AI systems that can reason and code Sign up for new podcasts every week. Email feedback to [email protected] Follow us on Twitter: @NoPriorsPod | @Saranormous | @EladGil | @Kanjun | @JoshAlbrecht Show Notes: (00:00) - Introduction to Imbue (04:55) - The Spectrum of Agent Tasks (08:43) - Specialization and Generalization With Agents (13:03) - Code and Language in AI Agents

Speaker names marked ? are inferred from speaking time and the show’s known hosts — they are not voice-verified.

• 0:05Sarah Guo?

  Embu is a company developing AI agents that can reason and code. Today, Alad and I sit down with Kanjun Q. and Josh Albrecht, co-founders of Embu, to discuss training large foundation models for high-level reasoning, why agents require architectures different from large language models, or language token prediction models, and how current computers are getting in the way of their users. Kanjun, Josh, welcome to No Priors.

• 0:30Speaker 01

  Thank you.

• 0:31Speaker 02

  Thanks.

• 0:31Sarah Guo?

  So perhaps you can start by just telling us the story of how you guys know each other and where the idea from Embu came from.

• 0:37Speaker 01

  Josh and I met at a conference and then started a big house together. It was a big house, 20-person house, and also started this first company around the same time. I've always been really interested in agency and kind of like, how do we enable humans to have more agency? And Josh has always been really interested in AI. And so, it kind of made sense. We, at that time, talked about like, oh, you know, someday we're going to be able to have AI systems that give humans a lot more agency. Fast forward to 2018 or so, we were running an AI recruiting company called Sorceress. And that was actually kind of the first AI agent that we built.

• 1:19Speaker 01

  It was, you know, not transformer models, like more old-school NLP. But it was a system that recruiters used and kind of automatically got candidates in their inbox. And we learned a lot about, oh, if you have an autonomous system like this, like what do you actually need to make it work? And around that time, some of our housemates were building GPT-3. And we were seeing like, oh, scaling works. You know, if we just keep scaling, actually, you're going to get pretty far with a lot of these language models. So our question at that time was, you know, how far can we get with language models? Does this kind of self-supervised learning, which is working so well on language, work in other modalities as well? So in early 2020, that's when we first started seeing self-supervised learning

• 2:04Speaker 01

  working across video and images and language. And we were like, huh, there's something really interesting here where maybe machines are learning the same kinds of representations or similar representations to what humans are learning. And maybe they can get to a point where they can actually do the types of things that humans are able to do. And that's when we first started Embu, or started talking about Embu.

• 2:25Sarah Guo?

  You clearly know a bunch of people working at sort of large language model research labs well. When you looked at what they were doing, how did the focus come to be on agents in particular? And how is that different from a general language model?

• 2:39Speaker 02

  Yeah, I think we've always been interested in agents in not just, you know, recommender systems or classifiers or things like that, but in systems that are going to go do a real work for us, right? That are going to actually be useful in the real world. Right now, you can ask some kind of chatbot something and it'll give you back a response. But the burden is sort of on you to go do something with that to verify whether it's correct or not. I think the real promise of AI is if we can get systems that can actually act on our behalf and can accomplish goals and kind of do these larger things and sort of free us up to focus on the things we're interested in.

• 3:10Speaker 01

  Yeah, one thing that I think we often forget because we're in it every day is our computers are actually like, they need to be micromanaged. The reason we're in front of our computers every day is because nothing really happens. Like, they can't make decisions on their own. Nothing really happens unless I'm in front of it. And I'm like in front of it doing all this really detailed stuff, kind of like operating a factory machine with all of these like little knobs that are really specific. And there is a future where computers don't need to be micromanaged that I can like give a computer an instruction, whether it's natural language or something, some other kind of instruction, like it can go off and understand what I'm trying to do and help me do it. The diff between this, where we are today, and that is kind of like the diff between the first calculator and where computers are today, like the first computer, very first

• 3:54Speaker 01

  digital computer was a room size calculator. All it did was calculate

• 3:59Speaker 01

  Fourier transforms and things like that. And I think that's kind of the potential for where AI can be, given the current, like where the technology is going. It's very possible.

• 4:12Speaker 03

  What do you think is, so when I look at technologies, there's, there's almost like three types, right? There's things that just are never going to work. And maybe some aspects of Theranos for that, right? Like there were questions whether the physics of Theranos would ever work. As you miniaturize things sufficiently. There's things that can work immediately today, or with a little bit of work or engineering, you can get there. And then there are things that are clearly going to happen. And they're at some point in the future. So for example, in the 90s, people defined out almost everything that cell phones would do. And then eventually it got there, once you had better processors on phones and more bandwidth in terms of cellular networks. Like you need to build a bunch of stuff in terms of infrastructure. It was clear what was going to happen. What do you think is missing, if anything, technologically, to start to build real worlds for the performance agents?

• 4:57Speaker 01

  The way we think about agent tasks is it's a spectrum of difficulty. So some agents are very possible today, like we see a lot of them. There are these conversational bots that take over some of the customer success workflows. And they'll fail over to real customer success people if the agent doesn't know how to deal with it. And those are actually what we see inside companies is that they actually have pretty complex reasoning workflows. They're somewhat hardcoded and so they're not general. They don't generalize to other company workflows, but you know, we are already seeing agents. And then maybe there are two spectra. There's like specific to general.

• 5:36Speaker 01

  So today we have very specific agents and over time we can, you know, if they are better at reasoning and better at certain other things. Interacting with your computer, then they become more general, be able to use the same agent and it'll learn something new. And then there's also a spectrum from like copilot to more autonomous. So today we see a lot of copilots and the human in the loop. And over time it becomes kind of incrementally more autonomous. And so I don't see it as being so binary, like, oh, there is a technology missing for agents. But rather that as capabilities improve, we're going to see more and more of these use cases. Be eaten up by more general, more autonomous agents. There are few categories of things that are in the way today.

• 6:19Speaker 01

  So I would say where we are today, we're kind of in the era of like. Maybe lossy Ethernet with no error correction or like analog computer, something like that, where we have these models and they don't work reliably. And that's, you know, when we talk to founders building agents, that's really the biggest thing. It's really hard to get these systems to work reliably and output exactly what I want it to output and kind of do the right thing at every step all the time. And so the question is, okay, how do you get it to work more reliably? Well, there's, you know, a lot of why we work on reasoning. And when we say reasoning, it's kind of all of the things around getting tasks done in the world. Like when does a system come back to you?

• 7:04Speaker 01

  How does it know it's not certain about its output? Can it kind of think through different action plans and figure out, okay, this plan is the better plan and we should try going down this path first? Reasoning is one big piece of improving reliability. And second chunk of things is like all of this error correction and I think like chain of thought, tree of thought, these are error correction techniques. We have a lot of other techniques internally and that also helps improve reliability. And so if we think about this problem as a reliability problem, then you can incrementally make a lot of progress on it.

• 7:40Speaker 03

  I loved your framework of sort of generalizability and sort of that two by two that you had. If I look at a lot of the language models today, what I'm observing a lot of people doing is they basically start off prototyping something, say on GPT four, because it's the most advanced model. They see if it works or not. And if it works, then they have any sort of scale. In some cases, they move to GPT three point five and sometimes, you know, they've thought about fine tuning or not, but sometimes they'll move to an open source model, which works dramatically less well in some cases, but then they'll fine tune it for a high volume use case. And it's all because of cost optimization. Basically, as you know, like if you have a really big model, it costs a lot more for inference in terms of compute than like a smaller model. How do you think about that relative to generalizability?

• 8:23Speaker 03

  Because I guess if you make something really generalizable, my assumption, which may be incorrect, is it's more expensive, right? You'll need some forms of memory for it. You'd need some broader logical capabilities versus just saying, I'm just going to do the thing that's going to like order flights really well. Or whatever it may be in terms of agents. And so I'm sort of a little bit curious about that framework.

• 8:41Speaker 02

  I think that's a, that's the right way of thinking about it. I think when Kenji was saying, you know, the spectrum from more specialized to more generalizable. I think we're talking about the ability to solve more general problems, like the ability to do these problems that you've only seen once or twice. I think even as that ability goes up, we're still going to see kind of, you know, a thing coming behind that, a force that takes each of those things. Like maybe you start out by doing your plane booking with GPT-4, but eventually you realize like, oh, actually like this is so expensive and slow. Like I just want the thing to be really good at it. But what you can do is you can apply these agents, and this is part of the reason why we're interested in agents that code. You can apply those agents to the original general system to have it go make a more specialized version of that. So it's kind of specializing the things that you're doing a lot. And you can look at like each of those things like, okay, I'm making 10,000 calls to this. This is super expensive.

• 9:25Speaker 02

  Can I just write a piece of Python code that does this? Right? As you have more general capabilities, you actually can use those more general capabilities to kind of do that specialization.

• 9:33Speaker 01

  What we see with a lot of the agent builders today is that they'll use, you know, an agent workflow is complicated. It has lots of different pieces. And so they may use a specialized model for parts of it and a general model for other parts of it. And the way we think about it, it's quite pragmatic. Basically that as capabilities increase, what we want is like minimal viable models for each capability. And so a lot of the models are much smaller and very specific and like pretty specifically trained. In the personal computer kind of revolution around that time, I think there was kind of like branching. So some people built supercomputers. They're like, oh, we're going to like make the more powerful computer. And then other people built personal computers. And it turns out like personal computer is much bigger market and supercomputer is not that many people needed that much computing power.

• 10:18Speaker 01

  And I suspect we're going to see something similar where a lot of use cases are going to be able to be addressed by something pretty pragmatic and relatively small. We're like not, we're definitely not pushing the bounds of what we can do with data today on small models. And so, yeah, smaller things can work well.

• 10:35Sarah Guo?

  I want to go back to what I think is like a really deep topic of discussion at Imbue in terms of how you define reasoning and like this being an area of differentiation in terms of your research efforts. Like, you know, we have a bunch of friends at OpenAI and other labs working now publicly on multi-step reasoning and more process supervision, as you were describing. What makes you excited and confident that there needs to be a different approach versus just general language models in order to make the reasoning you need for agents to work?

• 11:09Speaker 02

  I think there's a different process. Like, language models are great. They're really good, you know, predicting the next word. They're good at, you know, making like a very easy classifier. They're good at all sorts of things. But there is, there are obvious limits. Like, we know even in theoretical senses, like, they cannot learn to do multiplication in the general sense because it literally doesn't fit in the context window, right? Like, multiplication, they can learn to do addition in a modular sense, and they can learn to do it actually almost perfectly if you train them in the proper way. But they're not learning the general algorithm for addition. Instead, if you want something to actually execute the general algorithm for addition, you need to have a thing that works in a different way, that has some sort of outer loop about what step should I take next, right? That's just a kind of like definitional thing. There has to be some other sort of wrapper.

• 11:53Speaker 02

  There has to be a different sort of outside process. Everyone at OpenAI and at Imbue and at Anthropic, we all like know how this works. I don't think anyone is proposing like it's just, you know, shove it all in the language model. You can get really far. But I think we're interested in what is that other higher level system? How do we decide what is the right next step to take? When should I go collect more information? You know, am I certain about this? Like, all of these kinds of other things. Those are, I think, the questions that are much more interesting. And I think there's actually a lot of work to be done there. I think we're still very early in the days of like creating these systems.

• 12:21Speaker 01

  Natural language is not a bad medium for it. Code is also another example of a medium for it. Language is pretty compressed. And so that's, that's helpful for dealing with these situations.

• 12:32Speaker 03

  Is that one of the reasons you all decided to focus on code as one of the first Hepsi agents that you have started with? Or could you explain more about the logic behind that?

• 12:41Speaker 02

  Yeah, I think for us, code is

• 12:45Speaker 02

  Useful when we're thinking about reasoning. One way that we are, one way that we're sort of making collectively reasoning agents today is founders are just hard coding the reasoning process of like, okay, if there's a customer support complaint about this thing, then I do this. If it's like this, then I do that. And so you have this like very special case version of the thing, right? And there's a spectrum between code and language or more kind of general reasoning abilities, but it's a spectrum. It's not a binary thing, I think. And so you can have code now that we have these language models that kind of mixes the language models and the code layer, right? Where it's like, sometimes you're using a language model to decide what to do. Sometimes you're using an if statement. And so it's more about like a fusing or like melding of these two different things and being able to like be in the right place on that spectrum. And so code is actually like a really important part of this.

• 13:28Speaker 02

  And as you do things that you want to do more robustly and you want to do in a more repeatable way, then you want to move it more towards code. Right? And so to the extent that you've never seen this task before, maybe you should be doing it in this more kind of nebulous intuitive sense. And then over time, get better at it, critique it and turn it more into code, actually.

• 13:45Speaker 01

  And when we see founders and ourselves building these agents and people shipping them into production and us shipping them internally for ourselves, like basically the agent loop can be very complex and breaks down into different chunks. And we can like turn certain chunks into code. And it really feels like programming in a lot of ways. And so there's something kind of interesting.

• 14:06Sarah Guo?

  Can you talk a little bit about just where you begin in terms of like how to structure the research effort? Like if there are certain tasks you work on, if you start by working on policy or reinforcement and certain tasks, or there's data you want to collect, like how do you start?

• 14:23Speaker 01

  Yeah, so we have this idea we call serious use, where basically we should be building agents that we want to use every day. This is actually one of the biggest blockers. Like it's really hard to get agents we want to use every day because of the reliability issues. And so a lot of what we work on is coding agents, but we also work on agents for other operational business processes. And that kind of helps drive, oh, okay. Like these parts of the agent loop are really complicated. Like, can we simplify them? Can we make them more reliable? And in a lot, in a lot of ways, it is an incremental kind of set of work that helps us get from like, you know, 60% reliable to 70% to 80%. And that's what forces development of new techniques.

• 15:06Speaker 01

  It's not like, oh, magical, you know, we train a giant model and stick everything into it and then magically it works. Like it does not work. It'll get better at random parts of the agent loop, but that's not what we want.

• 15:16Sarah Guo?

  And is the premise here, like you start with a serious use smaller task in code or something like a recruiting communication automation task? Or how do you choose?

• 15:28Speaker 02

  Yeah, we pick tasks kind of depending on a bunch of different factors. One, like how useful, how frequent, how possible is this going to be to do, right? How generally applicable is it? How much is it going to help push the techniques that we want to push forward?

• 15:42Speaker 01

  Does it scale to more complex versions of the task?

• 15:45Speaker 02

  Yeah, so we're purposely trying to pick, you know, some with some diversity. Like we have, you know, one agent that will just go do a random to do in your code base. And so this can be super, super general. It can take a really, really long time to do this, right? And we have another, the opposite end of that spectrum is we have an agent that will look at every single, you know, pull request and run Linter against it and ask like, okay, are there any like type errors? Okay, how do I fix them? All right, great. Here's like a PR with me fixing the type errors for you, but very, very specific. But really you can imagine how, you know, you can invoke the to do agent to fix a specific type error and you can expand the type error fixer to do unit tests and to do security flaws and to do renaming these variables. And they sort of meet in the middle as you kind of make these things both more capable. And so there are just different ways of kind of looking at the problem of how do we make a useful coding agent?

• 16:29Speaker 01

  And Eli, to your point of kind of the specialized versus general dichotomy, one thing that is kind of interesting that we are seeing in agencies, like agents can call subagents. So our to do agent can figure out like, oh, there's already a subagent for this thing, for this function you're trying to write and like, let me call that subagent because it seems likely to succeed. And then if I try and it doesn't succeed, I'll do something else. And so you can kind of have this like more general reasoning layer and also a bunch of subagents where it that that general reasoning layer is actually very specific. It's a specific planner. It's not that good at like browsing the web and things like that. But the system itself altogether is more general as a result.

• 17:10Sarah Guo?

  How do you guys do evaluation for both these, like, let's say, categories of agents that you're working with today from the, I assume, more closer to production grade to do to broader coding agents?

• 17:24Speaker 02

  Yeah, the evaluations I think are actually one of the most important parts and one of the places where we spend the most time and think about it kind of the most. There's, there's a lot of work in specifying exactly what you want from the to do agent, for example, right? Like, how do you know, like, it gives you back some code. Okay, is that good? There's sort of a spectrum, but like. If it's faster, it's better. If it gives you less code, that's better. But if there's bugs, that's not good. So you really need to take it and like, break down, what did I really want to happen here? And I think when you start to break this down and you start to say, okay, there's some things that are kind of qualitative, like, do I trust it? Did it come back with tests? Can I run this code immediately? Like, the kind of feel of it. There's other things that are just for the code itself. There are different attributes. Is it in the same style? Does it have good variable names? Like, is it a minimal change? Or did it change all sorts of stuff that it didn't really need to change?

• 18:08Speaker 02

  Each of those things are actually something you can measure a little bit more easily than the overall task. So you can make another kind of metric that's like, okay, how good are the variable names? All right, how similar are they? You can break that down. You can kind of keep breaking it down until you get to a point where it's like, okay, I mean, you know, a regular language model or even just a person looking at this, like, there's an objective answer. One of the reasons why we work on code is that there are objective answers to a lot of these questions. Either the test passed or they don't. Either the function is correct or it isn't. Those kind of things are much easier to evaluate. And so we're starting a lot more of our tasks are in that zone as we sort of build up eventually to the ones that are a little bit more qualitative because the evaluation is so much harder there.

• 18:42Speaker 01

  But I think the whole, the strategy of breaking these things down, like, basically, the strategy is we take the output or the answer and we, like, ask a bunch of questions about the output and then we evaluate those questions. And we also evaluate the output. And the interesting thing about that is it scales pretty well to, like, non-code tasks. So for, like, our recruiting tasks, we can also do a very similar process. I think part of why a lot of teams try to work on just math or code reasoning is because those are the easiest to evaluate and, like, the clearest answers. But, um, but just relying on, like, is the output correct or not? That loses a lot of information in the evaluation.

• 19:19Sarah Guo?

  Yeah, I think it's likely to be a pretty rich space. I'm curious for your point of view, but we've looked at a lot of startups building, let's say, interesting AI, like, development tools, right? And, and one of the things that we've spent a bunch of time thinking about is like, what makes for a good scalable eval loop? Right? And that could be objective and easy to test, right? Like, does it compile to things that, as you said, might be richer in data? Like, how easy is it to check the functionality of something, right? Do you have to do static analysis? Is the performance better? Are there examples? If you want to focus on a particular problem, like, let's say, like, Python two to three upgrades or something, right? I think one of the things that's most attractive about this domain is

• 20:04Sarah Guo?

  there are lots of ways to evaluate, right? Even beyond the contributions to reasoning that you guys describe. And it's just going to be productive. I mean, maybe on that topic, like, do you, do you guys think of yourselves as a product company? Like, is it important to go get this functionality in front of users? Or just focus on research? And sort of how do you think about that sequencing?

• 20:26Speaker 01

  Yeah, of course, we're a product company, we're a company. But I think, looking at the history of computing, there is like a right time for technology. And today, I think what you see, what you both see, is that it's pretty hard to make agents that work that, like, can be productionized and used all the time. And it's because, like, the technology is just not there yet. And we use reasoning as like a bucket term. We've described a little bit all the nuances of what we're actually trying to do to get agents to work, and then we lump that all under the term reasoning, because it's easier for people to conceptualize. But the reality is, like, what we're trying to do is to make kind of a system, a set of

• 21:07Speaker 01

  tools, and maybe frameworks, that actually makes it so that we can build reliable agents really fast, really easily. So today, like, writing agents feels like writing code in assembly. And that really limits the types of agents we can build, and also limits the number of people who can build them. And kind of what we're going toward is like... Programming languages that are a little bit more ergonomic, where we can build agents much more easily, where they can work much better, and where a lot more people can build them. Whatever it is that we release, that's what we hope it's going to enable. And so that's why we kind of work on different parts of the stack.

• 21:48Speaker 01

  We work on the underlying models because there need to be like more specific underlying models that work for specific things. And that's what allows a lot of these capabilities in agents to be more reliable. We also work on other pieces of it as well.

• 22:04Sarah Guo?

  Maybe if we just project forward a little bit, like what are you guys most excited about? You want to be a tools at different levels of the stack company. What are you imagining people build? Or what are you already seeing people build that you think is going to be, let's say, useful a year from now and useful five years from now?

• 22:21Speaker 02

  Yeah, I think a year from now, we're going to start to see some of these use cases actually work that today you could, you can write these. Like we have the capabilities. You can make some kind of agent to triage your email or to do scheduling. Or many of these workflows that like, we really should like, why don't we have that today? That definitely can be done, right? Like, there's nothing stopping us. And I think five years from now, we're going to have something where it's not just, you know, okay, we have a scheduling bot, we have this other thing. But we really have these more general, more robust systems where each of us can individually say like, I want a thing that does this. I want to do this particular weird research workflow and I want it to work like this and blah, blah, blah. And just specify in language. I think one thing that-

• 22:58Speaker 01

  Personalized agents.

• 22:59Speaker 02

  Yeah, one thing that our recruiter mentioned yesterday that I thought was kind of funny is he's been describing to candidates like, we're actually sort of a software dev tooling company. But the idea is that in the future, everyone is going like, as we make these things easier and easier to program, really everyone's going to be at like sort of software engineer in that sense. Like we'll be able to make our own agents, right? Just by sort of working in natural language and like describing what we want to do and how we want it to be done and interacting at that level. And so since we're going to be working on these agents, we're kind of making, we're like trying to move towards that kind of tooling. And so I think the goal in five years is for people to be able to really specify some huge range of possible agents that, you know, that do exactly what they want. Like they can interact with their computer in whatever way they want.

• 23:41Speaker 01

  I think specifically what she said is we're a software dev tooling company, but in the future, everyone will be a software engineer and so everyone will need dev tools. And we think of agents, agents are a very technical term. It's like the specific memory architecture of the computer. But agents, what they enable is they're like a natural language, programming language. And so in the future, you know, it's, you know, computers, programming computers today. A way to think about the problem is that it's really not very intuitive to get our computers to do what they, we want them to do. And computers have been becoming more and more intuitive over time and the best tools are very intuitive. And so one day, you know, language is very intuitive to us, like vision, kind of seeing, understanding things that way.

• 24:24Speaker 01

  Very intuitive to us and our computers will become much more intuitive so that people can make them do what they want. More people can.

• 24:31Speaker 03

  One, one major milestone that you had recently was you announced a $200 million fundraiser from Astera, Nvidia and a variety of other folks. How do you think about what proportion of that will go to things like compute versus team? And how in general should AI companies think about the capital they raise and how to deploy it relative to different potential objectives and outcomes?

• 24:53Speaker 02

  I mean, I think actually a significant fraction of that is going to go to compute. I think I can't speak to other companies, how they should deploy it. But I think for us, given that our goal is to make agents, what, what we really want actually as a company is not to become a huge company. We don't want tens of thousands of people. We want to make our product actually work so that we can make AI agents, so we can have some huge impact and have a relatively small, close knit team where the communication is much easier. It's really hard to communicate with 10,000 people. It's much easier to get 100 people in a room and know, you know, what the heck you want to do and agree on things. And so I think we're trying to ideally leverage ourselves and we're already starting to do that today. And what that looks like is by spending a bunch on compute. Today, you know, we don't have AI agents that are running off and doing all sorts of things on their own. But we do have the beginnings of those.

• 25:35Speaker 02

  You know, we do have our internal, you know, hyper parameter optimizer, for example, which saves us a ton of time. Instead of our researchers manually deciding like, oh, this learning rate, I should do this experiment. We just go, we come back after the night and it's like, oh, great. Everything is optimized. This is really nice, right? But that used a lot of compute, like we're using a huge amount of compute relative to each person.

• 25:52Speaker 01

  Yeah, we're like training state, state of the art models with like 14, 13 people.

• 25:58Speaker 02

  Most of us are not working on training them.

• 25:59Speaker 01

  Large, large models. And most of us are not working on that. And so it's, it's the total team. Size is very small for the what we're able to do because of the way we think about our infrastructure. It's like a very agentic kind of approached infrastructure.

• 26:15Sarah Guo?

  It's now sort of broadly viewed that there will not be a fully monolithic architecture for lots of useful models and people have like mixture of experts and such. Given what you want to do with Asians with like planning and reinforcement learning and more test time compute, like I think it's sort of a belief among the largest research labs that under 5,000 GPUs, like under some reasonable level, like you cannot compete on state of the art reasoning, at least as the core LLMs describe it today. Obviously that that bar keeps moving. Does that number apply to you? Do you think the architecture is just very different?

• 26:56Speaker 02

  I mean, we actually have a lot of GPUs. So that number may or may not apply, but we do have a lot of GPUs. We have enough compute to be able to train models that are as large as the largest models have been trained today to date.

• 27:08Speaker 01

  So we have a ton of compute. We can train these really large models and it may not be the best use of our time and resources, actually, because I think just as with like computers, things just get more efficient. And what we see is that things are getting more efficient in training. So like learning how to use data more effectively so that the models get much better performance with less data, learning how to like do training runs so that

• 27:35Speaker 02

  So things don't, you know, diverge, like there's all sorts of

• 27:37Speaker 01

  So things don't diverge. We're not having to like rerun the same thing again. There's like a bunch of, there's a bunch of like hyper parameters to set and like tooling to build around it and monitoring and stuff like that. That just makes it more efficient to train these things. And then also, I think the data piece is just so big and so under explored, like people don't really, we all know that data is the thing that matters. And I think like a lot of efficiency gains are going to come from better data. And so that's actually quite a bit of what we work on.

• 28:06Speaker 03

  Could you tell us a little bit more about why you decided to focus on coding? And what are the types of systems you're really focused on building?

• 28:11Speaker 02

  Yeah, so there's a, there's a bunch of different reasons for focusing on coding. One of them is that the evaluate we talked about before, the evaluations are much easier to do and subjective. Another one is that coding is part of reasoning. Another one is that coding really helps us accelerate both our own work and the agents that we end up building. So as we're making the tools for ourselves, we already are starting to see like this kind of leverage from the systems that we've built. Where like, we can run this agent now, you know, I think probably within the next year, we'll probably, you know, not be hiring as many recruiting coordinators because, oh, we're going to do some of the scheduling with the agent that we've built. Right. But we also can do the same thing on the software engineering side. We're writing unit tests literally right now automatically. Okay. And that's just helping accelerate us, helping, you know, remove the bugs. It's additive, it's incremental.

• 28:55Speaker 02

  It's like, okay, we get a 5% gain, a 10% gain here. But as we make more and more tools, those things compound. And I think over time, it's going to be possible to make much more robust systems much more quickly. And we're building, you know, we're using these coding agents to write the coding agents. And I think this is kind of the like, you know, sort of recursive self-improvement thing that people have always been sort of worried about or excited about in, in AI. But I think what it really looks like in practice is not this scary like, oh, you, you know, you leave your computer on overnight and all of a sudden it's a super, super god thing the next day. Instead, it's like this slow grind of making things a little bit better every day. But a 1% improvement every day over a year is huge. Right. And so I think that's the kind of thing that, that we're really excited about with code.

• 29:38Speaker 02

  Is that not only can we apply it to our own workflows, but also as we start to actually get coding agents that can really write code. Now we're in a very unlimited, like very interesting space. Right now, the bottleneck for most companies is the ability to hire software engineers that can write really robust code. Right. But if you can just turn compute into really good code, now this is a totally different world. Now there's none of this like, oh yeah, well, imbue is so much smaller in this other company, blah, blah, blah. It's like, no, no, we can write way more code than anyone else. Right. And so I think this is kind of a pretty interesting thing that over time, I think, you know, we'd like to work towards. And so that's another reason for code as well.

• 30:16Speaker 01

  There's also code is really useful for action, so agents acting. And today, you know, even the models can like do really simple things like write code to write integrations, like API integrations. And so that saves us a lot of time writing API integrations, which is super annoying. Also think like software is just dramatically underwritten because it's so hard to write code today. So, you know, as we said in the future, like computers will be able to be programmed by regular people. What that means is like, we're going to write way, way, way more software all the time. And like, people will write software, but maybe not by having to write code, the agents write the code.

• 30:48Speaker 02

  I think it's not only just more software, but also better software, right? If like already, we're having our agents kind of look at our pull requests, you know, fix the type errors. Okay. Well, we can extend this to adding new unit tests, to fixing the existing unit tests, to looking for security flaws. Like, I'm very excited about agents that can go out and help all sorts of organizations improve the quality of their codebase. How can we simplify this? Refactor it, fix security flaws. I think there'll just be a huge flourishing of much higher quality, better software. As a result, not just more software, but just taking the existing software and making it so much better, which will make it so much nicer and more fun to interact with as programmers as well.

• 31:21Speaker 01

  Also, much more custom software. Like, something that we do some of is generating interfaces. And it's pretty interesting. Like, if I can have like a custom interface for whatever it is that I'm trying to do, it has exactly the right form fields. It's like, kind of nice. And then I can cache that interface and like, we use it. So, you know, pragmatic, but pretty interesting.

• 31:41Speaker 02

  Yeah, I mean, I did this over the weekend, actually, for Mid Journey. I got really sick of typing out Mid Journey prompts on my phone in Discord. You can't keep iterating on the prompts. So I just made like a little, a little thing that interacts, you know, with it via the API. Well, my version of the API. But, uh, yeah. And so, but I think everyone will be able to do this. Like, it didn't actually take that much code. When we have agents that can write code, someone else who wants to use it in a different way, great. You can just like, ask the agent to do that, come back five minutes later, and you have like, your own perfect way of interacting with this. I think that's just going to make our computers feel so much nicer to interact with.

• 32:11Sarah Guo?

  That, I think, is an inspiring note to, to end on. We're going to have 25-person companies who can change the world. We're going to have more software, more custom software, and higher-quality software for us all to use. So, thanks so much for doing this, Josh and Kanjun.

• 32:25Speaker 02

  Yeah, it's so generous.

• 32:27Speaker 01

  Thank you, Sarah and Elon.

• 32:27Speaker 02

  Thank you.

• 32:29Sarah Guo?

  Find us on Twitter at NoPriorsPod. Subscribe to our YouTube channel if you want to see our faces. Follow the show on Apple Podcasts, Spotify, or wherever you listen. That way, you get a new episode every week. And sign up for emails or find transcripts for every episode at no-priors.com.