Extreme Harness Engineering for Token Billionaires: 1M LOC, 1B toks/day, 0% human code, 0% human review — Ryan Lopopolo, OpenAI Frontier & Symphony

I do think that there is an interesting space to explore here with Codex, the harness as part of building AI products, right? There's a ton of momentum around getting the models to be good at coding. We've seen big leaps in, like, the task complexity with each incremental model release, where if you can figure out how to collapse a product that you're trying to build, a user journey that you're trying to solve into code, it's pretty natural to use the Codex harness to solve that problem for you.

It's done all the wiring and lets you just communicate in prompts to let the model cook. You have to step back, right? Like, you need to take a systems thinking mindset to things and constantly be asking, "Where is the agent making mistakes? Where am I spending my time? How can I not spend that time going forward?"

And then build confidence in the automation that I'm putting in place so I have solved this part of the SDLC. [upbeat music] All right. We're in the studio with Ryan Lopopolo from OpenAI. Welcome. Hi. Thanks for visiting San Francisco, and thanks for spending some time with us. Yeah, thank you. I'm super excited to be here. You wrote a blockbuster article on harness engineering.

It's probably going to be the defining piece of this emerging discipline. Um- Thank you. It is, it's been fun to feel like we've defined the discourse in some sense. [laughs] Let's contextualize a little bit this first podcast you've ever done. Yes. And thank you for spending it with us. W-what is-- where is this coming from? What team are you in? All that jazz. Sure, sure.

I work on frontier product exploration, new product development in the space of OpenAI Frontier, which is our enterprise platform for deploying agents safely at scale with good governance in any business. And the role of me and my team has been to figure out novel ways to deploy our models into packaged end products that we can sell as solutions to enterprises.

And you have a background, I'll just squeeze this in there, Snowflake, Brex, Stripe, Citadel. Yes, yes. Been, been building- The exact kind of customer- My entire life, yes. The exact kind of customer that you want to- So I'll say I was actually- Yeah. I didn't expect the background. When I looked at your Twitter, I'm seeing the opposite, stuff like this.

So you've got the mindset of, like, full send AI coding, stuff about slop, like buckling in your laptop on your Waymos. Yes. And then I look at your profile, I'm like, "Oh, you're just like... You're cracked in the other end too." [laughs] So perfect mix. Perfect mix. I... It's quite fun to be AI maximalist. If you're gonna live that persona, OpenAI is the place to do it, and it's- Token is what they say.

Yeah. Certainly helps that we have no rate limits internally, and I can go, like you said, full send at this thing. Yeah, yeah. So the OpenAI Frontier, and you're a special team within OpenAI Frontier. We had been given some space to cook, which has been super, super exciting. And this is why I started with kind of a out-there constraint to not write any of the code myself.

I was figuring, if we're trying to make agents that can be deployed into end enterprises, they should be able to do all the things that I do. And having worked with these coding models, these coding harnesses over six, seven, eight months, I do feel like the models are there enough, the harnesses are there enough where they're isomorphic to me in capability, in the ability to do the job.

So starting with this constraint of I can't write the code meant that the only way I could do my job was to get the agent to do my job. And like, uh, just a bit of background before that. This is basically the article. So what you guys did is five months of working on an internal tool, zero lines of code, over a mi-a million lines of code in the total code base. You say it was 10x more, like...

It was 10x faster than you would've if you had done it by hand, so- Yeah. That was the mindset going into this, right? Right. That's right. Okay. Yeah. Started with some of the very first versions of Codex CLI with the Codex mini model, which was obviously much less capable than the ones we have today, which was also a very good constraint, right?

It's quite a visceral feeling to ask the model to build you a product feature, and it just not being able to assemble the pieces together, which kinda defined one of the mindsets we had for going into this, which is whenever the model just cannot, you always pop open the task, double-click into it, and build smaller building blocks that then you can reassemble into the broader objective.

And it was quite painful to do this, honestly. The first month and a half was 10 times slower than I would be. But because we paid that cost, we ended up getting to something much more productive than any one engineer could be because we built the tools, the assembly station for the agent to do the whole thing.

But yeah, so onward to GPT 5, 5.1, 5.2, 5.3, 5.4, to go through all these model generations and see their kind of quirks and different working styles also meant we had to adapt the code base to change things up when the model was revved. One interesting thing here is 5.2, the Codex harness at the time did not have background shells in it, which means we were able to rely on blocking scripts to perform long-horizon work.

But with 5.3 and background shells, it became less patient, less willing to block, so we had to retool the entire build system to complete in under a minute. And this is not a thing I would expect to be able to do in a code base where people have opinions. [laughs] But because the only goal was to make the agent productive, over the course of a week, we went from a bespoke make file build to Bazel to Turbo to Nx and just left it there because builds were fast at that point.

Interesting. Talk more about Turbo to Nx. That's interesting, 'cause that's the other direction that other people have been doing. Ultimately, I have not a lot of experience- Okay... with actual front-end repo architecture. You're talking to JavaScript builds this guy, so I'm like- [laughs] I know the Nx team.

I know Turbo from Jared Palmer, and I'm like, yeah, that's an interesting comparative comparison. The, the hill we were climbing, right- Yeah... was make it fast. Is there multiple, multiple front-ends involved? Is it... How, how complex? React- Can we talk-... Electron base- Okay. Yeah... single app sort of thing. And- Must be under a minute. That's an interesting limitation.

I'm actually not super familiar with the background shelf stuff. Probably it was talked about in the five-three release. It basically means that Codex is able to spawn commands in the background and then go continue to work while it waits for them to finish. So it can spawn an expensive build and then continue reviewing the code, for example. Yeah. And this helps it be more time-efficient for the user invoking the harness.

And I guess, and just to really nail this, like, why does one minute matter? Like, why not five? Okay. We want, we want the inner loop to be as fast as possible. Okay. One minute was just a nice round number- Yeah... and we were able to hit it. And if it doesn't complete, it kills it or some- something? Uh, no.

We just take that as a signal that we need to stop what we're doing, double-click, decompose the build graph a bit to get- I see... the time back under so that we can able the agent to continue to operate. But it's almost like you're, it's like a ratchet, and it's like you're forcing- Yeah... build time discipline because if you don't, it'll just grow and grow. That's right.

And you mentioned that like- My current, like the software I work on currently is at 12 minutes. [laughs] It sucks. This has been my experience with platform teams in the past, where you have an envelope of acceptable build times, and you let it go up to breach, and then you spend two, three weeks to bring it back down to the lower end of the envelope and stop.

But because tokens are so cheap- Yeah... and we're so insanely parallel with the model, we can just constantly be gardening this thing to make sure that we maintain these invariants, which means there's way less dispersion in the code and the SDLC, which means we can simplify in a way and rely on a lot more invariants as we write the software.

Lovely. You mentioned in your article, like humans became the bottleneck, right? You kicked off as a team of three people. You're putting out a million line of code, like fifteen hundred PRs. Basically, what's the mindset there? So as much as code is disposable, you're doing a lot of review. A lot of the article talks about how you wanna rephrase everything is prompting, everything is what the agent can't see. It's kinda garbage, right? You shouldn't have it in there.

So what's like the high level of how you went about building it and then how you address, okay, humans are just PR review. Like, how is human in the loop for this? We've moved beyond even the humans reviewing the code as well. Most of the human review is post-merge at this point, but- Wow. Post-merge. [laughs] That's not even review.

That's just, "Oh, let's just make ourselves happy by reviewing it." You have a- Fundamentally, the model is trivially parallelizable, right? As many GPUs and tokens as I am willing to spend, I can have capacity to work- Yeah... with the code base. The only fundamentally scarce thing is the synchronous human attention of my team.

There's only so many hours in the day. We have to eat lunch. I would like to sleep, although it's quite difficult to stop poking the machine because it makes me want to feed it. You have to step back, right? Like you need to take a systems thinking mindset to things and constantly be asking, "Where is the agent making mistakes? Where am I spending my time? How can I not spend that time going forward?"

And then build confidence in the automation that I'm putting in place, so I have solved this part of the SDLC. And usually what that has looked like is like we started needing to pay very close attention to the code because the agent did not have the right building blocks to produce modular software- Mm....

that decomposed appropriately, that was reliable and observable and actually accrued a working front end in these things, right? So in order to not spend all of our time sitting in front of a terminal at most doing one or two things at a time, invested in giving the model that observability, which is that, that graph in the post here. Yeah.

Let's walk through the traces and- Which, which existed first? We started with just the app, and the whole rest of it from vector through to all these login metrics APIs was, I don't know, half an afternoon of my time. [laughs] We have intentionally chosen very high level, fast developer tools. There's a ton of great stuff out there now.

We use Neese a bunch, which makes it trivial to pull down all these Go written Victoria stack binaries in our local development. Tiny little bit of Python glue to spin all these up, and off you go. One neat thing here is we have tried to invert things as much as possible, which is instead of setting up an environment to spawn the coding agent into, instead we spawn the coding agent, like that's the entry point, just Codex, and then we give Codex via skills and scripts the ability to boot the stack if it chooses to- Mm...

and then tell it how to set some end variables so the app and local dev points at the stack that it has chosen to spin up. And this I think is like the fundamental difference between reasoning models and the four ones and four O's of the past, where these models could not think, so you had to put them in boxes with a predefined set of state transitions.

Whereas here, we have the model, the harness be the whole box and give it a bunch of options for how to proceed with enough context for it to make intelligent choices. So skills- So, so like a lot of that is around scaffolding, right? Yes. Previous agents, you would define a scaffold. It would operate in that loop, try again. That's pivoted off from when we've had reasoning models.

They're seeming to perform better when you don't have a scaffold, right? That's right. And, and you go into like niches here too, like your spec.md and like having a very short agent.mg, agentmd? Yes. Yeah. Yeah. So you even lay out what it is here, but- I like the table of contents. I- Like stuff like this, it really helps- So-... guide people because everyone's trying to do this.

This structure also makes it super cheap to put new content into the repository to spear both the humans and the agents. You, you reinvented skills, right? [laughs] Yeah. One big agent and- Skills from first principles. Oh, skills did not exist when we started doing this. You, you have a short one, hundred line overall table of contents, and then you have little skills, right? Core beliefs, MD, tech tracker. Yeah. Yeah.

The skill is over. The, the tech jet tracker and the quality score are pretty interesting because this is basically a tiny little scaffold, like a markdown table, which is a hook for Codex to review All the business logic that we have defined in the app assess how it matches all these documented guardrails and propose follow-up work for itself.

Before beads and all these ticketing systems, we were just tracking follow-up work as notes in a markdown file, which we could spawn an agent on, a cron to burn down. There's this really neat thing that, like, the models fundamentally crave text. So a lot of what we have done here is figure out ways to inject text into the system, right?

When we get a page because we're missing a timeout, for example, I can just add Codex in Slack on that page and say, "I'm gonna fix this by adding a timeout. Please update our reliability documentation to require that all network calls have timeouts." So I have not only made a point-in-time fix, but also, like, durably encoded this process knowledge around what good looks like. Yeah. And we give that to the root coding agent as it goes and does the thing.

But you can also use that to distill tests out of, or a code review agent, which is pointed at the same things to narrow the acceptable universe of the code that's produced. I think one of the concerns I have with that kind of stuff is you think you're making the right call by making it persisted for all time across everything. Yes.

But then you didn't think about the exceptions that you need to make, right? Mm-hmm. And then you have to roll it back. Part of it is also- Sometimes it can follow your instructions too. It's somewhat a skill, right? So it determines when it uses the tools, right? Like, it's not like it'll run at every call. It'll determine when it wants to check quality score, right? Yeah.

And we do, in the prompts we give these agents, allow them to push back. When we first started adding code review agents to the PR, it would be Codex CLI locally writes the change and pushes up a PR. On those PR synchronizations, a review agent fires, it posts a comment. We instruct Codex that it has to at least acknowledge and respond to that feedback.

And initially, the Codex driving the code author was willing to be bullied by the PR reviewer, which meant you could end up in a situation where things were not converging. So- Yeah... we had to- You just hit thrash. We had to add more optionality to the prompts on both of these things, right? The reviewer agents were instructed to bias toward merging the thing, to not surface anything greater than a P2 in priority.

We didn't really define P2, but we gave it- [laughs] Define P2. We gave it a framework within which to score its output. And then- Wait, greater than... P0 is worse, right? Yes. The secret majority of P2 is sort of good. P0 is you will nuke- Yeah... the code base if you merge this thing, right? [laughs] But also on the code authoring agent side, we also gave it the flexibility to either defer or push back against review feedback, right?

Mm. This happens all the time, right? Like, I happen to notice something and leave a code review which could blow up the scope by a factor of two. I usually don't mean for that to be addressed exactly in the moment. It's more of an FYI. File it to the backlog, pick it up in the next fix-it week sort of thing.

And without the context that this is permissible, the coding agents are gonna bias toward what they do, which is following instructions. Yeah. I do wanted to check in on a couple things, right? Like- Sure... all the coding review agent, it can merge autonomously. I think that's something that a lot of people aren't comfortable with. And you have a list here of how much agents do.

They do product code and tests, CI configuration and release tooling, internal dev tools, documentation, eval harness, review comments, scripts that manage the repository itself, production dashboard definition files. Like everything. Yes. And so they're just all churning at the same time. Is there, like, a brick code that, that any human on the team pulls to stop everything?

Because we are building a native application here, we're not doing continuous deployment, so there is still a human in the loop for cutting a release branch. I see. We require a bless human-approved smoke test of the app before we promote it to distribution, these sorts of things. So you're working on the app, you're not building, like, infrastructure where you have, like, nines of reliability, that kind of stuff. That's correct. That's correct. Okay.

And also, like, full recognition here that all of this activity took in a completely greenfield repository. There's should be no assurance that this applies generally to- This is a production thing you're gonna ship to customers. Of course, yeah, of course. So this is real. And, like, one of the things there is you mentioned you started this as a repo from scratch. The onboarding first month or so was pretty... It was like working backwards, right? Yep.

And then you had to work with the system, and now you're at that point where, you know, you're very autonomous. I'm curious, like, okay, so what... how human-in-the-loop is it? So what are the bottlenecks that you wish you could still automate? And part of that is also, like, where do you see the model trajectory improving and offloading more human-in-the-loop? We just got a five point four.

It's a really good- Fantastic model, by the way. Yeah, yeah. It's the first one that's merged top-tier coding, so it's Codex-level coding and reasoning, so general reasoning both in one model. So and computer vision. And now with, now with 5.4, I can just have Codex write the blog post, whereas for this one, I had to balance between chat and- Oh, I need to-... and Codex. Um, I, I might be out of a job [laughing] Oh my God. Oh.

[laughs] I know, you just gave me an, an idea for a completely AI newsletter that 5.4 could do. Yeah. I get it now. This sort of thing is just one example of closing the loop, right? Like- Yeah... the dashboard thing you mentioned, we have Codex authoring the JSON for the Grafana dashboards and publishing them, and also responding to the pages.

Which means when it gets the page, it knows exactly which dashboards are defined and what alerts, what alert was triggered by which exact log in the code base, 'cause all of this stuff is collated together. Yeah. It has to own everything. Yes. Yeah, yeah. And it means that if we have an outage that did not result in a page, it has the existing set of dashboards available to it.

It has the existing set of metrics and logs and can figure out where the gaps in the dashboard are or in the underlying metrics and fix them in one go. In the same way you would have a full stack engineer be able to drive a feature from the back end all the way to the front end. So it, it seems like a lot of the work you guys had to do was you as a small team are fully working for a way that the model wants the software to be written.

It's like less human legible for better code legibility, agent legibility. How do you think that affects broader teams? So one at OpenAI, do you liaison, like this is how software should be written? Like I can imagine, say you join a new team with this methodology, this mindset, there's ways that teams do code review, teams write code, like teams are structured and a lot of it is for human legibility.

So should we all swap? Like how does this play back, one, broader into OpenAI and then like broader into the software engineering, right? Is it like- Teams that pick this up will have... It's pretty drastic, right? You have to make a pretty big switch. Should they just full send? Yeah. The mindset is very much that I'm removed from the process, right? I can't really have deep code-level opinions about things. Mm.

It's as if I'm group tech leading a 500-person organization. Yeah. Like, it's not appropriate for me to be in the weeds on every PR. This is why that post-merge code review thing is, like, a good analog here, right? Like, I have some representative sample of the code as it is written, and I have to use that to infer what the teams are struggling with, where they could use help, where they're already moving quickly, and I can pivot my focus elsewhere.

Yeah. So I don't really have too many opinions around the code as it is written. I do, however, have a command-based class, which is used to have repeatable chunks of business logic that comes with tracing and metrics and observability for free. And the thing to focus on is not how that business logic is structured, but that it uses this primitive, 'cause I know that's gonna give leverage by default. Yeah. Yeah, it- Back to that sort of systems thinking.

And you have part of that in your blog post, enforcing architecture and ta- taste, how you set boundaries for what's used. There's also a section on redefining engineering and stuff. But yeah, it's just... it's interesting to hear. As the models have gotten better, they have gotten better at proposing these abstractions to unblock themselves, which again, lets me move higher and higher up the stack to look deeper into the future on what ultimately blocked the team from shipping.

Yeah. You mentioned, so you... this is primarily a, it's like a one million line of code base Electron app, but it manages its own services as well. So it's like a back-end for front-end type thing? We do have a, a back end in there, but that's hosted in the cloud. This sort of structure is actually within the separate main and renderer processes within the Electron. That's just how Electron works. Yeah, yeah, yeah.

Of course. So have also treated, like, NVC-style decomposition with the- Yeah... same level of rigor- Okay... which has been very fun. I have a, a fun pun. This is like a tangent. NVC is model view controller, and any sort of full stack web dev knows that. But my up- AI native version of this is model view claw. [laughs] The M- claws the harness. That's right. That's right.

[laughs] I do think that there is an interesting space to explore here with Codex, the harness as part of building AI products, right? There's a ton of momentum around getting the models to be good at coding. We've seen big leaps in, like, the task complexity with each incremental model release, where if you can figure out how to collapse a product that you're trying to build, a user journey that you're trying to solve into code, it's pretty natural to use the Codex harness to solve that problem for you.

It's done all the wiring and lets you just communicate in prompts to let the model cook. Yeah. It's been very fun. And there's also a very engineering legible way of increasing the capability. It's fantastic, right? Yeah. Yeah. Just give, just give the model scripts, the same scripts you would already build for yourself. Yeah.

Yeah, so for listeners, this is Ryan saying that software engineering or coding agents will eat knowledge work, like the non-coding parts that you would normally think, "Oh, you have to build a separate agent for it." No, start with a coding agent and go up from there, which OpenClaw has. Like, it's- Yes... pie under the hood. Yes. Basically define your task in code. Everything is a coding agent.

By the way, since I brought it up, this is probably the only place we bring it up, is any OpenClaw usage from you? Any- No, no, not for AI. I don't have any spare Mac Minis rattling around my house. [laughs] You can afford it. No, just I'm curious if it's changed anything in OpenAI yet, but it's probably early days.

And then the other, the other thing that I wanna pull on here is, like, you mentioned ticketing systems and you mentioned PRs, and I'm wondering if both those things have to go away or be reinvented for this kind of coding. So the Git itself and is, like, very hostile to multi-agents. Yeah. We make very heavy use of work trees.

But, like, even then, like, I just did a, dropped a podcast yesterday with Cursor saying, and they said they're getting rid of work trees 'cause it still has too many merge conflicts. It's too un- too un- unintuitive. But go ahead. The models are really great at resolving merge conflicts. Yeah. And to get to a state where I'm not synchronously in the loop in my terminal, I almost don't care that there are merge conflicts.

Yeah, it's disposable. Yeah. We invoke a dollar land skill, and that coaches Codex to push the PR, wait for human and agent reviewers, wait for CI to be green, fix the flakes if there are any, merge upstream if the PR comes into conflict, wait for everything to pass, put it in the merge queue, deal with flakes until it's in main. And this is what it means to delegate fully, right?

This is, in a very large model repo, probably a significant tax on humans to get PRs merged, but the agent is more than capable of doing this, and I really don't have to think about it- Yeah... other than keep my laptop open. Yeah. [laughs] I used to be much more of a control freak, but now I'm like, "Yeah, actually, you could do a better job at this than me." Yeah. With the right context. Yes.

Anything else in harness engine general, just th- this piece? I just wanna make sure we- I think one thing that I maybe didn't- Understand... make super clear in the article that I heard on Twitter as an interesting framing here- Let's respond to them. What's the chatter and then what's your response? Ultimately, all the things that we have encoded in docs and tests and review agents and all these things are ways to put all the non-functional requirements of building high-scale, high-quality, reliable software into a space that prompt injects the agent.

We either write it down as docs, we add lints where the error message is, tell how to do the right thing. So the whole meta of the thing is to basically tease out of the heads of all the engineers on my team what they think good looks like, what they would do by default, or what they would coach a new hire on the team to do to get things to merge.

And that's why we pay attention to all the mistakes, mistakes that the agent makes, right? This is code being written that is misaligned with some as yet not written down non-functional requirement Sorry, what did the online people misunderstand or- No... what are you responding to? Somebody just literally said that and I was like, "Oh, yeah." Okay. This is the thing. This is what I've been doing. Oh, you agree with it. Yeah, I see. Interesting.

One other neat thing which I did totally did not expect is- Mm... folks were just taking the link to the article and giving it to Pi or Codex- [laughs]... and say, "Make my repo this." You can achieve a whole recursion. And it was wildly effective. Really? It was wildly effective. No way. Like just- This actually is something I tried with five four yesterday. I, I didn't have that much time.

I was like out speaking at something, and this is one of my things. I was like, "Okay, I, I have this article. Can we just like scaffold out what it would be like to run this?" And I, I did it first as that, and then I was like, "Okay, let me take another little side repo and see, okay, if I was to fully automate this like this," 'cause I haven't written a line of code.

It's like- It's like a full stack, right? [laughs]... a side thing I'm doing. Voice TTS or I'm just like slobbing out whatever. It's nothing production. I'm like, "How would I make this like this?" And it's actually like a really good way. It's like a good way to learn what could be changed, what could be like... It's just a good analyzing, right?

You give it all the code, you give it all the context, you give it the article, and it walks you through it very well. That's right. That's right. I guess one more thing before we go to Symphony is I wanted to cover Brett Taylor's response. We had him on the show. He is your chairman. [laughs] Which is wild. [laughs] Yeah.

[laughs] That he's reading your articles as well and like getting engaged in it. He said software dependencies are going away, basically. They can just be like vendored. Yes. Response. 100%. 100% agree. You still have PromptQL, you still pay Datadog, you still pay Temporal. Thank you. Yep. The level of complexity of the dependencies that we can internalize is, I would say, low-medium right now- Okay...

just based on model capability. What is low then? What is medium? I would say like a, a couple thousand line dependency is a thing that we could in-house no problem, uh, in an afternoon of time. One neat thing about it is like probably most of that code you don't even need. Like by in-housing and abstraction, you can strip away all the generic parts of it and only focus on- Yes...

what you need to enable the specific thing- Yes... you're building. I've been calling this the end of bullshit plugins. Yeah. Because there's so much that when I publish an open source thing, I wanna accept everything and be liberal in what I accept. This is Postel's law, but that means there's so much bloat. Yeah. There's so much overhead.

One other neat thing about this too is when we deploy Codex Security on the repo, it is able to deeply review and change the internalized dependencies- Mm... in a much lower friction way than it would be to like push patches upstream, wait for them to be released, pull them down, make sure that's compatible with all the transitives I have in my repo and things like that.

So it's also much lower friction to internalize some of these things if code is free 'cause the tokens are cheap sort of thing. I think like the only argument I have against this is basically scale testing, which obviously the larger pieces of software like Linux, MySQL, he calls out, but even the Datadogs and Temporals, and then maybe security testing, where- Yes...

classically, I think, is it Linus Torvalds who said security open source is the best disinfectant? Many eyes. Many eyes. And if inline your dependencies and code them up, you're gonna have to relearn mistakes from other people that- Yep, yep. And to internalize that dependency, you're back to zero and you have to start reassembling all those bits and pieces to- Yeah... have high confidence in the code as it is written. Yeah.

Even part of the first intro of this, you basically mentioned like everything was written by Codex, including internal tooling, right? Yes. So internal tooling, like when you're visualizing what's going on, it's writing it for itself. Yeah. I'm building internal tooling. So I, I... now, and like I just show them off and they're like, "How long did you spend?" And I, I didn't spend any time. I just prompted it. Very funny story here. Yeah, go ahead.

We had deployed our app to the first dozen users internally, had some performance issues, so we asked them to export a trace for us, get a tarball, gave it to our on-call engineer, and he did a fantastic job of working with Codex to build this beautiful local dev tool Next.js app that you drag and drop the tarball in, and it visualizes the entire trace.

Oh. It's fantastic. Took an afternoon. But none of this was necessary because you could just spin up Codex and give it the tarball and ask the same thing and get the response immediately. So in a way, optimizing for human legibility of that debugging process was wrong. It kept him in the loop unnecessarily when instead he could have just let Codex cook for five minutes and gotten the same- Yeah, you notify your instincts here of this is how we used to do it, or this is how I would have used to solve it.

Yeah. In this local observability stack, like sure, you can de- deploy Jaeger to visualize the traces, but I wouldn't expect to be looking at the traces in the first place because I'm not gonna write the code to fix them. Yeah. So basically, there needs to be like this kinda house stack and owning the whole loop. I think that is very well established, and it sounds like you might be like sharing more about that in the future, right? Yeah.

I think we're excited to do... We're gonna talk about Symphony in a little bit, but like the way we distributed it as a spec, which I think folks are calling ghost libraries on Twitter. This is like a such a cool name. [laughs] It does mean it becomes much cheaper to share software with the world, right? You define a spec, how you could build your own, specifying as much as is required for a coding agent to reassemble it locally.

The flow here is very cool. Like we have taken all the scaffolding that has existed in our proprietary repo, spun up a new one, ask Codex with our repo as a reference, write the spec. We tell it, spin up a Tmux, spawn a disconnected Codex to implement the spec, wait for it to be done, spawn another Codex and another Tmux to review the spec com- or review the implementation compared to upstream, and update the spec so it diverges less.

And then you just loop over and over Ralph style until you get a spec that is with high fidelity able to reproduce the system as it is. It's fantastic. And you're basically, you're not really adding any of your human bias in there, right? That's correct. A lot of times people will write a spec and be like, "Okay, I think it should be done this way," and you'll riff on something and it's, "No, the agent could have just handled it."

Like you're still scaffolding in a sense, right? I want it done this way. It can determine that spec better. That's right. That's right. Part of me, it, I'm, I've been working a lot on evals recently, and part of me is wondering if an agent can produce a spec that it cannot solve. Is it always capable of things that it can imagine, or can it imagine things that it is impossible to do? I think with Symphony, we...

There's like this, there's this axis where you have things that are easy or hard or established or new, right? And I think things that are hard and new is still something that the models need humans- Yeah... to drive. Yeah, yeah. But I think those other quadrants are largely solved given the right scaffold and the right thing- That's crazy... that's gonna drive the agent to completion. It's crazy that it's solved.

But it means that the humans, the ones with limited time and attention, get to work on the hardest stuff, like the problems where it's pure white space out in front, or like the deepest refactorings where you don't know what the proper shape of the interfaces are, and this is where I wanna spend my time 'cause it lets me set up for the next level of scale.

Yeah. Yeah, amazing. Let's introduce Symphony. I think we've been mentioning it every now and then. Elixir? Interesting option. Yeah, yeah. Looks like- Again, like the Elixir manifestation here is just a derivative. Is a model chosen? Yeah. Yeah, yeah, and it chose that because the process supervision and the gen servers are super amenable to the type of process orchestration that we're doing here. Yeah.

You are essentially spinning up little daemons for every task that is in execution and driving it to completion, which means the model gets a ton of stuff for free by using Elixir and the BEAM. I had to go do a crash course in BEAM and Elixir, and I think most people are not operating at that scale of concurrency where you need that, but it is a good mental model- Yep...

for resumability and all those things, and these are things I care about. But tell me the story, the origin story of Symphony. What do you use it for? Is this... How did it form? W- maybe any abandoned paths that you didn't take. At the end of December, we were at about three and a half PRs per engineer per day. This was before 52 came out.

In the beginning of January, everyone gets back from holiday. With 52 and no other work on the repository, we were up in the 5 to 10 PRs per day per engineer, and I don't know about y'all, but, like, it's very taxing [chuckles] to constantly be switching like that. Like, I was pretty tapped out at the end of the day.

Again, where are the humans spending their time? They're spending their time- Agreed... context switching between all these active tmux panes to drive the agent forward. Yeah, no way. Yeah. So let's again re- build something to remove ourselves from the loop, and this is what Frantic sprinted after here, to find a way to remove the need for the human to sit in front of their terminal.

So a lot of experimentation with dev boxes and automatically spinning up agents. Like, it seems like a fantastic end state here where my life is beach. [laughs] I open Linux twice a day and say yes, no to these things. Yeah, yeah. And this is again a super, super interesting framing for how the work is done because I become more latency insensitive. I have way less attachment to the code as it is written.

Like, I've had n- close to zero investment in the actual authorship experience, so if it's garbage, I can just throw it away and not care too much about it. In Symphony, there's this, like, rework state where once the PR is proposed and it's escalated to the human for review, it should be a cheap review.

It is either mergeable or it is not, and if it's not, you move it to rework. The Elixir service will completely trash the entire work tree and PR and start it again from scratch. Okay. And this is that opportunity again to say, "Why was it trash?" Right? Yeah. What did the agent- What'd he do?... do that was bad? Yeah, yeah. Yeah. Fix that before moving the ticket to- So be it... in progress again.

Yeah. Why is this not in Codex App? I, as, I guess it's, you guys are ahead of Codex App. Yeah. So the way the team has been working is basically to be as AI-pilled as possible and sprint ahead, and a lot of the things we have worked on have fallen out into a lot of the products that we have. Like, we were in deep consultation with the Codex team to have the Codex App be a thing that exists, right?

To have Skills be a thing that Codex is able to use so we didn't have to roll our own to put automations into the product, so all of our automatic refactoring agents didn't have to be these hand-rolled control loops. It has been really fantastic to be, in a way, unanchored to the product development of Frontier and Codex and just very quickly try to figure out what works and then later find the scalable thing that can be deployed widely.

It's been a very fun way to operate. It's certainly chaotic. I have lost track very often of what the actual state of the code- Mm... looks like 'cause I'm not in the loop. There was one point where we had wired Playwright directly up to the Electron app with MCP. MCPs I'm pretty bearish on because the harness forcibly injects all those tokens in the context, and I don't really get a say over it. They mess with auto compaction. The agent can forget how to use the tool.

There's probably only, what, three calls in Playwright that I actually ever wanna use, and so I pay the cost for a ton of things. Somebody vibed a local daemon that boots Playwright and exposes a tiny little shim CLI to drive it, and I had zero idea that this had occurred because to me, I run Codex, and it's able to- So suddenly it's better...

drive the UI. Yeah, like no knowledge of this at all. Uh-huh. So we have had, like in human space, to spend a lot of time doing synchronous knowledge-sharing. We have a daily stand-up that's 45 minutes long because we almost have to fan out the understanding of the current state. Yeah, I was gonna say, this is good for a single human multi-agent, but multi-human multi-agent is a whole, like, poly, like explosion of stuff.

Yeah, and that, this is fundamentally why we have such a rigid, like, 10,000-engineer-level architecture in the app because- We have to find ways to carve up the space so people are not trampling on each other. Sorry, I don't get the ten thousand thing. Did I miss that? The structure of the repository is like five hundred MPM packages.

It's like architecture to the access for what you would consider, I think, normal for a seven-person team. Mm. But if every person is actually like ten to fifty, then the, like, numbers on being super, super deep into decomposition and sharding and, like, proper interface boundaries make a lot more sense. Yeah.

To me, that's why I talk about micro front-ends and I... a- and exits from that world. But cool. Uh, just coming back to, to, to this, I don't know if you have o- other thoughts on orchestrating so much work going, going through this. Is this enough? Is this, like... Any aha moments? It'll be interesting to see, like, where... Okay, so right now you pick Linear as your issue tracker, right? Or is it like a l- is it actually Linear? This is actually Linear. Linear. Oh, that's Linear. It's Linear.

Oh, I n- I never looked at Linear. The demo video. The demo video I had to download to run. [laughing] So I- because I'm a Slack maxi, but yeah, Line- Linear is also really good. Yes. We do y- make a good use of Slack. We, we fire off codecs to do all these- Like we should- Low complexity fix ups, the things that like sync that knowledge into the repository. It's super cheap. Yeah, yeah.

Just do it in codecs and- My biggest plug is OpenAI needs to build Slack. You need to own Slack, build yours. Turn this into Slack. I, I did read- You know how to do this? Yeah. I would say that if we think that we want these agents to do economically valuable work, which is like this is the mission, right?

We want AI to be deployed widely to do economically valuable work, then we need to find ways for them to naturally collaborate with humans, which means collaboration tooling, I think is an interesting space to explore. Yeah, totally. Yeah. GitHub, Slack, Linear. Yeah, that was kind of my thing. Okay, where do we see... Right now, Codex has started Codex model, then CLI, now there's an app.

App can let me shoot off multiple Codexs in parallel, but there's no great team collaboration for Codex. And it seems like your team had some say into what comes out, right? So you talked to them. Codex kind of was a thing from there. If you guys are on the bound, what stuff that, like, you might not focus on, but what do you expect other people to be building, right?

So people that are like five X, fifty X-ing, should you build stuff that's like very niche for your workflow, for your team? Should it be more general so other people can adopt this or a niche there? 'Cause, 'cause part of it is just, okay, is everything just internal tooling? Do we have everything our own way? Like, the way our team operates has our own ways that we like to communicate.

Or is there a broader way to do it? Is it something like a issue tracker? Just thoughts if you wanna riff on that. I think TBD. We have not figured this out in a general way. I do think that there is leverage to be had in making the code and the processes as much the same as possible. If you think that code is context, code is prompts, it's better from the agent behavior perspective to be able to look in a package in directory XYZ and it not to have to page so deeply into directory ABC because they have the same structure, use the same language.

They have the same patterns internally. And that same, like, leverage comes from aligning on a single set of skills that you're pouring every engineer's taste into to make sure that the agent is effective. So like in our code base, we have, I think six skills. That's it. And if some part of the software development loop is not being covered, our first attempt is to encode it in one of the existing set of skills, which means that we can change the agent behavior more cheaply than changing the human driver behavior.

Yeah. [laughing] Have you ever, have you experimented with agents changing their own behavior? We do, yeah. A parent agent changing a sub-agent's behavior or something like that. We have some s- bits for skill distillation. So for example, there's one neat thing you can do with Codex, which is just point it at its own session logs- Mm. -to ask it to tell you how you can use the tool better.

Use it better, yeah. It's like- Introspection or- You can ask it to do things, right? Meta reflection. How can I do this session better? G- what skills should I have? I like the modification of you can do, just do things to you can just ask agent to do things. [laughing] Yeah, you can just Codex things. This is like a, this is like a silly emoji that we have, right?

You can just Codex things. You can just prompt things. It's really glorious future we live in. But okay, you can do that one-on-one, but we're actually slurping these up for the entire team into blob storage and running agent loops over them every day to figure out where as a team can we do better and how do we reflect that back into the repository- Yes... so everybody benefits- Yes... from everybody else's behavior for free.

Same for like PR comments, right? These are all feedback that means the code as written deviated from what was good. A PR comment, a failed build, these are all signals that mean at some point the agent was missing context. We've got to figure out how to- Yeah... slurp it up and put it back in the repo.

By the way, I do this exactly right. I u- when I use Cloud Code for knowledge work. [laughing] Cloud Code Work is like a nice product, right? Yes. And I think you would agree. I always have it tell me what do I do better next time, and that's the meta programming reflection thing. So almost think like you have six reflection extraction levels in Symphony, and almost like the zeroth layer.

So the six levels are po- policy, configuration, coordination, execution, integration, observability. We've talked a- about a couple of these. But the zeroth layer is like the, okay, are we working well? Can we improve how we work? Yes. Can I modify my own workflow.md or something? I don't know. Yeah, of course. Yeah. Of course you can. Like this thing is also able to cut its own tickets 'cause we give it full access.

Yeah. You can make a ticket to have it cut tickets. You can put in the ticket that you expect it to file its own follow-up work like- Self-modifying, yeah. Yeah. Put... Don't put the agent in a box. Give the agent full accessibility over its domain. I had a mental reaction when you said, "Don't put an agent in a box," 'cause I think you should put it in a box.

Like, it's just that you're giving the box everything it needs. Yeah. Context and tools. But we're like, as developers, we're used to calling out to different systems. But here you use the open source things like the Prometheus whatever, and you run it locally so that you can have the full loop, I assume. Yep. I think like another thing- You wanna minimize cloud, cloud dependencies.

You also wanna make sure that you think about what the agent has access to. What does it see? Does it go back in the loop? Like from the most basic sense of you let it see its own, like, calls, traces, it can determine where it went wrong. But are you feeding that back in? So you know, just the most basic level, if you wanna see exactly what's input/output, like does the agent have access to- What is being outputted, right? It, it can self-improve a lot of these things.

It's all text, right? [laughs] My job is to figure out ways to funnel text from one agent [laughs] to the other. It's so strange, like way back at the start of this whole AI wave, Andre was like, "English is the hottest new programming language." It's here. It's here. Yeah. The future is now. [laughs] Yeah. [laughs] A lot of...

Okay, like a lot of software, a lot of stuff, there's a GUI. It's made for the human. We're seeing the evolution of CLIs for everything, right? All tools have CLIs- Yeah... your agents can use them well. Do we get good vision? Do we get good little sandboxes? Like right now it's a really effective way, right? Models love to use tools. They love to bash. They love to read through text. So slap a CLI, let it go loose.

That, that works for everything. That does, yeah. We've also been adapting non-textual things to that shape in order to improve model behavior in some ways, right? We want the agent to be able to see the UI. Agents do not perceive visually in the same way that we do. They don't see a red box. They see red box button, right? They see these things in latent space. [upbeat music] So if we want- Hey, behind you.

[laughs] We have a thing that goes off every time you go see latent space. Ding. [laughs] Anyway, if we wanna actually make it see the layout, it's almost easier to rasterize that image to ASCII art and feed it in to the agent. Uh, and there's no reason you can't do both, right? To like further refine how the model perceives the object it's manipulating. Cool. Could we... You wanna talk about a couple more of these layers that might bear more introspection or that you have personal passion for?

I will say that the coordination layer here was a really tricky piece to get right. Let's do it. Yep. I'm all about that, and this is Temporal's core thing. This is where when we turn the spec into Elixir, where like the model takes a shortcut, right? Like it's, oh, I have all these primitives that I can make use of in this lovely runtime that has native process supervision, which is I think a neat way to have taken the spec and made it more- Tech choices...

achievable by making choices that naturally map- Yeah... to the domain. Yeah. Right? In the same way that like you would prefer to have a TypeScript model repo if you are doing full stack web development, right? Because the ability to share types across the front end and back end reduces a lot of complexity. And because- This is what GraphQL used to be. That's right. And- I, I don't know if it's still alive, but it's...

[laughs] No humans in the loop here, so like my own personal ability to write or not write Elixir doesn't really have to bias us away from using the right tool for the job. Yeah. Which is just wild. [laughs] Love it. I love it, yeah. I wonder if any languages struggle more than others because of this.

I feel like everyone has their own abstractions that would make sense, but maybe it might be slower, it might be more faulty where like you'd have to just kick the server every now and then. [laughs] Um, I, I don't know. [laughs] I think observable layer is really well understood. Integration layer, MCP is dead. I think all these are just like a really interesting hierarchy to travel up and down.

It's common language for people working on the system to understand. The policy stuff is really cool, right? Yeah. You don't really have to build a bunch of code to make sure the system waits for CI to pass. It's your institutional knowledge. Yeah, you just give it the GH CLI- Yeah... with some text that say, "CI has to pass." [laughs] It makes the maintenance of these systems a lot easier.

Do you think that CLI maintainers need to be, do anything special for agents or just as is it's good? 'Cause like I don't think when people made the G- GitHub CLI they anticipated this happening. That's correct. The GH CLI is fantastic. It's great. Super industry. [laughs] Everyone go try GH repo create, GH pull and then, uh, pull request number. Right. GH PR like 153, whatever, and then they label pulls.

Basically my only interaction with the GitHub web UI at this point is GH PR view-web. Exactly. Glance at the diff and be like, "Sure thing, send it." [laughs] But the CLIs are nice 'cause they're super token efficient and they can be made more token efficient really easily. Like I'm sure you all have seen like I go to Buildkite or Jenkins and I could just get this massive wall of build output.

And in order to unblock the humans, your developer productivity team is almost certainly gonna write some code that parses the actual exception out of the build logs and sticks it in a sticky note at the top of the page and you basically want CLIs to be structured in a similar way, right? You're gonna wanna pass dash silent to prettier because the agent doesn't care that every file was already formatted. It just wants to know it's either formatted or not so it can then go run a write command.

Similarly, like in our PMPM distributed script runner when we had one, when you do dash recursive, like it produces a absolute mountain of text, but all of that is for passing test suites. So we ended up wrapping all of this [laughs] in another script- To suppress the, the- Which you can vibe- The one channel, yeah... to only output the failing parts of the test.

You know you could pipe errors versus the send it, send it out. I, I don't know. Okay. Yeah, whatever. [laughs] Yeah. Too much thinking to have to do that. The, the CLI, I used to maintain a CLI for my company and yeah, this is like core, very core to my heart. [laughs] But you're vibing my job. That's right. [laughs] Cool. Any other things? Uh, this is a long spec.

I, I appreciate that. It's got a lot of strong opinions in here. Any other things that we should highlight? I think obviously we can spend the whole day going through some of these, but I do think that some of these have a lot of care or some of this you might want to tell people, "Hey, take this, but make it your own."

Fundamentally, software is made more flexible when it's able to adapt to the environment in which it is deployed, which means that things like Linear or GitHub even are specified within the spec but not required pieces of it. There's like a more platonic ideal of the thing that you could swap in like Jira or Bitbucket, for example. But being able to tightly specify- Things like the ID formats or how the Ralph loop works for the individual agents basically means you can get up and running with a fully specified system quickly that you then evolve later on.

I think we never intended for this to be a static spec that you can never change. It's more like a blueprint to get something working- It's a starting point... up and running- Yeah... for you then to vibe later till your heart's content. You have, like, code and scripts in here where it's, oh, I think this is a really good prompt. It's just a very long prompt [laughs].

Fundamentally, the agents are good at following instructions, so give them instructions, and it will improve the reliability of the result. We... Much like the way we use Symfony, we don't want folks to have to monitor the agent as it is vibing the system into existence. So being very opinionated, very strict around what the success criteria are means that our deployment success rate goes up. Yeah. Means we don't have to get tickets on these things [laughs]. Yeah.

I think it all goes back to that, like, code is disposable, right? Like, early on when you had CLIs, or you'd kick off a Codex run, it would take two hours. You would wanna monitor. Okay, I'm in the workflow of just using one. I don't want it to go down the wrong path. I'll cut it off, and then just shoot all four. Like, that was my favorite thing of the Codex app, right? Right. Just Vorex it.

Like, it's okay. One of them will probably be right. One of them might be better. Stop overthinking it. Like, my first example is probably, like, deep research. When you put out deep research and I'd ask it something, like, I asked it something about LLM, it thought it was legal something, and spent an hour, came back with a report completely off the rails, and I was like, "Okay, I gotta monitor this thing a bit."

No, don't monitor it. Just you wanna build it so it goes the right way and you don't wanna, you don't wanna sit there and babysit, right? You don't wanna babysit your agents. With that deep research query that you made, looking at the bad result, you probably figured out you needed to tweak your prompt- Yeah... a bit, right?

That's that guardrail that you fed back into the code base for the- Yeah... task, your prompt, to further align the agent's execution. Same sort of concepts apply there too. When you talk... How are the customers feeling? For Symfony, I think we have none, right? This is a thing we have put out into the world. Symfony is internal, right? Right. As long as you're happy, you're the customer. That's right.

Just what's the external view? I'd say folks are very excited about this way of distributing software and ideas in cheap ways. For us, as users, it has, again, pushed the productivity 5X, which means I think there's something here that's, like, a durable pattern around removing the human from the loop and figuring out ways to trust the output.

The video that is shared here- Yeah... is the same sort of video we would expect the coding agent to attach to the PR- Yeah... that is created. Yeah. That's part of building trust in the system, and that's, to me, like, fundamentally what has been cool about building this, is it more closely pushes that persona of the agent working with you to be like a teammate.

I don't shoulder surf you, like, for the tickets that you work on during the week. I would never think that I would want to do that. Yeah. I wouldn't want a screen recording of your entire session in Cursor or Claude Code. I would expect you to do what you think you need to do to convince me that the code is good and mergeable. Yeah.

And compress that full trajectory in a way that is legible to me, the reviewer. Yeah. Yeah. It's just, uh, and you can just do that because Codex will absolutely sling some FFMPEGs around. You can just- It's great [laughs]. Oh, FFmpeg is the OG, like, god CLI. Yeah. Swiss Army chainsaw [laughs]. I used to say there's a SaaS, microSaaS let's call it, in every flag in FFmpeg. Oh, for sure.

You know what I mean? For sure. Just host it as a service, put a UI on it. People who don't know FFmpeg will pay for it. When we were first experimenting with this, it was a wild feeling to be at the computer with just, like, windows just popping up all over the place and getting captured- Yeah... and files appearing on my desktop.

Like, very much felt like the future- Yeah... to have a thing controlling my computer for, like, actual productive use. Like, I'm just there keeping it, like, awake, jiggling the mouse every once in a while [laughs]. That's what some office workers do. So- They buy a mouse jiggler device. That's right [laughs]. One thing I wanted to ask. Okay.

As stuff is so code is disposable, async, shoot off a bunch of agents, one question is, okay, are you always, like, a extra high thinking guy, and where do you see Spark? So 5.3 Spark, there's a lot of me wanting to make quick changes. I'm not gonna open up a ID. I'm not gonna do anything, but I will say, "Okay, fix this little thing, change a line, change a color."

Spark is great for that. But am I still the bottleneck? Like, why don't I just let that go back and, like, just riff on that. Is there... Spark is such a different model compared to the, the extra high level of reasoning that you get in these 53, 54. Yeah, to be clear for people, it is a different model, a different architecture, different... Like, it doesn't support it.

It's just- It's incredibly fast... a smaller model. I have not quite figured out how to use it yet, to be honest. I- It's faster... I was adapting it to the same sorts of tasks I would use X high reasoning for. Yeah, I know. And it would blow through three compactions before writing a line of code. And- That's another big thing with 5.4, right? Million token context- Yes. It's fantastic... which is huge in agentics, right?

Like, you can just run for longer before you have to compact. The more tokens you can spend on a task before compacting, like, the better you'll do. That's right. That's right. I'm not sure how to deploy Spark. I think your intuition is right, that it's very great for spiking out prototypes, exploring ideas quickly, doing those documentation updates.

It is fantastic for us in taking that feedback and transforming it into a lint where we already have good infrastructure for ES lints in the code base. These sorts of things it's great at, and it allows us to unblock quickly doing those, like, anti-fragile healing tasks in the code base. Mm-hmm. Yeah, that makes sense.

So you're push- you guys are pushing models to the freaking limit. What can current models not do well yet? They're definitely not there on being able to go from new product idea to prototype Single one-shot This is where I find I spend a lot of time steering, is translating end state of a mock for a net new thing, right?

Think no existing screens into product that is playable with. Similarly, while this has gotten better with each model release, like the gnarliest refactorings are the ones that I spend my most time with, right? The ones where I am interrupting the most, the ones where I am now double-clicking to build tooling to help decompose monoliths and things like that. This is a thing I only expect to get better, right?

Over the course of a month, we went from the low complexity tasks to like low complexity and big tasks in both these directions. So this is what it means to not bet against them all, right? [laughs] You should ex-expect that it is going to push itself out into these higher and higher complexity spaces. Yeah. So the things we do are robust to that.

It just basically means I'll be able to spend my time elsewhere and figure out what the next bottleneck is. I do think it's also a bit of a different type of task, right? Codex is really good at code base understanding, working with code bases, but companies like Lovable, Bolt, Replit, they solve a very different problem scaffold of zero to one, right, idea to product, and it's...

There, there are people working on that, and models are also pushing like step function changes there. It's just different than the software engineering agent today, right? Like I said, the model is isomorphic to myself. The only thing that's different is figuring out how to get what's in here into context for the model.

And for these white space sorta projects, I, myself, I'm just not good at it, which means that often over the agent trajectory, I realize the bits that were missing, which is why I find I need to have the synchronous interaction in. I expect with the right harness, with the right scaffold, that's able to tease that out of me or refine the possible space, right?

To be super opinionated around the frameworks that are deployed or to put a template in place, right? These are ways to give the model all those non-functional requirements, that extra context to anchor on and avoid that wide dispersion of possible outcomes. Thank you for that. I wanted to talk a little bit about Frontier- Yeah, sure... overall.

You guys announced it maybe like a month ago, and there's a few charts in here, and it's eff- basically like your enterprise offering is what I view it. Is there one product or is there many? I can't speak to the full product roadmap here, but what I can say is that Frontier is the platform by which we want to do AI transformation of every enterprise and from big to small.

And the way we wanna do that is by making it easy to deploy highly observable, safe, controlled, identifiable agents into the workplace. We want it to work with your company native IM stack. We want it to plug into the sc- security tooling that you have. Oh. We want it to be able to plug into the workspace tools that you use. So you're just gonna be stripping specs, right?

[laughs] We expect that there will be some harness things there. Agents SDK is a core part of this to enable both startup builders as well as enterprise builders to have a works-by-default harness that is able to use all the best features of our models, from the shell tool down to the Codex harness with file attachments and containers and all these other things that we know go into building highly reliable, complex agents.

We wanna make that great, and we wanna make it easy to compose these things together in ways that are safe. For example, right, like the GPT-OSS Safeguard model, for example, one thing that's really cool about it is it ships the ability to interface with a safety spec. Safety specs are things that are bespoke to enterprises.

We owe it to these folks to figure out ways for them to instrument the agents in their enterprise to avoid exfiltration in the ways they specifically care about- Mm... to know about their internal company code names, these sorts of things. So providing the right hooks to make the platform customizable, but also mostly working by default for folks, is the space we are trying to explore here. Yeah.

And this is the Snowflakes of the world just need this, right? Yeah. The Brex's of the world, Stripes, yeah. Makes sense. I was gonna go back to your... I think the demo videos that you guys had was pretty illustrative. It's like also, to me, an example of very large-scale agent management. Yes. Like, you give people a control dashboard that if you play a- if you like play any one of these like multiple agent things, you can di- dig down to the individual instance and see what's going on. Yes, of course.

But who's the user? Is it, is it like the CEO, the CTO, CIO, something like that? At least with, with my personal opinion here, the buyer that we're trying to build product for here is, one, end employees who are making productive use of these agents, right? That's gonna be whatever surfaces they appear in, the connectors they have access to, things like that.

Something like this dashboard is for IT, your GRC and governments folks, your AI innovation office, your security team, right? The stakeholders in your company that are responsible for successfully deploying into the spaces where your employees work, as well as doing so in a safe way that is consistent with all the regulatory requirements that you have and customer attestations and things like that.

So it is a iceberg beneath the actual end employee face. It's great. Yeah, you jump every, I guess, layer in the UI is like going down the layer of extraction in terms of the agent, right? Yep. Yeah, yeah, I think it's good. Yeah. The ability to dive deep into the individual agent trajectory level is gonna be super powerful, not only for from like a security perspective, but also from like someone who is accountable for developing skills.

One thing that was interesting that we also blogged about shipping was an internal data agent which uses a lot of the frontier technology in order to make our data ontology accessible to the agent and things like that to understand what's actually in the data warehouse. Yeah, semantic layer- Yes... type things. I was briefly part of that, that world. Is this all? I don't know. [laughs] It's actually really hard for humans to agree on what revenue is. Yes. Yes.

What is- There's like- What is an active user? There's, what, five data scientists in the company that have defined this golden query. They all define it differently. Yeah, and no, and there's also internal politics- Yes... as to attribution of I'm marketing, I'm responsible for this much, and sales is responsible for this much, and they all add up to more than 100.

[laughs] And I'm like, "You guys have different definitions." [laughs] Yeah, and if you're a startup, everything is ARR. So I think that's cool. Oh, you guys blogged about this. Okay, I didn't see this. Yeah. Is this the same team? I, I don't know. Is this what you're referring to? Yes. Okay. We'll send people to read this. This is our data agent. Yeah. A lot of good reading-... this one.

Yeah, I, I don't know if you, you have any highlights. I- In general from the playlist. Yeah. A lot of good things to read. Yeah, yeah. Lot, lots of homework for people. No, but, like, data as the feedback layer, you need to solve this first in order to have the product's feedback loop closed. That's right.

So for the agents to understand, and this is not something that humans have not solved this. Like, in- This is how you build agents- OpenAI runs-... that are artists, that do more than coding, right? Yeah, yeah. To actually understand how you operate the business- Yeah... you have to understand what revenue is, what your customer segments are- Yeah... what your product lines are.

Like, one thing that's in looping back to the code base that we described here for harnessing, one thing that's in core beliefs.md is who's on the team, what product we're building, who our end customers are, who our pilot customers are, what the full vision of what we want to achieve over the next 12 months is.

These are all bits of context that inform how we would go about building the software. Oh my God. So we have to give it to the agent too. I'm guessing that stuff is, like, pretty dynamic, and it changes over time too, right? Like, part of it was it's not just a big spec. You have it as one of the things, and it will iterate.

One, one thing that I think is gonna break your mind even more is we have skills for how to properly generate deep-fried memes and- [laughs]... have ReactG culture in Slack because with the Slack ChatGPT app that you're able to use and Codex, like, I can get the agent to shit post on my behalf. Amazing. Just it's part of humor and team. Humor is part of AGI.

Is it funny? It's pretty good. Yeah. Okay. Yeah. It's pretty good at making deep fries. It's a lot of... I think humor is, like, a really hard intelligence test, right? It's like you have to get a lot of context into, like, very few words. This is why- Make references... this is why 5.4 is such a big uplift for our memelords. It's the memeing. Yeah, for sure.

[laughs] [laughs] All right. Yeah, yeah, it's very cool. So 5.4 can tip us. [laughs] That's our, that's our takeaway. Yeah. Maybe, maybe when y'all are done here today, ask Codex to go over your coding agent sessions and to roast you. Love it. [laughs] I'll give it a shot. I'll give it a shot. [laughs] Coming back to the, the final point I wanted to make is- Yeah... yeah, I think that there, there are multiple other...

Like, you guys are working on this, but this is a pattern that every other company out there should adopt- Yes... regardless of whether or not they work with you. To me, this-- I, I saw this, I was like, "Fuck, every company needs this." This is multiple billions- And that's what it takes to get- Yeah... people to yes. Yeah. To actually realize the benefits- Yes...

and distribute the AGI- Build the admonishment layer... right? And it's, it, it... I think it sounds boring to people, like, "Oh, it's for safeguards and whatever," but I think you, to handle agents at scale like you're envisioning here, I don't know if it's, like, a real screenshot or, like, a demo, but this is what you need.

This is origin- my original sort of view of what Temporal was supposed to be, that you've, you built this dashboard, and you basically have every long-running process in the company- Yes... in one dashboard, and that's it. [laughs] That's right. Yeah, I think it's pretty customized towards every enterprise, right? Like, you care about different things. There's a lot of customization. Yeah.

There'll be multiple unicorns just doing this as a service. I don't know. [laughs] I'm, like, very frontier pilled, if you can't tell. [laughs] Amazing. Love it. But it, it only clicks because obviously this came out first, then Harness, and then Symphony, and it only clicked for me that, like, this is actually the thing you ship to do that. Yeah, yeah.

There's a set of building blocks here that we assembled into these agents, and the building blocks themselves are part of the product, right? Yeah. The ability to steer, revoke authorization if a model becomes misaligned. Like, all of this is accessible through Frontier, and there's gonna be a bunch of stakeholders in the company that have the things they need to see in the platform- Yeah... to get to yes.

So we'll build all those in the frontier so that we can actually do the widespread deployment. Yeah. That's the fun part. Yeah. I'm also calling back to there's these, like, levels of AGI. I don't know if OpenAI is still talking about this, but they used to talk about five levels of AGI, and one of it was like, oh, it's like an intern coding software engine. At some point, it was AI organization, and this is it. That's right. Like, this, this is level four or five. I can't remember which, which level, but it, it's somewhere along that path was this.

You know how I mentioned that my team is having fun sprinting ahead here, and we do this thing where we're collecting all the agent trajectories from Codex to slurp them up and distill them? This is what it means to build our team-level knowledge base. Happen to reflect it back into the code base, but it doesn't have to be that way, and it doesn't have to be bound to just Codex.

I want ChatGPT to also learn our memeing culture and also the product we are building and how, so that when I go ask it, it also has the full context of the way I do my work, and I'm super excited for Frontier to enable this. Yeah. Amazing. What do the model people say [laughs] when they see you do this? Like, you have a lot of feedback, obviously. You have a lot of usage. You have a lot of trajectories.

I don't, I don't imagine a lot of it's useful to them, but some of it is. You have this too. You deploy a billion tokens [laughs] of intelligence a day, and this was, this was at the beginning of 2026. You're, you're cooking. Yeah. There's this fundamental tension which I think you have talked about between whether or not- We invest deeper into the harness, or we invest deeper into the training process to get the model to do more of this by default.

Yeah. And I think success for the way we are operating here means the model gets better taste because we can point the way there, and none of the things we have built actively degrade agent performance 'cause really all they're doing is running tests, and, like, running tests is a good part of what it means to write reliable software.

If we were building an entire separate Rust scaffold around Codex to restrict its output, that I think would be, like, additional harness that would be prone to being scrapped. But- Yeah, yeah... if instead we can build all the guardrails in a way that's just native to the output that Codex is already producing, which is code, I think no friction with how the model continues to advance, but also, like, just good engineering, and that's the whole point.

Yeah. Uh, and so I've had similar discussions with research scientists where the R- RL equivalent is on-policy versus off-policy. Yeah. And you're basically saying that you should build an on-policy harness, which is already within distribution and you modify it from there, but if you build it off-policy, it's not that useful. That's right. Super cool.

Any important thoughts? Any things that we haven't covered that we should get out, get out there? Just I've been super excited to benefit from all the cooking that the Codex team has- Yes... been doing. They absolutely ship relentlessly. This is one of our core engineering values, ship relentlessly, and they-the team there embodies it to an extreme degree. Yeah. To have 5.3 and then Spark and 5.4 come out within what feels like a month is just phenomenally fast. It's exactly a month ago was 5.3 and yesterday was 5.4. Yeah. I mean, is- do we have every month now?

Is 5.5 next, like [laughs] It's like, uh- You can't say that. Yeah. The poli markets would be very upset. I think it's interesting that it's also correlated with the growth. They announced it is 2 million users, but, like, almost don't care about Codex anymore. This is it. This is the game, man. It's like coding cool, soft, like knowledge work. That's right. This is the thing to chase after.

Yeah. And this is one of the things- I- yeah... that my team is excited to support. Get the whole, like, self-hosted harness thing working, which you have done, and, like, the rest of us are trying to figure out how to catch up, but then do things, you know? That's right. With it. [laughs] Do things.

[laughs] That's right. You can just do things. That's the line for the episode. That's it. Any other call to actions? You're based in Seattle, your team, I'm guessing. New Bellevue office. New Bellevue office. We just had the grand opening yesterday as of the recording date- Yes... which was fantastic. Beautiful building. Super excited to be part of the Bellevue community, building the future in Washington.

And I would say that there is lots of work to be done in order to successfully serve enterprise customers here in Frontier. We are certainly hiring, and if you haven't tried the Codex app yet, please give it a download. We just passed 2 million weekly active users, growing at a phenomenally fast rate, 25% week over week. [laughs] Geez. Come join us. [laughs] Yes. And I think, uh, that's an interesting...

Um, my, my final observation, OpenAI is a very San Francisco-centric company. I, I know people who have been- who turned down the job or didn't get the job 'cause they didn't wanna move to SF, and now they just don't have a choice. You have to open to London. You have to open to Seattle, and I wonder if that's gonna be a shift in the culture. Obviously, you can't say, but... I was one of the first engineering hires out of our Seattle office. Yeah.

So- Se- Seattle was very natural... its success has been part of what I have been building toward and it is- it has grown quite well, right? Yeah. We have durable products and lines of business that are built out of there. A ton of zero to one work happening as well, which is the core essence of the way we do applied AI work at the company to sprint after it new to figure out where we can actually successfully deploy the models. Yeah.

Yes, 100%. We also have a New York office too- Yes... that has a ton of engineering presence. Yeah. Yeah, exa- exactly. That's- these are my roadmap for AI. [laughs] [laughs] Wherever people are hiring engineers, I will go. That's right. As, um- The cool office to New York is the old REI building, I believe, the REI office. It's just... No, it will never be as big.

New York is... You can't get the size of office that they need. The New York office- Seattle you can get... has a very- Office... Mad Men vibe. It's beautiful. The Bellevue one is very green, gold fixtures, very Pacific Northwest. It's very cool. The place is a vibe. It'd be a local hire, yeah. A lot of people are, like, there for.

People like New York, they wanna be in New York, right? Yeah. Yeah. We have a fantastic workplace team that has been building out these offices. It really is a privilege to work here. Yeah. Excellent. Okay, thank you for your time. You've been very generous, and you're- you've been cooking, so I- let me let you get back to cooking. It's been amazing chatting with you folks. Happy Friday. Happy Friday.

[outro music]

Extreme Harness Engineering for Token Billionaires: 1M LOC, 1B toks/day, 0% human code, 0% human review — Ryan Lopopolo, OpenAI Frontier & Symphony

Kapitelklicken springt direkt hin

Shownotes

Transkriptvom Podcast bereitgestellt · Zeitmarken springen hin