Right now, a lot of engineering leaders are stuck in the same loop: rolling out AI tools only to watch their teams quietly drift back to business as usual. Andrew sits down with James Everingham, former Head of DevInfra at Meta and current CEO of guild.ai, to discuss how to break this cycle by treating AI not just as an autocomplete tool, but as a "sentient fabric" woven directly into your software development lifecycle. They explore how replacing top-down AI mandates with impossible business challenges—like eliminating code freezes entirely—empowers developers to organically build game-changing tools like conversational onboarding agents. Finally, James breaks down why 2026 is the year of the agent and how his team is building the enterprise infrastructure needed to safely govern, audit, and scale collaborative agent workflows.
Show Notes
Transcript
(Disclaimer: may contain unintentionally confusing, inaccurate and/or amusing transcription errors)
[00:00:00] Andrew Zigler: Hello to our listeners and welcome back to Dev Interrupted. Right now, a lot of engineering leaders are stuck in the same loop. They roll out AI tools and they see promising demos, but when they go to measure productivity, the numbers get fuzzy and the organization quietly drifts back into business as usual.
[00:00:18] Andrew Zigler: Sound familiar. James Everingham, however, has lived the opposite story. After nearly a decade at Meta, including leading Instagram engineering, he was pulled back to help run Dev infra a thousand person org, responsible for the internal developer experience of 40,000 engineers and technologists. There he discovered that the real gains
[00:00:40] Andrew Zigler: come from when you stop thinking about AI as an authoring tool and start treating it as sentient fabric across your entire SDLC. And that's what we're gonna talk about today, because internally that work became DevMate, an agent platform that went viral inside of Meta and grew to the point where it's agents were submitting [00:01:00] 50% of all diffs.
[00:01:01] Andrew Zigler: And now James is taking those lessons to the rest of the world as the CEO of guild.ai, where he is building enterprise infrastructure for AI agents so that every engineering org, not just meta scale companies can centralize and orchestrate and safely scale their agent workflows. This is something we've been talking about quite a bit on Dev Interrupted, so we're really excited to dig in.
[00:01:23] Andrew Zigler: And James, welcome to Dev Interrupted.
[00:01:26] James Everingham: Thank you so much for having me on. I'm excited to be here today.
[00:01:29] Andrew Zigler: Great. Well, let's go ahead and jump into talking about that mental transition. Uh, the one I kind of opened with here about moving from the idea of AI being an editor, a helper to being part of the fabric that you work within. Um, you know, when you were leading Dev infra, you realized pretty quickly that like, you know, auto complete and just finishing your idea of what to implement is not where the biggest wins are.
[00:01:53] Andrew Zigler: You, you want for these. Larger leverage opportunities within the infrastructure, beyond the editor, what was, what was [00:02:00] that realization like and what led you to go there?
[00:02:02] James Everingham: Yeah, sure. I think, you know, when we first started looking, you know, we were on the same path as, as everyone was trying to accelerate developer productivity using ai. We started with the same tactics that we saw, such
[00:02:16] Andrew Zigler: I.
[00:02:16] James Everingham: I would say the, in the in authoring experiences, you see the cursors and the copilots out there, which are. Uh, auto complete. These have evolved to much more than that, but that's where we all started. We had an advantage there where we were, we owned all of the internal tooling we owned.
[00:02:34] Andrew Zigler: Hmm.
[00:02:35] James Everingham: We owned the, we, we had to build our own editors. We had to build our own source control because the repository was so large. It wasn't that we were, uh, an NIH company. It's just that the infrastructure so vast and large, these tools just wouldn't work. Uh, so the advantage of that though was that we got to measure and experiment quickly with a very closed economy of developers. So we could learn pretty quickly. We did learn [00:03:00] that like, hey, these tools like Cursor, which we basically came pretty close to feature parity with, internally with our internal product called code composed. you would get a certain level of productivity more with the junior engineers. And actually surprisingly, some of the very senior engineers, but the, the bulk of the engineers in the middle weren't actually, uh, it wasn't moving anything meaningful. And you know, that's a whole conversation itself is like, what is moving something meaningful actually mean, which we put a lot of thought into as well. Um, so we experimented and eventually, uh, we, we started trying some different things. And one thing that we did, we had this realization that, hey, you know, AI is a very powerful tool, but if you actually move some of this new agentic behavior closer to your source control system as part of the infrastructure, you get a lot more impact and you can do a lot more interesting things.
[00:03:56] James Everingham: You know, source control is like the canonical source of truth. Like [00:04:00] your teams, your tools, everything connect to it. There's your code, your history, um, and if you can intercept some of those tool connections and invoke agents. Um, and, uh, you can start doing some super interesting things.
[00:04:13] Andrew Zigler: You mentioned this opportunity. You have that because you owned all these different parts of the stack and you had everything custom built. You get these really amazing opportunities to slice and dice and examine, and that's like a privilege and an ability that like not a lot of orgs have to like the level of granularity that,
[00:04:33] Andrew Zigler: that they get. And so I think there's oftentimes, models the process of trying to experiment and measure the impact. Like what would you, what would you say to somebody who is working within an org and doesn't have that level of detail in slicing their whole top to bottom system? Like where should they start to try to zoom in first and, and look at what they can get their hands on?
[00:04:57] James Everingham: That's a good question because like it's, it's, I think [00:05:00] that's one of the things that the industry is also struggling with right now is like, where do you even start? Like, you know, a lot of the companies that we talk to now outside of Meta, that's the first thing that we come across is like, Hey, you know, we're all getting pressure to, to do more, to develop faster and things like that, but it's not even clear where to start. what, what we found, the formula that we found inside Meta that really helped kick things off was that, we had a centralized place where, where, when, when I talked about this platform, which was DevMate that connected to the infra war. It was also a centralized place where engineers could go and actually see what agents were there, what, what was working, what wasn't. And they could build on 'em. They could, view them, they could dig in, they could branch them, they could create their owns based on those. And, and that was a great starting place.
[00:05:53] James Everingham: You know, as engineers, you know, I, you know, speaking for myself, I was a better, like thief than coder. Like, [00:06:00] I would go look for something that would. Uh, that would do kind of what I want and then like I would try to get that and wrangle it into something that would work for my specific thing. And I would learn along the way.
[00:06:11] James Everingham: And if it didn't ultimately work, I'd have enough knowledge to go build something new. And I think that's not, I don't think I'm that unique. I think a lot of engineers work that way. And so when we had this centralized surface. It was a clear starting place. So, you know, for companies that are outside, meta is like one, you know, where do you go?
[00:06:32] James Everingham: Where do you go find this clear starting place, you know, where do you go and point at things that are working outside. And, you know, we're getting better. It's like becoming more clear what works in the industry now. You're seeing a lot of more, uh, referenceable, uh, pieces of technology that are actually doing real things.
[00:06:51] James Everingham: So I think this will become less of a problem over time. But right now, you know, it's, it's not clear where to start and it's not even clear what, you [00:07:00] know, the holy grail of metrics is developer productivity. Like, you
[00:07:04] Andrew Zigler: Right.
[00:07:05] James Everingham: um, is it lines of code? I, I don't think it is. You know, some of the most productive developers delete more code than they create, right?
[00:07:12] James Everingham: So, Is it feature velocity? You know, what is productivity in your company? I think another place to start is figuring out and, and getting pretty, pretty detailed on what that actually means in your company.
[00:07:27] Andrew Zigler: you really hit on some really amazing details here because focusing in on the first idea that like, you have to understand what matters to your company and or your organization before you can even go out and hunt these things, and the idea that also of, you know, always being a better like.
[00:07:43] Andrew Zigler: Thief than like a CR original creator. I totally like that resonates with any kind of engineer. We don't wake up and we're like, oh, I wanna rewrite grep today. Like we go and find the tools that help us get the outcomes that we're looking for with software. So, you know, I'm always looking to leverage. And learn [00:08:00] from other people that are playing within the same space.
[00:08:01] Andrew Zigler: So what y'all did was really smart. You created this like a corral basically, where all these agents and these workflows and these experiences can go, folks can go and learn and experiments, fork, and then standardize. That's kind of like you get to that core, that like idea of a fabric where the agentic work is happening in your infra.
[00:08:20] Andrew Zigler: So you know. As part of that too, I bet that you got a really great glimpse into emergent kind of solutions and agentic things that you probably definitely didn't have on your radar or didn't think about, but because an engineer within your org was empowered and was, and had this place to share, that stuff got elevated.
[00:08:40] Andrew Zigler: Like what were some of those that stood out to you?
[00:08:42] James Everingham: you know, you, you hit a very important point is like, you know, one of the things that was interesting in Dev Infra is like, we would get stuck in thinking like, what are the best things that we can build for developers? And what we found when we pushed the tools to the developers themselves to solve their [00:09:00] own problems, the best things were coming from the teams outside of developed Dev infra. And you know, so I think like the measure of a successful initiative or a successful platform is when the ideas are coming from your customers that you know, and they're able to build on it. So a few examples of that were one, we had something called diff risk score, and it was a. Using an LLM in a rather novel way.
[00:09:27] James Everingham: Um, and this was open sourced actually last year, where it would measure the amount of risk that a disc a diff would have when you push it to production, to crashing the system. course, like many companies. Uh, we freeze at meta. We would freeze the code base at like December 9th through January during the holiday because that is where the most traffic is a very important time for the company. This allowed us to start removing that code freeze, like, and uh, the way that we, the way that these this happened wasn't by saying, go build diff [00:10:00] risk score and do this. It was a challenge to the company saying, how do we eliminate code freeze? And then the engineers came and built these tools to start doing it. Um, so that's one example. Other ones that just sort of organically popped up that I thought were amazing was this incredible onboarding agent that an engineer built. And, you know, once again, you know, I have a friend that I keep re quoting saying, you know, great soft building, great softwares and active empathy. Um, and this was no exception to that. It was, it was an engineer that was trying to familiarize himself with a code base to be productive. And he built an agent to go help him do that. This agent, I'll explain it a little bit, like back at Instagram, which you mentioned if you brought a new engineer in and you said, Hey, I want you to work on these specific camera filters. That engineer might take a week just to figure out where those files even are. And, um, it's, it's, it's a complicated code base and process. The [00:11:00] onboarding agent sort of made the source control base sentient in a way, so you could ask it questions, you could say, I went to work on these specific camera filters. And it would say, well, that's these files. Would you like a system diagram? And it would draw you a system diagram. Would you like to know about the history of this and why things are done? And you could have a conversation with the source base. And this onboarding agent, um, would effectively the source base onboard the engineers, uh, directly.
[00:11:31] James Everingham: And had measured something called TTFD or time to first diff and that was like. long does it take to get an engineer in and get them to submitting their first diff. And this agent alone was, was decreasing that, um, pretty significantly. And at scale, that's a lot of man years reclaimed in a large workforce. So those were just a couple hundreds of these popped up things that I had no idea, um, like would never have imagined. It was really fun [00:12:00] to watch.
[00:12:01] Andrew Zigler: That onboarding agent is a really powerful, uh, unlock because what that represents actually is like a huge amount of downstream leverage that you were able to unlock as the person implementing that kind of infrastructure. By creating a space where other people could create infrastructure and save themselves time, someone else then created.
[00:12:21] Andrew Zigler: A tool, a system that then saved everybody a ton of time. And that was a leverage beyond your initial leverage. And that's what happens when you create these spaces where folks can solve the hardest problems within your engineering org. And I think like something like time to first diff is really critical for huge code bases.
[00:12:38] Andrew Zigler: And I know, a lot of our listeners who work on a huge code base is really identify with that pain, especially when it comes to bringing in folks who are trying to have instant impact. I think that like in in this world, you're describing this as the ideal, right? Where like you said, your customers, your stakeholders are coming to you with
[00:12:55] Andrew Zigler: things they wanna, they wanna do and they're building it on your platform. But, you know, sometimes that script is [00:13:00] not necessarily what is happening or unfolding within an org. Sometimes you get more top down mandates and things from leaders within an organization about how AI will be used or, or what are policy around it is, or a top down goal that maybe doesn't really tie that well to like technical throughput for engineers.
[00:13:20] Andrew Zigler: So, you know. What do you think about that approach? How would you advise somebody to navigating that as an engineering leader to try to really unlock value?
[00:13:29] James Everingham: Yeah, sure. I, you know, I think that I'll make, you know, I've, I've been not, um, quiet about this. I do get a little, a little frustrated when I see, uh, and leaders saying, mandating their teams
[00:13:42] James Everingham: use AI for productivity. I think the best developer tools like you have to earn the usage. Now, like, developers are smart. They're, you know, they wanna do good work, but they're also, you know, they have a set of tools that they've become very proficient with over time, [00:14:00] and they take some convincing. Right now, the, the way to do that, in my opinion, isn't to mandate. Like, Hey, you all need to use these specific tools. I think what we ended up doing that, that, that really helped was to put business challenges out one to your organization that forces them to think differently. Like for example, another one that we put out there in Dev Infra is, can you make self-healing fabric? Can you make it so that when, uh, if the system does crash. You can identify it automatically. You can write the code to fix it. You can write a test case to prove that it fixes it. You can run it through that loop until it finds it, land it responsibly, um, and minimize the, the, the impact radius of that outage. When you start putting these types of challenges out, like there's not many other tools that you can use, it's sort of force to use AI to do that. So that's just one part of the equation. Now [00:15:00] AI is very good at doing simple things. It's, it's a little more challenging to get it to do very complex algorithmic things, right? So like getting the uh, product team is a lot easier, uh, to prove, uh, utility with these tools than like, bowels of a, a VM or a languages or a kernel team, right?
[00:15:21] James Everingham: Like, those are
[00:15:21] Andrew Zigler: Yeah.
[00:15:22] James Everingham: hard things to do, but you can still put challenges out there for those types of teams. Uh, you know, can you optimize compiler output with an LLM? You know, can you change the spec of a language to, uh, actually, make more, uh, say an LLM can more accurately build the right code? You know, things like that. Once you get that, the next part of it is to get some senior engineers who, who have had, uh, success with it and they should be your evangelists. So, we luckily at Meta we had these amazing internal, uh, [00:16:00] workplaces where everyone could communicate openly to the company. And we had senior engineers that were like, look what we just did.
[00:16:06] James Everingham: We did this with this agent. The other senior engineers then would be, see that and they would, they, they would, they would want to actually try something or would spur something where their thinking and that organic earned usage is what really ended up moving the dial. Right? Like they're going to use the tools if they can help them, but, you know, the early tools, they're getting better. Don't help every engineer, some of them slow them down, and so, so the mandates are a little, a little, a little misguided if you ask me.
[00:16:38] Andrew Zigler: Yeah, and that's really good advice for how to level set it because you take that top down kind of mandate and you find a way to turn it into a collaborative space where those organic gains can serve. Surface, like if you have a top-down mandate, okay, then use that to establish a recurring learning and sharing meeting, and then use that to incubate these [00:17:00] best ideas that maybe in an ideal world, like with the one you were describing at at meta, like you would, it would be evolving and happening in like this shared kind of agentic mesh or like a corral of different agents doing different stuff, you know?
[00:17:12] Andrew Zigler: So, Within that too. I think once you get to that point, and maybe you're in a position of having to prove, uh, value back in like a top down kind of way, once you have that kind of muscle built, then you can start exploring things like, um, like you said, like getting rid of your code freeze. Is a great example.
[00:17:31] Andrew Zigler: I'm sure there's like a lot of, uh, bandage or like back of the room, back of the office kind of issues that like any team could think up and, and, and, and, and tackle. Like are there any other, like big ones that come to mind for you that you'd recommend people like every org has this debt. Go tackle this debt with AI, prove your worth.
[00:17:48] James Everingham: Yeah, I think that, look, test testing is one that everyone does is test cases. And, you know, you can have a hundred percent test coverage code-wise, but humans actually, uh, will [00:18:00] end up using the products in different ways where different code paths get exercised and you can never, uh, find all of the problems, but like, one challenge we put out there is, can you build a testing harness that would simulate how a human would actually use the software? Um, and that's something really good that an LLM can do. It can mimic behavior. So instead of saying, go and automate test suite, this image. Test this filter, test this. You could basically give it a script and say you're a user, you're walking down the street, you take photos of this, you wonder where there's restaurants. So you look those up and you can describe a user scenario and then, you know, have an LLM, go replay that into your software. And so like that was another example. But we, we had a lot of big challenges like eliminate code free, uh, um, self-healing fabric, can we expand uh who contributes [00:19:00] to the feature set beyond engineers? Can we go directly to product, to designers, to everyone in the company, to people outside the company? Like what are these big challenges?
[00:19:10] James Everingham: And it's fun. Like, here's the great opportunity to do with your org that we really just, we might have gone overboard at some point with it, but look, you know, we get to write science fiction stories about like how development's gonna work in the future and like, get your team to do this. Go like, go write a science fiction story about like what development's gonna be like in five years and go make that happen. Um, and that's where a lot of these ideas came from, you know, was people just dreaming and, uh, thinking about like where their pain is specifically and coming up with these novel ideas.
[00:19:44] Andrew Zigler: I think that's a fun way to reframe it. It's definitely how I go into building things these way these days. Like you go in with all this baggage and expectations about how an app is supposed to be built, how it's supposed to be delivered and onboarded, what the experience is like, and we do, we get to live in this, like you described it, like [00:20:00] a science fiction world where you can throw that away and you can rewrite
[00:20:03] Andrew Zigler: what it can be. None of us have the language or like the knowledge to know what these will, these kinds of tools and apps will evolve into. Everyone has their take on like what's gonna happen to apps when in the world of AI. Right? And so like in, in, in this world, like what you said is you're going out to solve a pain point, a problem like we become engineers because we want to have like a lot of impact.
[00:20:23] Andrew Zigler: We want to create technology that changes the world for the better. And I loved what you said earlier about. Uh, this quote that you say about building great software is an act of empathy. Like, I really relate with that. I think it speaks to the core of what we all do as engineers about using technology to address a problem
[00:20:41] Andrew Zigler: and, and helping other people. Putting, like putting yourself in other people's shoes is like really fundamental part of engineering, and I think that like AI, even in this case, can be a huge leverage that engineers can use to, to unlock that.
[00:20:55] James Everingham: Yeah, absolutely. I mean, that that is. Part, [00:21:00] one of the things we've always tried to do, or I've always tried to do in my companies and organizations is put the software between, you know, make sure my team is somehow using the software, even if it's not relevant to them. Figure out a way force them into the software.
[00:21:16] James Everingham: If they're not using it every day, it's just not going to get better as fast as if they were. So, like, uh, always find a way to get your developers, um, to feel the pain that your customers will have.
[00:21:29] Andrew Zigler: Yes and such, bringing them closer to the problems and getting them in the conversations. That's where you get really great philosophy on engineering. We cover that. We co, we talk that a lot on the show. We with engineering leaders who have, um, engineers who get sit really close to the problem and talk to customers.
[00:21:45] Andrew Zigler: I think that's fundamental, especially now to being able to deliver software value. Um, and just before we move on, I also just want to bookmark what you said, just point people's attention back to the idea of the user intent based testing method that you can [00:22:00] do now with AI where you can literally, you don't have to write necessarily the super strict unit tests.
[00:22:05] Andrew Zigler: You can have a more abstract layer of tests too, where you point it at your website or your API and you tell it to do something. Can it figure it out? And frankly, that's the kind of unit testing that I think more orgs should embrace because agents are becoming their primary consumers. So just something to really, um,
[00:22:22] Andrew Zigler: point towards. I think that's like, again, going to the science fiction world, that's a, that's a, that's something that you would never have optimized for a few years ago. That now is a major win that doesn't have a word for it yet. So, uh, that's the kind of challenges I think we're up against.
[00:22:36] James Everingham: Yeah, totally agree. It's like, it makes me think there's probably a whole business just to rewrite like Chaos Monkey out there, right? Like you can, you have persona based testing systems, like, you know, and uh, there's probably a whole opportunity just there.
[00:22:49] Andrew Zigler: Yeah. And in, in fact, speaking about like the, the chaos opportunities, I think like AI on the ground within a lot of engineering orgs, there's a lot of like business risks involved with like runaway [00:23:00] costs and security and IP and also just like fragmentation and. All of this, the huge risk of all of this stuff getting kind of siloed.
[00:23:08] Andrew Zigler: So like what does it look like from your perspective as a leader in this space? Like when you would talk with other folks and other engineering leaders about how they're kind of taming this within their, their org, like what do you see?
[00:23:18] James Everingham: So I think that's the, you know, the next big thing, the next big challenge. You know, this industry is evolving really fast and you know, one way to think about it is, is like if 2025 was the year of vibe coding, like 2026 is sort of the year of agents, right? And, uh, what this means is that we're seeing a lot of these reasoning models and different architectures that are now not just. Being part of an auto complete, they're becoming a fabric, of the company, right? So you need a control plane to, to be able to manage these. And what is a control plane? It's a piece of infrastructure that allows you to govern these things. You need to be able to understand what these agents are doing in your [00:24:00] infrastructure instead of just give them access to everything and let them yolo it. You know, that's probably not a great thing. I doubt your SOC 2 sign off person will be happy with that. So the ability to deploy these, roll them back, give them access to specific parts of your infrastructure to be able to log and see what they're doing to be able to like, understand the costs of what each of these are doing. This is the challenge that like, is that we think is coming up. This is what we're seeing. This is a problem that we're hoping to address with Guild. and uh, uh, that that's sort of what we believe is the next challenge here I firmly believe that, like right now, if you look at corporate infrastructure, not even just software development, you know, it, it all looks, you have servers, you have all these internal web applications. I think the future of that is gonna be have thousands, hundreds of thousands of agents, they're gonna be doing all types of really amazing things in your infrastructure. [00:25:00] You know, understanding, giving those things control and understanding that is the next big challenge for this stuff.
[00:25:05] Andrew Zigler: Yeah, I couldn't agree more. I see agents and like their impact on this kind of infrastructure, almost the same as like, it's almost like TCP/IP event all over again. It's like you genuinely are thinking about how can I pipe all of this intent and impact. Inputs and outputs and weave it all together.
[00:25:25] Andrew Zigler: It's a new way of thinking about how information moves within any system that we're all still like grepping around and exploring. Like the exact pain point you've described is like what pushes developers like me where I run, you know, dozens and lots of agents in parallel and do lots of things all at once.
[00:25:41] Andrew Zigler: Like I moved to a VPS. Because it just fundamentally doesn't scale on my own laptop. And why am I in a VPS? Because my org doesn't have the infra necessarily. It needs to meet me where it needs to. It needs to be, and I know a lot of engineers sing that pain and have built their own version of this VPS thing that I do [00:26:00] too.
[00:26:00] Andrew Zigler: And it's like you ultimately remove these barriers that let you move fast, but then you're running so far ahead that like your entire org can't keep up and you end up kind of building these in the middle pro, uh, solutions. And, and that goes back to the science fiction reality of it all. Like it's not actually that scary because you're running so fast that you're inventing the ground in front of you as you run, but it's still solid ground.
[00:26:23] Andrew Zigler: But ultimately, how can you, you can't build on that. That's where things like guild, I think come in and really offer this full suite solution because like if you're. Like a 10 x or a hundred x engineer and you're having a ton of output, like you want a way to distribute that output. You don't want to be the thousand X engineer in your team and the only one who's just like Houdini can just do anything with AI.
[00:26:46] Andrew Zigler: You wanna distribute it to everybody. And to do that, you need the platform. You need the infrastructure.
[00:26:52] James Everingham: And you wanna feel safe, right? Like traditionally you, you know, you, there's been this trade off between like moving fast and then [00:27:00] having things that are like secure, properly governed and everything. And we don't think that you should have to make that trade off. We think that you should have an environment, the future development environments are going to have the guardrails in necessary to protect engineers. You know, we're kind of a, a risk taking bunch, right? Like we just saw this with open claw, right? People. Yeah, I'll just give it access to everything. And suddenly there's like passwords and security keys and malware being installed. Like that's, that's bad enough on your personal laptop. But like as soon as one person does that at a, on a, on at the corporate level, on their infrastructure, that's pretty, that could be pretty damaging.
[00:27:40] James Everingham: So like, that's the thing to be concerned with. That's one of the things that like needs solidly addressed in the future here.
[00:27:48] Andrew Zigler: Yeah, so like it solves, one part of it is the context and just like the environment sharing kind of problem. Another part of it too is the auditing, the security, the awareness. [00:28:00] and, and as. When you kind of build this, it's, it makes me think of like when you made DevMate, it was kind of like an internal agent, almost like an app store kind of deal where people could go and like search around and find different solutions and fork them and change them.
[00:28:14] Andrew Zigler: Like, is that how ultimately this same kind of platform works within any other org that you're envisioning? Like, oh, people can come in and spin up and create these workflows that all live in this like shared internal like ecosystem.
[00:28:27] James Everingham: Yeah. If you are central, like if you sort of pull on the thread of a control plane, you have this centralized piece of infrastructure that's doing that. It's like, it's, um, it's providing access. It's, um, it's providing context in a way that makes sense on a per team or poor company level is providing credentials. It's providing session history. Uh, you know, you need to understand when something goes wrong. You need to quickly be able to go in and debug it. So you need all of that. And part of when it's centralized, the opportunity [00:29:00] is, is like your agents are centralized. So very much like you see a managed software center and an enterprise for what software, you know, you are allowed to install or not. We're gonna need that for agentic infrastructure, and like your security team's gonna want to go through and configure these things and say what they're allowed to do and help build the guardrails around these. And that's just not even gonna be optional. I do not see a world where that is not something that is needed.
[00:29:25] James Everingham: I can't even imagine that. Now the next big opportunity is like, okay, you have these agents, just like you have a managed software center, like maybe some of these could be public, right? And you go and not only can I learn internally what engineers are doing, but I can learn cross company. And this is sort of what happened with GitHub, right?
[00:29:46] James Everingham: Like you can now go and see public repository in guild and agents like a repository, and there are workspaces, and workspaces are run times and runtimes have access and there's a reasoning layer and an execution [00:30:00] layer. And there's execution controls. You know, like you need all of these things, but like we do, we do,
[00:30:06] James Everingham: we're big open source people. Like our roots are open source. My personal roots are open source. We saw the power in this all the way back when we did Mozilla, you know, at Netscape when we opened that up, you know what we put out there, was initial one was, was, wasn't that great, but having the community, uh, learn and make it better over time it sort of became the standard and led to even what are parts of Chrome, Firefox, all of that. We think that's missing, for the agent landscape and that's something we're hoping to provide.
[00:30:42] Andrew Zigler: Yeah, I mean, I, I definitely think it's missing in the agent landscape and that you're right, someone's gonna. Have to own it. I, and like it's gonna have to exist there. I I wanna pick your brain a little bit about the kind of, uh, what kind of person do you think, or the group of people do you think does own that?
[00:30:59] Andrew Zigler: Is it, [00:31:00] does it that fall with underneath the traditional kind of platform engineering domain that now expands to con include this AI control plane? Is it a fundamentally different team, maybe has a different interrelation? Uh, it's something to brainstorm because just as necessary as it'll be to have that kind of layer.
[00:31:16] Andrew Zigler: It'll also be necessary to have the org to support it. So what do you think that looks like?
[00:31:19] James Everingham: Do you mean who owns the control plane?
[00:31:22] Andrew Zigler: Yeah.
[00:31:23] James Everingham: Or well. Yeah, I think that like you're going to see a lot of these in the future, right? Like I think that there will be ones that are offered by specific vendors and then I think there are ones that will be offered, like companies like us that are vendor neutral, right?
[00:31:37] James Everingham: So, rather than phrasing it as who, who should own it, like I can say some of the trade offs of the people that maybe shouldn't own it, right? Like if you have a specific vendor owning it, like they're just by the sheer, uh, just by the, their business or what they're trying to do, it'll probably lock you in and limit you more to their [00:32:00] solutions. So if you're trying to build something. That is, um, picking up the best of all of the solutions out there. You may not want to be locked to, a single vendor. I mean, there are reasons you might, but like there are also reasons you might not. Um,
[00:32:15] Andrew Zigler: Mm-hmm.
[00:32:16] James Everingham: And I'm not sure if I'm answering your question. I may not have understood it, so please
[00:32:20] Andrew Zigler: Oh, may, Maybe I'll clarify by asking within an org, what's the type of role that you think owns that enablement, that platform? It's like I, I know I see a lot of orgs now with like AI platform
[00:32:32] James Everingham: Yeah.
[00:32:33] Andrew Zigler: leaders. Like is that who you think owns that kind of activity?
[00:32:36] James Everingham: Yeah, I mean, I think like, look, there's, there's probably more than one org that's gonna own that. So you have, you know, right now agents, when you're built, the way that engineers and, and teams are building even, uh, agents in infrastructure is what we call like single player mode, right? It's like
[00:32:53] Andrew Zigler: Hmm.
[00:32:53] James Everingham: have an a, you have an engineer who's firing up, like Claude Code has it running on there. Uh, their, their [00:33:00] server or even their laptop doing something. Um, but this stuff needs to be multiplayer. So like when you're, when you're, when you're moving to like this type of system, you might need your security team to be able to access and do it. You'll probably even need like your financial teams to go in and do audits.
[00:33:17] James Everingham: So you can see like your token spend. You have a bunch of different, um, entities in the company that are gonna need to access it in different ways. So I don't think there's like one single owner, like, you know, probably your core infrastructure, your IT team will like set it up and manage that, but you'll have a lot of people involved in this in order to make it work, especially at scale.
[00:33:41] Andrew Zigler: Yeah, and especially too as you explore it, like you called out a lot of primitives that are needed to make this system work. Like obviously the storage layer of them, the compute layer of them, the communication layer of them. And, um, it's about understanding which parts of those are, are most critical for your organization, and which of those maybe you're [00:34:00] trying to solve for first too, you know?
[00:34:02] Andrew Zigler: Maybe just to, just wrap things up to get to, so we, we've explained kind of the, the dream for this kind of platform that we need to build towards and get, and orgs should prioritize having, that way they can fully take advantage of their AI transformation. But what do you think is maybe the.
[00:34:20] Andrew Zigler: Most critical, like primitive Of the ones that you've called out, like maybe what should people focus on first to start getting immediate gains? Is there like a part of that orchestration platform where you're like, this is the first unlock that you would recommend to people?
[00:34:34] James Everingham: Well, yeah, I think that's
[00:34:36] Andrew Zigler: I.
[00:34:36] James Everingham: good question. Like I think, you know, if I go back to the DevMate ex experience, like there, there were some clear agents that were. That were, that would work across multiple organizations. So like, you know, what we're hoping to do is have some reference agents available as a clear starting point, like maybe an onboarding agent so you can go and say, wow, look, this is [00:35:00] awesome. This works well. I just click boom. Now it's. I've created an account and I've hooked it to my repo, and now I have an onboarding agent and I have a centralized place where, where engineers can go and look at it, add new ones, and start forking it or doing whatever they need. That's what we hope to provide. But I, I always think a place to, to start for any team is to find something that works and you're gonna have to look outside your company and,
[00:35:26] Andrew Zigler: Yeah.
[00:35:26] James Everingham: and uh, and use that as a model.
[00:35:29] Andrew Zigler: Absolutely. I think it's like in a, maybe a previous life, you know, we would go and hunt those like prompts and save them to our prompt library and we're all like starting on this like AI journey and you think about, oh, what are the workflows I can build to unlock my own kind of velocity? But now it's just challenging everyone and organization leaders, you know, listening to this, to to, to look and model at these kinds of, uh, workflows that are happening on a.
[00:35:53] Andrew Zigler: Org level within other places and being like, how can I capture that and model [00:36:00] that? Um, I think there's a lot that's like the next level of unlock that, that leaders can gain right now just by paying attention to like these kinds of systems. 'cause when you really crack the egg and like you look at it, they're a, a lot of them are very simple.
[00:36:13] Andrew Zigler: They're taking advantage of simple primitives.
[00:36:15] James Everingham: Yes. They, they are. And, and again, maybe this goes back and I'm just adding onto an earlier question, but a way to energize your teams to do this is, is by putting big challenges out there. You know, we, we tend to, you know, we, we see these same patterns over and over, and the analogy that I use is like, I feel like AI right now when people are trying to move faster with it. Is if they're a car company and they said, we want the car to go faster, and everyone just started polishing their part and making it more efficient and putting it back together and saying it's, oh, it's going a little bit faster. You need to completely rethink the car. And so the way that you do that in a business is not by saying, I want something incrementally better. You have to put [00:37:00] challenges out to your org that are crazy. You have to go order of magnitude, go to your team and say. We have to 10 x revenue in six months, or our CI/CD, like from land to production is six hours, get it to five minutes. You know, you gotta put these crazy challenges out and that is where like you get order, that's where you get order of magnitude.
[00:37:23] James Everingham: You get evolutionary, not revolutionary thinking in your org and it sort of forces the team to use these tools because they need to.
[00:37:31] Andrew Zigler: Yeah, I love that frame of thinking. It reminds me of something I read recently from Claire Vo, where she said, challenger org to rebuild your entire product from scratch in two weeks, and then if you can do it, reflect on what that means. Like it, you have to have these really difficult conversations and challenges.
[00:37:49] Andrew Zigler: Um, that really stood out to me. Um, the advice that you just gave of setting a really huge ambitious goal, I think is the kind of thing that gets people thinking creatively about the tools. [00:38:00] Um, really great framing and there's honestly so much that we can continue to unpack, so we'll just have to keep chatting for sure.
[00:38:06] Andrew Zigler: But for now, I'm gonna go ahead and say that, James, it's been such a pleasure to have you on the show and to pick your brain about how you think agentic engineering orgs are going to evolve in the things that they need. Um, but just before we wrap up today, where can our audience, go to learn more about your work and guild and, and what you're building.
[00:38:23] James Everingham: Yeah, absolutely. Well, you can go to guild.ai where. We're taking signups on our wait list right now. It, we are very close to starting to open that up to have people come in and, and, and start using it and giving us feedback and we're, we're, we're very excited to do that. And we can't wait to, to hear what you build and see what you build on this platform when we do release it.
[00:38:45] James Everingham: 'cause I
[00:38:45] Andrew Zigler: I am.
[00:38:45] James Everingham: be better than anything we thought internally.
[00:38:48] Andrew Zigler: Amazing. Well, we're gonna share links in the show notes, make sure folks know where to go to check out Guild and and, and see the latest there. And to those listening, if like you want a deeper dive into the leadership side of AI [00:39:00] transition, which is a lot of what we dug into today, be sure to join the conversation in our newsletters as,
[00:39:05] Andrew Zigler: well, we're distributed on Substack and LinkedIn. You can find easy ways to continue this conversation with us because James and I are both also on LinkedIn and would love to get your thoughts about what you heard today. And so thanks for tuning in to Dev Interrupted, and we'll see you next time. James, thanks again for joining us.
[00:39:21] James Everingham: you for having me. This has been so much fun. I appreciate it.
