Paul Stack helped build Terraform. Now he says he'll never write another line of infrastructure as code, because an agent harness runs his team's production infrastructure instead. Watch all the AI DevCon NYC 2026 talks: https://tessl.co/kpo Recorded live at AI DevCon NYC 2026, Guy Podjarny sits down with Paul, who spent years on Terraform at HashiCorp and on Pulumi before Swamp, to unpack why agents still trip over infrastructure state, what it takes to run a software factory that automates software delivery all the way to production, and why the people who know the system still make the calls. Then stay for Paul's full DevCon talk, From Page to Dossier, on a lights-out factory that does the 3am on-call legwork before anyone is woken up. What we cover: - Why agents still struggle with infrastructure as code, and why state is the hard part - Model problem or harness problem: what an agent harness for operations needs - Running an AI-first software factory from issue to production - Blast radius, deterministic workflows and keeping credentials away from agents - Why agents love toil, and why operators still own the judgment - Paul's AI DevCon talk: turning a 3am page into a ready-made dossier Chapters: 00:00:00 - Introduction 00:02:21 - From Terraform and Pulumi to Swamp 00:04:19 - How good are agents at infrastructure as code? 00:07:28 - Model problem or agent harness problem? 00:09:54 - Do we still need infrastructure as code? 00:12:53 - Inside an AI-first software factory 00:15:34 - Blast radius, determinism and agent credentials 00:18:48 - Agents love toil: the ops harness engineer 00:21:49 - Why software factories need ops 00:27:35 - AI DevCon talk: From Page to Dossier Book early for AI DevCon London 2027, 7-8 June at The Brewery, Moorgate: https://tessl.co/wzi 🔔 Subscribe for weekly episodes on AI-native development Would you trust an agent harness to run your production infrastructure, or does your team still want a human on every apply? Tell us in the comments.
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
SPEAKER_02For me, I'll never write another line of infrastructure as code. We use Swamp to manage our own infrastructure, and we've actually changed production infrastructure four times in the last six months. Agents don't care. They're like, your cloud is here, the new cloud is here, let's do the migration. We've gone from railway to DigitalOcean app platform, we've gone to DigitalOcean Kubernetes, and now we've actually gone to like uh GCP, and every time it's been like completely flawless and completely seamless. And that includes full data migration. It's kind of amazing to watch because a year ago we wouldn't have been in that situation.
SPEAKER_04The AI Native Dev is a podcast for developers and engineering leads at the cutting edge of AI and agentic coding. Join your hosts, Sky Pajani, and me, Simon Maple, every week as we chat with the most exciting voices in AI and tackle the biggest questions facing developers today. This is the AI Native Dev. AI DevCon is coming back to London. Our first London event sold out in June. After our second New York event this November, we're heading back to the brewery Moorgate in 2027 with a bigger lineup and two full days of talks from the people actually building with agents.
SPEAKER_04You'll hear honest takes on where the industry's at, real stories from teams adopting AI, the wins as well as the messy bits, and where they think things are heading next. It's on June 7th and 8th. And don't tell anyone, but we've got a really great deal for you. Scan this QR code to grab an early bird ticket for just£100. See you in London.
SPEAKER_01Hello everyone, welcome back to the AI Native Dev podcast. Today we're recording this actually at AIDEVCON, TESL's semi-annual conference on it. Super fun to doing it. There is a session going on in the background on it. So if you hear some clapping or cheering on it, that's just like normal occurrence here at AIDEVCO. And specifically over here, we'll do uh a short podcast with Paul Stack here from Swamp. We'll talk more in a sec, followed by his talk that will come up later in this conference on it. So, Paul, first of all, thanks for coming onto the podcast.
SPEAKER_02Thanks so much for having me. It's been a pleasure.
SPEAKER_01And uh so you you do a lot of things, but I think probably like a core competence is the whole world of uh infrastructure as code and the build-up. Uh, can you give us just a quick kind of background note on just a few of the highlights of your past on it? And importantly, what does Swamp do?
SPEAKER_02So my past is I I helped build a lot of what Terraform is today. I was very early doors in HashiCorp. I was there for quite a few years, left HashiCorp, went to Pulumi, worked on Pulumi for four years after that. I've spent like just an extraordinary amount of my career in infrastructure as code. To define infrastructure as well. Well, yeah.
SPEAKER_01You should automate some of that infrastructure creation.
SPEAKER_02And then I joined a company called System Initiative. Um, and System Initiative was trying to reimagine how infrastructure as code was. It was trying to use digital twins to be able to manage it, but it just never really hit that product semen with users who wanted it to be very declarative and they wanted it to be in Git. So earlier this year we created a new company called Swamp, and we sort of thought about how we would actually bring agents into like managing infrastructure, managing like systems as a first-class citizen rather than you know what unfortunately a lot of other people had to do, which was try and retrofit their code and their system to work with agents.
SPEAKER_01Yeah, yeah, interesting. Definitely a world over there on it. So we'll touch on it. Maybe let's do baby steps a little bit, but um, so there's a lot of work going on around sort of tickets to PR, right? How do you kind of go from whatever, like an intent or something into like a pull request and maybe even all the way to like auto-merging it? Uh and I think as more people uh advance down that path, there's now a more attention to the uh sort of PR to production, if you will, right? Like how do we actually get that and get that deployed? Because otherwise, you know, what have you done? Um and in that world, you know, we do use like infrastructure's code is useful because agents can generate that.
SPEAKER_01But there's been a lot of kind of complaints around how infrastructure's code, maybe unlike other types of code, the the amount of like a public uh kind of you know reservoir of examples of code and all that were not good, and that the models were not as good at it. So maybe let's start with something something simple, which is like today, like how how well do agents uh, how well are they able to produce infrastructure as code and kind of help guide you, just like they create the regular code on it, manage and sort of create that sort of deployment side of it?
SPEAKER_02So over the past six months specifically, they've got a lot better. They really have, okay, as the evolution of models has continued and has just got better across the board, for infrastructure as code, they have got a lot better. A lot of the pain that agents find with infrastructure as code is it's very opinionated code. It's very uh refactored in a way that suits like taste and and presentation of an individual developer, an individual team, and how modules sit on top of each other and how abstracted each module is, and it's modules upon modules upon modules upon modules, and it makes it actually a wee bit more difficult for you know for agents to be able to create that level of sophistication within your org.
SPEAKER_02If you asked an agent to produce base vanilla infrastructure as code, no problem. No problem, it'll do such a good job of it. But then, of course, we know that some of the pain with infrastructure as code comes when you try and have to refactor it, you know, and it's not because infrastructure as code is bad at it, it's because it's got a layer of state underneath it that becomes more difficult to move it around and be able to like, you know, change how it's represented. So as users bring in models to do it, they have to try and find ways for those models to interact with their existing systems.
SPEAKER_02And that's why they're they're not getting as good results as they've actually been like hoping for.
SPEAKER_01So it's super interesting to maybe dig a bit into that state, because I think on one hand, infrastructure as code indeed is a place where, you know, we're like often sort of seen like it's very sensitive as well. You know, there's like just every line has so much weight on it. Uh, there is uh like there's a lot in what is not present in the code. Like a lot of the choices are like you're leaning into the defaults, and so that requires maybe an understanding of that default. So it's interesting that I guess that kind of represents that state, right? Like maybe echoing back, you're saying, okay, like maybe the first sort of finicky, don't make small mistakes, is one piece of it, but then beyond that, ordering is important uh because it's managing state behind the scenes and um kind of understanding what the current state is.
SPEAKER_02And but but even from that, there's a lot of operations that like we we know how agents interact, right? They try, they find a pattern, they build upon that pattern again and again in order to like get us to the outcome that we care about. Sometimes infrastructure is code that's difficult, right? Because when they find a pattern and they apply it, something's out there. Something's like an actual resource. You can't sometimes you can't just change it. Right. You know, it's a it's the equivalent of like taking it down, recreating it, and there's like an entire feedback loop there that becomes really slow in that infrastructure as code loop.
SPEAKER_02So, you know, if we're hoping that an agent is gonna go from idea to like a an entire Terraform script or Pulumi script or whatever infrastructure is code script that you want, and you can apply that first run, you're gonna be probably a little mistaken that that's gonna be first time, you know what I mean?
SPEAKER_01Interesting. How much of that is is like a harness problem uh of just sort of I guess informing the agents uh at the right time? Because I I mean I suspect the reason that they got better uh over these last six months are part is just the reasoning capabilities of the model, and probably a part of it is just sort of the data feedback loop, right? Which is as more people started doing the work, then the labs and the models get better. But you know, how so how much of it is kind of a model problem versus a harness problem?
SPEAKER_02I mean hugely. Like the amount of the number of people I know who write like vanilla terraform or vanilla plume is like really low. Yeah. They're usually using a tool that sits on top that they can like scaffold it, that they can like interact with it, they can have their level of abstractions, which sort of outputs the terraform or outputs the infrastructure with code itself.
SPEAKER_01So of the same complexity, even for sort of humans, you know, that sort of like error prone nature of infrastructure as code.
SPEAKER_02So, you know, people are used to that level of abstraction, and then models coming in in the mix, it sort of like adds another level of, you know, you kind of have to take almost your entire harness, that harness that you created previously, and then recreate it as a new harness for models to be able to do it. And you can totally do it. Like, you know, Pulumi have done this really well with Pulumi Neo. They've done a fantastic job with Neo, and it's given really good results about it, but it was really based on, you know, if people were actually like using Pulumi itself and Pulumi Automation API to be able to do it.
SPEAKER_01And like the in in this context, the the job of the harness is primarily to convey state. It's to it's to say, look, this is my representation, maybe that sort of digital twin or like a flavor of that, a little bit of this is the state of my production. And so you have to assess whatever piece of code that you are conveying in uh to kind of inform the agent at the right time.
SPEAKER_02And that and that you know, plan apply loop is it it's slow for humans.
SPEAKER_01Yeah.
SPEAKER_02So the fact that it's slow for humans means it's even slower for agents than you know anything else. And and we're still in this era where people are not sure, do we give agents access? Do we not give agents access? Should they have access to run the terraform? And if they don't and they apply it, then you're gonna have to meet proxy. You know, that result back and forward. It's just it's just a combination of paper cuts that just make it more and more difficult to be able to do.
SPEAKER_01So maybe like getting a little bit more controversial, do we in do we even need infrastructure as code? I mean, I think so now you're you're kind of in this mode in which uh let's imagine you know you you have some form of map of your state. So I don't think you can get away uh from that, right? Like you need to kind of understand a little bit of what's deployed in production. But once you have that, I I think we we kind of created infrastructure as code iteratively because you know, people like because human labor was expensive, you know, this expensive and error prone. You'd sort of SSH into the machine and modify a bunch of resources and come back on it.
SPEAKER_01And but you know, now kind of human labor is not human labor, it's AI labor, is cheap. Uh and you can get fairly you know bright ones, and you can you can still create a harness that will sort of nudge them to say, no, no, no, this resource is sacred. What is the value that we get out of that sort of intermediate kind of representation of like infrastructure as code in Palumi or in Terraform or in whatever others?
SPEAKER_02Like for me, I wouldn't choose. Like for me, I'll never write another line of infrastructure as code. Okay, I like we use Swamp to manage our own infrastructure, and we've actually changed production infrastructure four times in the last six months. Okay? And I mean like live migrations, so fast, so easy, because of exactly what you said. You have a map of what your existing system is, and you then have an idea of what the intent of where the new map needs to be, and you can actually use an agent to go from A to B. And it's incredibly easy, it's incredibly straightforward.
SPEAKER_02It knows the outcome, it knows what it has to get to, it knows where it has to go, and it has all it is almost doing is translating A to B in order to get there. Now, to do that in infrastructure as code, to do a cut like an entire cloud provider migration in infrastructure as code is painful, it's really painful because there's many layers of abstraction in infrastructure as code, right? So you have the SDK of the cloud provider, which you have to know, then you have the Terraform equivalent or the Pulumi equivalent abstraction on top. Um, like we've referred to that in the past as the 200% problem, right?
SPEAKER_02You kind of need to know both layers to be able to interact with it. Agents don't care. Agents do not care about that. They're like, your cloud is here, the new cloud is here, let's do the migration. It's A to B, and it's it's done it really well live. And we've done this as we've grown and our system has grown, we've gone from railway. Railway to DigitalOcean app uh platform, we've gone to DigitalOcean um uh Kubernetes, and now we've actually gone to like uh GCP, and every time it's been like completely flawless and completely seamless, and that includes full data migration, like that's click house servers, that's you know, entire buckets, and it's just doing it, and it's it's it's kind of amazing to watch because a year ago we wouldn't have been in that situation.
SPEAKER_01So fascinating and and super interesting, and I can see because these are again, these they're sort of like human intelligence uh heavy uh exercises, right? You know, which you need to build those on it. What about the the kind of the systems operations? Like, okay, that is like for migrations that they're complicated, but then there's also the I just committed a new piece of code. Does it make sense for an agent to deploy that for me, or should that be uh like some whatever Terraform piece that would we are AI first, like we are literally AI first.
SPEAKER_02We don't do any manual configuration of any systems, any servers, anything. At this moment in time, when a pull request actually when an issue is picked up, our software factory goes the whole way through. And not only does it run the software factory, it runs the test factory, it runs a release factory, it runs the entire thing the whole way through to production. And that's our agents at different levels, different agent perspectives and personas actually doing the right pieces in the factory to be able to take care of it. So for us, it's like it it takes care of the deployments, it takes care of like the changes to the load balancers that's needed, it takes care of the deployments to like click house, it does the whole thing end-to-end.
SPEAKER_01So um I mean it it's interesting, but I think like you and I'm very much on board with having kind of an agent on the outside. Um but I guess still kind of my question stands when it comes to the to the inside, right? Because like agents can do a lot of things, but like software is still useful. Like you you don't want, I mean, some software should go away, right? And should just be an agent that delivers the software, like the code is is useless. Yeah. Um in this case, like is is the code actually useless? Like when you when you take that piece of code that you've just merged into your main branch and you need to deploy that, like replace the binary of it.
SPEAKER_01I I guess what would you use? Is it like literally the agent will sort of go off into the copy-paste, or is it like a uh or or or do you do you still use snippets of code and they're just like the agent is allowed to change them, but otherwise it is running a piece?
SPEAKER_02So we would use Swamp for this, and what Swamp allows us to do is to create like reusable behaviors, right? Behaviors are like uh pieces of intent that are encoded with they have schemas and they have like a workflow and they have like a you know a specific data structure that is like adding gates to the process. So when something goes into our factory, it is running Swamp behaviors the whole way along. Right. So Swamp is actually controlling with the agent to be able to do all of the pieces of the puzzle, including taking servers offline, putting them back online.
SPEAKER_02You know, it has the full access to do it the entire way through the pipeline. So for us, it's not that it's particularly code, it is an actual agent harness that is doing it the whole way.
SPEAKER_01Got it. Okay, so interesting, and indeed we didn't dig too much into swamp on it, and people should check it out and and try it. But those are indeed kind of defined behaviors and they're ingentic. Maybe let's talk a little bit about the blast radius aspect of it. So, like another reason that operations is sort of like ops teams are afraid of uh of uh agents is that the blast radius is big. You make a mistake, you might take the system down, drop the database, do whatever you want. Uh, and so they kind of refer to these sort of layers of infrastructure automations as layers of higher sensitivity, where they want kind of a human approver uh to say, like, I don't want any statistics over here.
SPEAKER_01You know, like I want uh I want an approval by a human, which I will say like is clearly uh at the best a short-term solution because you you like any any bottleneck, any human bottleneck will eventually go away. But so like how do you how do you think about that? Do you feel you know we have like with swamp or maybe with sort of other sort of like good scaffolding of the agent? You get sufficient determinism that people just need to get with the program, uh, or or is this more about the future, like okay, maybe today you should approve things because we're not quite there yet.
SPEAKER_01But um it's just just know that you're not future-proofing.
SPEAKER_02So that blast radius is incredibly important, right? Those guardrails, like those um real like systems that stop the agent going offline and like really having that deterministic behavior. It's like it's why we built what we built, because of the fact that we were and we seen other people just having that pain and that structure. So, like for us, it's very much encoding the exact workflow step, and the agent knows just to run that exact workflow step, and it doesn't have to think A to B in order, because it's probabilistic, right?
SPEAKER_02It doesn't have to think how can I go from here to like production. It goes, I just need to run this exact like script, this exact piece of code, this exact like um deployment of the API behavior, and it actually does it. The other interesting part with the operations world is people are worried about giving an agent credentials, right? We've seen CV Mageddon the last couple of weeks in October. It's been horrendous for so many people, and it's actually like made people worry even more, right? Because if you give an agent a key, then you know, whatever can happen.
SPEAKER_02So it's it's like about making sure that like your agents don't just have raw access, don't just have environment variables in the system, they need to have the encoded vault structures, like you know, all of that needs to be wrapped away. So an agent doesn't even need to understand what the keys are, it needs to know that when it runs an automation that the system itself is going to be able to pick up the keys inside the automation. And if you can wrap those pieces away together, then you'll start to find that you know things become a little easier and a little less blast-radisy, and like you'll be able to control it more.
SPEAKER_04Hey everyone, hope you're enjoying the episode so far. Our team is working really hard behind the scenes to bring you the best guests so we can have the most informative conversations about agentic development. Whether that's talking about the latest tools, the most efficient workflows, or defining best practices. But for whatever reason, many of you have yet to subscribe to the channel. If you're enjoying the podcast and want us to continue to bring you the very best content, please do us a favor and hit that subscribe button. It really does make a difference and lets us continue to improve the quality of our guests and build an even better product for you.
SPEAKER_04Alright, back to the episode.
SPEAKER_01So so interesting. So I guess kind of describing this and trying to kind of keep this from just being swamp, although clearly that should be sort of one of the solutions that assesses it. Uh, I think your point is when you're managing uh production right now, really what you should have is a system where it's sort of an agent on top. Uh and you do want that agent to be in a very well-managed harness. Uh, and that harness you know probably will use some pieces of code, maybe sometimes infrastructure's code, uh, and sometimes just whatever scripts or sort of you know program programmable code that we created that uh will will will basically apply determinism and contain access and such at different times.
SPEAKER_01Uh but I think what's important is that the agent is at is is sort of on the top because then it can it can kind of resolve problems, it can adjust, it can adapt, and it will have tools, and maybe, you know, in some cases you'll say, look, I'm commandeering judgment from you, like over here, and that's the harness's job. It's like over here you're gonna run this tool because I did not give you the keys to be able to apply this, so you really can't do anything else.
SPEAKER_02And like in the ops world, we have been riddled with toil for so many years. Just the mundane things that we hate doing, but it's the things that we have to do to keep our systems running. Agents are not bored by toil. Agents love toil, they will do those jobs again and again and again and again and again. And it is it's incredibly satisfying because when you tell it to do it and it does it again, it's amazing. So, as an ops person, now we can actually turn that to our advantage, right? We can exactly what you said, we can still maintain that control, but we can let the agent go and do all of the pieces for us, and we're the ones in control that say, yes, now is the time it goes into production, or this is what we have to do next.
SPEAKER_02And if we can continue to hold that control, we're the ones who know the system more than anyone else. You can tell an agent, you can give an agent access to the system, but it doesn't have all of the like the detail, it doesn't have the entire systems thinking that goes with it, or the understanding of the system. So you still need to have an operator who is able to take control and take it over at any point and go, you know, we have to make sure that this doesn't go off the rails. And that's like a really important thing.
SPEAKER_01Their job is to build basically the sort of these instructions to absolutely correct.
SPEAKER_02So it's like almost becomes a like ops harness engineering, and you know, like you hear like terms like harness engineering, you hear terms like agentic engineering and stuff like that, but it's real like ops system engineering in AI to be able to control that in a lot of people.
SPEAKER_01It's more about the choice of expertise that you are embedding into the harness.
SPEAKER_02And like I I've been saying for like forever now, it's like people are like, oh, you know, agents are gonna take our job away and they're gonna do that. I actually think quite the opposite. If you're like if you understand your system inside out, back to front, and you really like understand the pieces of it and the constraints of it, an agent is a force multiplier for what you can do, and you can actually achieve so more in your or so much more in your org.
SPEAKER_01Yeah, fully, fully agree with that. So maybe one last question here. Uh taking it into software factories. Uh so actually, like a lot of what you described is very aligned to TESL's sort of software factory approach, right? We have A Tesla JSON file that defines skills. It's always the agents at the top. So like this behavior or whatever that may be is always encoded as a skill. I say skill, but really I mean plugin. It has like some hooks and it has some tools in it. It's just skill is the sort of the term that's been out there. And so you take that, you define an environment, suddenly, you know, a skill plus an environment is an action.
SPEAKER_01You take an action, you add a trigger or a schedule or something like that. That's a type of trigger. You know, suddenly together you have a loop, you're sort of running a thing. And so it's very much, I guess we define our software factory in this sort of declarative way. And we sometimes refer to it, I don't know if we have at the moment like the ops credentials, the sort of really code design, but we refer to this as infrastructure as code for software factories and the definitions, contrasting it from uh what feels like sometimes software factories look like, which is the ops days of old, which is just a jumble of scripts uh that you might kind of cobble together and they will manage your system.
SPEAKER_01They're kind of doing similar things, you know, when you build it just naively with the uh with the agent. Like how how do you think about infrastructure as code uh for software factories? Like if you think about this, this is basically a new layer of ops, right? It's a new um uh a new type of system that you are deploying that is operating on it. I guess how do you think about the role of infrastructure as code for managing software factories to begin with, right?
SPEAKER_01Or or maybe it's not infrastructure as code, because we just talked about that. Uh I don't know what what is your term really for these behaviors.
SPEAKER_02Like we call them behaviors, yeah. So like for me, there's always been this disconnect between software teams and ops teams, and they kind of like keep a you know, separation of duties and how like these pieces like are far apart. In the world of agents now, the closer that these scripts, these infrastructure management scripts that come closer to the software, like it's gonna give a much better like understanding of what's happening. So embedding them as part of that flow, that factory, and like we hear the term software factory, and it's kind of like it's almost misleading because it's not just about software.
SPEAKER_02Um it's it's actually more about the encompassing software, it's not just the actual code itself, it's about how the code goes into production and how it runs in production, right? And so the closer like these two like systems come together and the more embedded they are, the more that that factory is actually you know fine-tuned to be able to do it because you don't have to have that handoff between teams that we've used to have for a long period of time. Yeah, because the feedback loop is so short. Like the agent should actually be able to understand how it can determine and how it can change the infrastructure's code or whatever it is that it's actually using to deploy and manage the infrastructure to be able to do it, rather than saying, right, I'm finished here now, here's an entire set of context that you need to pass on to the next team.
SPEAKER_02Because as soon as you start passing that context around as a layer that's not controlled, it becomes really difficult to maintain. And there's definitely going to be something lost in translation.
SPEAKER_01It's interesting, it's like it makes me smile a little bit thinking that uh you know, to achieve true DevOps and kind of mix the two teams, we needed to take the human out of the equation. To sort of get the agents to do actual dev and ops, and then you will actually have uh the two kind of parts, and frankly, much more of software development in the same case.
SPEAKER_02I blogged like maybe two months ago about how the teams that are most efficient with agents and delivering the best with agents at this time are the teams who are really far down their journey of continuous delivery. And exactly what you're saying with continuous delivery, right? Those teams who had to put those structures in place, those processes, those workflows, those ways of working, like for delivering their systems, you apply that same process now to like engineering an AI, and you just get such a smooth transition. So, exactly what you're saying.
SPEAKER_01Yeah, so I I guess that's uh that's a good point to maybe end a little bit the uh the um uh the podcast part of the uh conversation. And we're actually gonna go on to show your talk over here. So, can I ask you to just explain in a word, you know, what is it? It's called uh from uh from page to dossier, right? Uh tell us a little bit about what it is, you know, to entice people to stick around and listen to the next up.
SPEAKER_02So we have this idea of lights on, lights off factories, um, where you know an agent can be, you know, as part of it or a human can be part of it, what's happening. And like I've I've been, for a while now, I've been professing to people that you know having a human as the human touch and like understanding what's going on in the system, be able to make decisions is really important, but that you can actually put an agent in charge of doing the research. Ops people have been woken up at two o'clock in the morning forever. First thing they have to do when they wake up is they have to go and run this runbook, that run book, get this data, that data.
SPEAKER_02An agent can do all of that for us. It can present us with a dossier of exactly what's happening in the system, and then we as humans we can take over and we can understand where it is. So it's actually a sneak peek into how you would actually build a factory like that using smaller models. I've been using JEV as an example about how we can actually control.
SPEAKER_01These are just decisions, yeah.
SPEAKER_02Just decision engines, exactly, about how we can actually control is this a correct alert, is it not, how it routes through the system. So it's a it's just a different way to thinking about how ops can actually be empowered to actually build systems.
SPEAKER_01Yeah, got it. And I love the play on words from a page to a dossier. So love that on it. So definitely tune in for that. And with that, let's switch over to the talk.
SPEAKER_02Good morning. Everyone hear me? Beautiful. Um okay, so this is a one-hour talk that's gonna be condensed into 30 minutes. So this could go a number of different ways, but we'll get through a lot of different things here. Uh, this talk is called From Page to Dossier, and it's about using agents to your advantage when you're an operator. Any operators, systems admins, SREs, platform engineers? I'm sure we all dread this. Okay? It happens to me so often, I've been paged so many different times, and it's incredibly frustrating.
SPEAKER_02And when we wake up, we have to go through a checklist of things that happens in order to achieve, like, and figure out what's going on. So we like have to wake up, open your eyes. Like it's just it's just painful. You gotta look at your logs, you gotta try and determine what's going on, you gotta look at dependencies, maybe it's an upstream issue that you're having. It's just a set of paper cuts that just make things pain. Okay, that 30 that first 30 minutes of context gathering is incredibly important to help you make a decision that what you do next.
SPEAKER_02Okay. I'm sure operators, software engineers, people who have been on call before have been in the situation where you're trying to determine what the hell is going on, there's multiple pages happening, there's multiple pieces of information going on, and you try and figure out what is happening. Now it's not we we have to context gather really well, not because we're bad engineers, not because we're bad platform people, not because we're bad operations people, because at three o'clock in the morning or five in the morning, whenever you're paged out of hours, the last thing you're thinking of is what are the steps that you actually have to do.
SPEAKER_02What if that 30 minutes context gathering was actually two? What if it was zero? What if something had already done it for you? What we're in in this period of time in ops world when we have that level of checklist of do this, do this, do this, do this, and do this, this is called toil. Okay? It's manual, repetitive, no value, like that scales, you know, it's just as it's just a segment of pieces that we have to do to check the boxes to help us understand what's next.
SPEAKER_02Okay. One thing that's really important is an agent can do every single one of these steps. Okay. Agents love toil. Okay. Agents don't care if you ask them to do the same task 500 times in a row. If I ask one of my engineers to do the same task three times in a row, they will grumble and moan and like try and cut corners and they will make mistakes. Okay, it's not because they're bad engineers, it's we are not programmed in that way.
SPEAKER_02We are programmed to make things as fast and efficient as possible, and we will try and undercut the system to do that. I have worked in environments where there have been run books. Okay, it still makes me shudder a little bit to this day. And those run books are sets of guides that you have to follow. And I know that when those run books were written, they're immediately out of date because they're very rarely kept up to date. And I know that I can skip specific steps. I know I don't need to do step six because I'm not configuring that part of the system, and I can jump straight to step seven, and then I get to step 23, I'm like, ah shit, I meant to do step six.
SPEAKER_02So, you know, it's very much a case of agents can wrap this away. Um agents never push back on us to say, this is boring, I told you not to do it. Well, Claude sometimes does. Like Claude sometimes tells us that, like, and it also tells us that we're awesome, and it also, yeah, all those different things. But of course, it's that's just the fluff that comes with it. That's not the agent itself, that's just what what happens. Agent will do the boring part the same way every time. Okay, it is sh sure. How it actually does it internally is a probabilistic system, but if you tell it to do step, A, step, B, step, C, and step C, it will do step, A, step, B, step, C, and step C.
SPEAKER_02How it does each step could be slightly different just because of the nature of an LLM. We are very much in a case of um, you know, we can start to piece tools together to allow us to take away this toil. Okay, vendors are already shipping tools like this. Okay, Honeycomb have Canvas, Dash Zero are like an up-and-coming uh vendor in the monitoring space. They're not up and coming, they're like an incredibly established company. But like they're you know, they're they're spending a bunch of time rethinking how you can actually embed operations practices with AI in order to do it.
SPEAKER_02And you know, these vendors know their platform better than anyone else, and they will create incredible tools that will allow you to do this. You know, every piece of the run book, if you have a third-party vendor, they will give you the tools to do it, and you can create the process that brings it together. Now when you have a run book, when you have like deterministic steps that you have to go through in order to help determine what's happening, you can create a factory, okay?
SPEAKER_02Please excuse that I use the term factory, okay? One, I hate it. I absolutely hate it with a passion. Everything seems to have become a factory, and it's just a crap way to describe it. Okay, it's like, I mean, we're not in manufacturing. It is sure, it is a process of pushing inputs into a system, the system acts upon them, and you get things that come out the other side. If anybody else gives me a better term for it, I promise you I will change my slides because I hate the term factory. Okay, but at each level and each step in the factory, you can actually automate and you can bring it together.
SPEAKER_02Now, if you think about it, right? We talked about you need to talk to logs, you need to talk to upstream dependencies, you need to check your deployments, you need to check this system and that system to help you pick up a picture of what's actually happening when a page goes on. If you think about it, all of these tools are all there. Okay, so you have metrics tools, you have traces, you have logs, you have your deploy pipeline, you have your config changes, you have your upstream status pages, you have your chat history, your your run books. All of that information is available to you.
SPEAKER_02So what you can do is you can start to build a process that connects them and brings them together. There is terminology around factories, okay, where you have a lights out factory or a lights on factory. A lights on factory is a human is involved at multiple steps along the way and is helping the factory decide what it's doing next. As the human is keeping control of what's happening, and you largely, largely, not always, do this when there is work that you need human judgment and human taste for what you're actually doing.
SPEAKER_02Okay, but there is also the concept of a lights out factory where an agent will just rip through a set of systems and it will give you the output the other side. We created a lights out factory for our alerts. Okay? Now, please take this that I'm not telling you that you have to go and put together a lights out factory for your alert. You absolutely do not. You build the systems that work within your organization and your environment. We are just sharing a little experience of what we've actually built and the tooling that we've put together to allow people to be able to do it.
SPEAKER_02I'm gonna stop talking about the abstract here. I'm gonna actually show you the details of what is going on. Okay, so we start with alerts. An alert comes in from our system, it either comes from GCP, it comes from a tool called Axiom, which is another metrics tool, or it comes from our Grafana system. Okay, every alert is pushed as a webhook into our platform that we build and maintain. After that, we actually put that alert through a verification system. Okay, I don't want you attacking my verification system or my alerting system, so I verify that it is a correct alert with the correct HMAC signature that comes in that matches the parts of the system that we actually know.
SPEAKER_02When it is designed that it is okay, it continues. If the naughty people on the internet try and attack things, we will try. I'm not saying we will succeed, we will try our best and try and determine that it that is hooked off. When we go in, we then start to de-dupe things. Have we seen this alert before? We take a hash ID of what actually comes in, and if there are multiple alerts that come in of the same type, because we all get alert storms, 500 alerts fire for the same thing, and as you're working on it, PagerDuty or whatever tool you use is continuing to throw other alerts in the background.
SPEAKER_02So we actually dedupe it and we hash it at that point to help us understand. We then correlate it. Okay. Is this an alert that we've seen before? Is this something that has recently resolved we have to reopen it? Is there actually correlation by what is happening in the system that allows us to drive it forward from there? And if there are, we close things out. Right? There is like resolutions that we can say, this one is good, we can close it. This one is a jupe of what's happening, we can close it.
SPEAKER_02This one is related to another system that is currently being worked on, that is an open issue, we can close it. Notice what I say here. It is closed by code. It is not closed by an agent. An agent is never able to make a decision about when an alert should be closed. We have written deterministic systems that allow us to do that. Okay. I have not written a deterministic system to do it. I have instructed an agent to write a deterministic piece of code that can actually do it. Okay, it is a it is a piece of code that has logic, and that logic is attached to business rules within the org that allow us to do it.
SPEAKER_02From there, we go into a screen. Okay, is it actionable? Is it not actionable? You know, and like this is where you can start to mix in a little more. We use JEV. Anyone heard of JEV? It's a small language model, like the decision-based model. Um we got in the early beta in September, they gave me$5 credits. I heard the funny meme on the internet saying when I die, I'll be able to hand the rest of my JEV credits to my children. Like I cannot spend my JEV credits because it is such a cheap model to run and it's incredible.
SPEAKER_02We actually use JEV a lot, and I'll talk about it a little bit later about what it actually did for us. But that that initial understanding of it's actionable, dismissed, or recorded or whatever is so good in a decision tree like this. Then once it passes the JEV test, it goes into a real triage loop. Triage loop then is actually our deterministic workflow. Talk to the run books, talk to the upstream systems, check the logs, check the dependencies, all of these different things, and that is a workflow itself that runs and goes through an agent to do it.
SPEAKER_02And then we validate, we apply the triage of it, we actually check the actionable outcomes, we understand what's happening, and lastly, we get a ping. Okay, we ping in multiple places, we ping on Discord because we use Discord for everything, not Slack, because we're trying to be uh hipster and cool, trying to be done with like the gaming kids. And uh, secondly, we use like of course like pings like to people's phone. Now, the signal only reaches a person on call when it has traversed the entire tree. Okay, that does take approximately five minutes.
SPEAKER_02Okay, this is actually a real alert that fired at 2153 UTC on Halloween night. Okay, and it was a certificate renewal was overdue in our Grafana system, and immediately we could see the correlation and the cause and effect of exactly what happened. What's actually incredibly funny is that was that did ping somebody. Same alert, because we haven't fixed it, it's like if it was a small system, it doesn't really matter too much.
SPEAKER_02Same alert fired this morning. Okay, I checked on it specifically before my talk at 1148 UTC. Okay, um, that's like five hours ago, six hours ago, whatever it is. And we can actually see it says yes, it is the same two certificates. It's now 4.6 days past renewal, not 24 hours. The um the ingest basically says it's a duplicate. Claude basically says don't worry about it, attach it to the open incident, and then we basically say, no new incident, no new page, don't wake anybody up.
SPEAKER_02Okay, now that's fascinating because what it actually did was it created a very specific set of context that it passed back to the agent. By the way, all of these slides I will publish and you can have access to them, okay? So don't be worrying about trying to like read the like the minute details. Basically, it had all of the context that was needed to be able to do this. It had the category, the title, the summary, the rationale, the recommended actions, all of these different pieces. And what happens now is we've built this loop, we've built this deterministic system that allows us to be able to do this.
SPEAKER_02I showed you the top half of the factory, the lights out factory, but then there's also a bottom half of the factory. The bottom half of the factory is when something arrives in Discord, we as operators can query it. We can ask questions. And when we ask questions, that introduces new context into the system. It goes off, it queries, it prepares, it goes and does another round of analysis, and then it attaches the answers to what's happening. And we end up with a system that looks a little like this, where we have a trigger, where we have a concurrency model, where we have an ingestion engine, where we have a triage, and then we have apply triage.
SPEAKER_02So we've kind of like sat down and thought about what it is we do as operators and how we can actually change that into a system where we are the last people in the queue that we are then make the decision about how we remediate a problem. Don't let that LLM drive at 3 a.m., okay? Because you're gonna go approve, approve, approve, shit. That's what's gonna happen. Okay? But we only built the part that's ours, okay? When I say that, it's like every step in our system is actually a behavior, it is a model, it is a workflow that comes together to allow us to bring and stitch this behavior together using our own toolswamp.
SPEAKER_02Okay. Now you get a schema that looks like this, because it's type schemas, and you do things like this where you actually have like steps in the graph, looks very similar to a GitHub action. Okay, if you've ever seen a GitHub action. Okay, and then as I told you earlier, we use Jev. Now, Jev was a new addition into our pipeline. Okay, we were doing all of this initial triage with Claude. Okay, we're anthropic users, other models are available, but we are just an anthropic place where we try and just use Opus and like uh Sonnet for like what's happening.
SPEAKER_02When we swapped in to using Jev, we actually got 91% cost improvement in our system because one claude call is the same cost as approximately 1365 GEV calls. Okay, now that's kind of fascinating because now you can see why JEV is so fast, so small, so like cheap to run. But what it is, it was very much a case of the system became faster. We didn't need to use large frontier models to actually do um very simple basic classification of what happened.
SPEAKER_02We then deferred to using those large frontier models and intelligent models after like the classification understand that happened. And it was a massive reduction in our costs. And of course, we're in the era now where we can really control those costs and understand. But effectively, what it's doing under the hood is JEV's like running the equivalent of like a query. Okay, it's running the equivalent of a query, and then it's basically giving us a probability of is this something we need to do? Is this something that we've seen before?
unknownDo we
SPEAKER_02Close it. It's like a very simple yesno style like decision tree. But what we end up with is a decision, like a dossier that looks like this. Okay? And yes, we did call our bot Swamp Ops. But we end up with like a very structured level of information that comes back every single time in the same format. It has a title, it has an understanding of what's happened, it has the category, it has which signals that come in, which webhooks are actually attached to it, how many times it's actually fired, when it last updated, etc.
SPEAKER_02etc. But we build dashboards on the fly. Okay, dashboards for me are a thing of the past because we used to create dashboards and operations, and those dashboards would live forever, and you would have to maintain them, and they were just an absolute pain to maintain. Now we build them on the fly specifically about the data we're we're actually trying to report. But you see at the bottom we have a little ask button. You click the ask button, you get a little window that pops up, and as an operator, you can start to query and talk with the LLM, which will help you be able to do it rather than saying go to this system, go to that system, go to this, wherever, it does it centrally and it records that conversation as part of that incident.
SPEAKER_02The ask flow is kind of cool here. Um so basically, you go to an ask question. Do you have permission to do it? If you do, you ask the question, you then dispatch it, it starts doing some queries and some start-come code in. It actually goes off in a read-only mode to our our um ops system. It then prepares, like you know, all of the payload that it has to bring back in order to do it. It analyzes the output with the LLM and it gives us the answer for how we push it in through the system.
SPEAKER_02It's very, very cool. We're in charge of the decision at that point in time. This is an example, this is a real example of an investigation of when a human has asked a question on that same incident. And what they said is uh can you see why the last rotation failed? And we can see its findings, we can see its evidence, we can see its likely cause, and we can see the recommended next steps. Notice that the agent, again, the slides will be there so you can see it. Notice the agent hasn't said, I've gone and fixed it, it's asking me to make the decision for the next steps.
SPEAKER_02So if we go back to 3 a.m. and it happens, only signal pages you. No noise. No noise gets through, you don't want noise to get through because the more noise that we get through in a system, the less we pay attention to that. We get our alert and our dashboard and our links, we can query it, we can look for regular uh for correlation and incidents and occurrences, and like we can take actions, we can take actions based on what the agent actually gives us and helps us understand.
SPEAKER_02Why is it the same shape every time? One, it's not always the same person on call, not always the same person woken up. But if we understand and we give the information in the same way, the same structure, the same understanding, then it's very easy to read it and understand what's happening. So a sleepy engineer who's on autopilot knows exactly what information to look at, and it knows what to um the steps that it actually has to take next rather than trying to determine which system do we think this is from, which application could it be, is it a downstream dependency?
SPEAKER_02All of that is taken care of away from us. The agent never makes a call here. Never once does an I take that back. That's not true. An agent makes the call about if it's seen the incident before or if it's um an incident that is currently already um being investigated and it's a dupe coming in. That is the only time the agent will make a decision on our behalf about the findings and what we actually have to do. We as humans are the right people to make the decision. In 1979, an IBM training slide had the following words on it: a computer can never be held accountable, therefore, a computer must never make a management decision.
SPEAKER_02Okay, if we treat LLMs in this respect, we will get fantastic outputs. Okay, never, ever, ever, ever, ever defer your taste and your expertise to an LLM. Okay. Eric's talk this morning could not have been a better introduction to this topic. Okay, they are very, very, very good at what's happening, and he said, like, we are at the era now where we won't make money on code, but you can make money around products with code. And what happens there is that you bring taste, you bring expertise, and you bring domain knowledge into what's happening.
SPEAKER_02That same theory can be applied at any point of using LLMs across the sp the spectrum, and operations is an incredibly important aspect of that. Our agent never ever touches the controls. Okay, it's never gonna go silence or ping it up the chain, ignore it, let the next person, the agent picks it up because an agent doesn't care about toil. An agent will run that same step again and again and again, and it'll follow that same flow that you actually build and you that you understand.
SPEAKER_02What a human brings into the system is that judgment. Do we roll back now? Is it something else that we have to think about? Do I need to wake another engineer who knows this better? An LLM won't be able to give you any of that. Okay, spend the judgment in the areas that matter for you as an organization and you as a team rather than deferring that away and making the potentially wrong decision. I want to be very clear here. LLMs are not here to take our jobs.
SPEAKER_02They're absolutely not. I've been telling this for the last nine months to people. LLMs are there to be a force multiplier for what we actually want to be able to do and what we can do. But we as people who have systems knowledge, systems thinking, architecture, taste, all of these things work incredibly well with agents to give you really great outcomes. If you defer and you don't trust an agent output, that's totally fine. You know what I mean? Nobody's telling you you gotta burn away all your process and just throw everything to an agent.
SPEAKER_02You are still in full control of what can happen, and this is a great way of being able to do it. You can run this same playbook yourself, let an agent run it at the same time, and see how you can actually close you are. Muse? Like as in like a personal agent? Um I I I I I I have words. I I'm not a personal agents fan at this moment in time. Um I don't know why I'm not a personal agents fan at this moment in time.
SPEAKER_02I think it was probably because when I first looked at OpenClaw, it just looked such a pain in the ass to set up, and I've just skipped that whole personal agents thing, and I kinda just set up workflows that allow me to do it myself. But you're right, like Muse can handle a bunch of this stuff as well. Totally could. I I wouldn't trust my data with them, but that's okay. That's that's a your decision. That's a that's a your decision, people. And but what actually happens here is that because an LLM is actually helping us and going through the steps and understanding, you're able to gain understanding and review and sharpen what is going on at every moment in time.
SPEAKER_02This is genuinely how many times we've changed this flow in the last couple of like the last two months. Right? Every time we find something new, every time we have a learning out of an incident, all of that feedback is pushed back into the system to strengthen it, to make it better, so that the next time we actually can get better decisions, better understanding, and get a better outcome from what we have. How do you get started? I mean, if you if you're interested in this type of area with regards to agents and operations, first thing you gotta do is you gotta take out some of that institutional knowledge out of people's heads.
SPEAKER_02Okay, we all have people in our team who we go to when something happens, when shit hits the fan, we go and say, Hey, like, can you help me out? Can you show me this part of the system? We gotta start bringing those people out. I was actually talking to Ahmed um earlier um about how we do that. We do that specifically at our company because we interview people. Okay, when we're helping customers, we go and we sit with the customers, we interview them, we pull that data out of them, and then you're able to turn that into actually you know a reusable system that like that you can encode.
SPEAKER_02It's there, it's like available. And the more you do that, the more you pull that institutional knowledge out, the better that you actually get the outcomes of what's happening. You can then turn each step in that flow into a workflow, into a behavior that is encoded and it can run and it can run on its own. You can like fix that shape of the output that you want, you know, that makes it easy for people to understand what's happening. You can let the LLM read it, and then every time you do a post-mortem in your system, you would add a feel to the end of the post-mortem about how you can strengthen that system and make that system better.
SPEAKER_02Okay, you have to be able to feed it. For us now, a page at 3 a.m. kind of looks like this. We sometimes get paged. I mean, I think the number of times we've been paged in the last two months is maybe twice. You know what I mean? And yes, one of them was Halloween night, but you know, that sometimes happened. It's only a certificates issue. It was very it's it's not that it fully expired, it was classed as a P2, so it wasn't a drop, everything and fix it. So, you know, our judgment now is about spending on the problem, fixing this system strength in this system to make this better.
SPEAKER_02You are not being replaced in any way, shape, or form. You're kind of arriving with that first 30 minutes done, armed with a bunch of material, a bunch of um information that can help you make a decision. If you scan the QR code, you'll the slides will be on there in maybe 30 minutes, um, so you'll be able to see it. I I never know if people are comfortable asking questions or not, so I always prepare my own. I come armed with questions because every time I give this talk, people do have questions, and then I'm able to feed those questions back in.
SPEAKER_02Look, I'm even like taking my own advice of what's happening, okay? What happens if the agent gets the root cause wrong? The agent's not telling you what the root cause is, the agent is giving you hints and ideas of where it can be, areas where you can spend your time and focus to sharpen up the resolution and like what's happening, okay? It's evidence, it's not a conclusion. You, as people, are part of making that conclusion. Um, why not just use honeycomb like Canvas or Dash Zero or stuff like that?
SPEAKER_02Use them. Absolutely. If you have these tools, use them. It just so happens that our flow is a little different. It's not specifically a honeycomb-shaped problem or a dash-shaped problem. It is a system that brings together a bunch of you know different areas and telemetry and all these different areas to be able to do it. So we built the system that fits us. We are in the era of personalized software. As you quite rightly heard this morning in Eric's talk. We should be able to build the tools that work for our teams and our organizations and our workflows.
SPEAKER_02What about alert storms? Serialize them. Don't make the system take hundreds of issues at the same time if you're not able to cope with a hundred issues at the same time. That's up to you. Fingerprint them, dejup them, have correlation windows, have resolutions, all of these different things that make happen. What about prompt injection? Surely somebody's going to prompt injection you are. Yeah, they will. Ultimately, there's always somebody smarter, and they will get through. So, what we have to try and do is we have to try and decouple what the alert text and what the label is and mark them as untrusted data and not instructions for the LLM, and then our LLM output is actually goes through a very specific schema.
SPEAKER_02You have to think about building these systems, like you have to think about building software systems. CVEs, attack, surface, everything is getting incredibly, incredibly sophisticated. I mean, October was probably the worst month on record for CVEs. It's gonna get worse. It's gonna get worse. I just read before this talk that there's an uh Node.js vulnerability in the newest version of Node.js today. So there's gonna be patchmaged in this afternoon, okay, when that comes out like later today. It is literally every single day now, you're gonna have to deal with this.
SPEAKER_02So the best thing that you can do is get ahead of it and start to put the systems in that can help you actually put those uh pieces in place. Isn't this just giving an access, or excuse me, isn't giving an access, um an agent access to production dangerous? Absolutely it's dangerous. Don't ever give them rewrite access, please. Jesus no. Give them just read access, give them the minimal position, the minimal credentials that they need to be able to do the job that you need them to. Don't just share an API key to be able to do something.
SPEAKER_02You are setting yourself up for pain. Uh, won't all call engineers lose the skill of investigating? Nope. They will not. They still have to make the judgments, they still have to bring all the data together, they still have to do all this. What does it cost to run? It's really cheap, I told you. I can't spend Jeb credits. I mean, I wish I I don't wish I had more alerts, but I wish I could spend more JE credits because in two months I've spent 23 cents. Okay? Like, that's not a lot of credits. Um, you know, there's any uh anybody any other questions that I can add to my questions bank for next time?
SPEAKER_03So you said a couple times that LMs are not here to replace us, which is a great sentiment. UmAI is a charter. It says that they are trying to create automation for quote most economically valuable work. What do you think is doing all these big signals?
SPEAKER_02I mean, please take it with what I say with all of the respect to all of these people. They are a business. They're an incredibly profitable business, they're a marketing machine, they are going to continue to try and sell software for what's actually happening. Okay, they are not the only frontier model that you can use. You can use local models, you can use all sorts of, you know, there's a lot of uh sovereign models that are coming out of Europe to be able to help like move away from this.
SPEAKER_02You've got to take statements like that from big large companies with a pinch of salt, in my opinion. I've heard other frontier model companies saying code is solved, okay? There's no need for it anymore. Sure, taste is not solved. You know, like developer expertise is not solved. Like an LLM can't bring any of that judgment. It'll just continue building code on top of code, on top of code, and it'll do brilliant, and you'll have a tool that does every single thing in the world, everything.
SPEAKER_02But it might not be for you. So in my in my opinion, I think we are very, very, very, very far away from like code, like LLMs replacing all of us. I think unfortunately, there are companies who will like uh undergo like a lot of change because of restructuring of agents in the in the org, but I I still continue to believe that engineering will exist in X number of years' time because we are people who have a lot of thinking and a lot of expertise.
SPEAKER_02And once you couple that with an agent who can rip through like what you need to do in a short period of time, you can have incredible results off the back of it. I hope that answers your question.
SPEAKER_00Hello? Yeah, first of all, thanks for the talk. Uh I immediately took a couple of pictures of the slides and sent them to our DevOps team and our data team. Um I'm wondering like what's next? What gaps do you see that you're working on, or what workflow do you want to do a similar flow with next?
SPEAKER_02We're basically pulling like all of the pieces of the puzzle for our organization. We use everything of that we build our tool, builds our entire organization. Okay, we build our software with our tool, we build our um CI pipeline with our tool, we build our release pipeline with our tool, we build our ops pipeline with our tool, we build our CMRM pipeline for our tool. We're basically pulling at all the pieces and we're trying to like break the status quo of the old tools that we need to use. We broke away from using GitHub issues, and we did that specifically because not because GitHub issues were bad or that they're suffering an incredibly bad uptime.
SPEAKER_02That is a completely separate issue. It was much more about the fact that we were building, we build agentic software and we have a very like specific agentic flow, and inserting agents into a flow that was designed for humans was a wee bit more difficult than there. So I can talk to you more about some of the things that we do. So, folks, thank you so much. Enjoy the rest of your day. I really appreciate you coming out.
SPEAKER_01Hope you enjoyed Paul's talk. If you want to check out other excellent talks from DevCon, you can click the link in the show notes or scan the QR code. Uh we have some amazing talks in DevCon that will have concluded by the time you listen to this episode from the top labs, from thought leaders Lex Tiege, and others. Paul, thanks for coming here again on the podcast and to the AI Native Dev again, and I'll see you next time.
SPEAKER_04The AI Native Dev is brought to you by Tesla, the package manager for skills and context. Your hosts are Guy Pajani and me, Simon Maple. Our producer is Tom Dowler. The AI Native Dev is not just a podcast, it's a community. And we host monthly meetups at the Tesla offices in central London. Visit Tesla.io forward slash community to learn more, and I hope to see you there.
Developers are about to write skills instead of code, and Microsoft's Daniel Meppiel argues the software factory that runs them needs versioning, a bill of materials and signed receipts before enterprises will trust it....
Automated software delivery is moving faster than the people who used to approve every release. LaunchDarkly co-founder and CEO Edith Harbaugh tells Guy Podjarny why rollback should be autonomous, why one-shot coding...
Agentic coding has outgrown the text box. Maggie Appleton, staff research engineer at GitHub Next, argues that walls of CLI output and AGENTS.md files serve coding agents far better than the humans steering them. She...
AI attackers now move at machine speed, while most security teams still move at meeting speed. Former Robinhood CSO Caleb Sima has seen an AI attacker up close, and he argues the only way to keep up is to take humans...
Your coding agent should never hold a credential, and in a software factory that rule is only the start. Recorded live at the AI Security Summit in San Francisco, Simon Maple sits down with Eli Aleyner (Docker), Marcelo...