AI agents now write and run their own code, and nobody has time to review it. When that code runs near your data and systems, one bad script can reach things it was never meant to reach. The missing piece is a security boundary that limits what agent-generated code can access and do.
In this interview on TFiR, Matt Butcher, VP Product Management at Akamai, breaks down how WebAssembly’s hardened sandbox contains agent-generated code, what Akamai Functions reaching general availability changes, and why latency and open source matter for AI agents.
Guest: Matt Butcher, VP Product Management at Akamai
Show: The Agentic Enterprise
LinkedIn: Matt Butcher
Watch the discussion on YouTube
Here is what every platform engineer and security team running AI agents needs to know.
Technical Deep Dive
Q: How do you sandbox AI agents that write and run their own code?
Matt Butcher, VP Product Management at Akamai, says models pursue a task relentlessly and sometimes use creative tricks that amount to hacking. A developer can do little about the model, so the control point is the environment the agent runs in. WebAssembly’s hardened sandbox fits because it was built for the browser, which makes it a runtime designed to distrust the code it runs. Butcher explains that the sandbox refuses the URLs an agent tries to access unless a human in the loop approves them, and Akamai Agent Sandbox is a thin wrapper that runs an agent inside Akamai Functions to use that security layer.
“…agents are generating code that we don’t often have time to review… when you can put it in a sandbox like that, the sandbox is already saying, okay, I’m not gonna totally trust this.” Matt Butcher, VP Product Management, Akamai
Q: Should I use containers, micro VMs or WebAssembly to run AI agents securely?
Butcher describes an agent as one more application pattern after microservices and cloud native. It is a loop where the model reasons about a prompt, acts through tools such as REST calls or running a program, then pauses for human input before looping again. Runtimes are diversifying, with OpenShell, containers, micro VMs and WebAssembly all used to run agents securely. For agents that customers interact with, Butcher wants scale, a secure perimeter, and an agent that cannot go off the rails or coordinate with services it should not talk to.
“I’m not sure we’re ever gonna get to that point where we only have one style for running an agent or one particular agent platform.” Matt Butcher, VP Product Management, Akamai
Q: Why is latency the biggest problem for AI workloads, and how does edge computing help?
Butcher says people expect AI to respond at the cadence of human conversation, and a 3-second pause before a voice assistant answers breaks that unspoken contract. Smaller, better-tuned models and bigger hardware help, but so does proximity on the network. Distributing processing close to users avoids piping every query to one distant data center and spreads load across GPUs in different regions, so each GPU processes requests faster and results travel a shorter distance.
“So latency once again becomes the number one problem that we need to solve.” Matt Butcher, VP Product Management, Akamai
Q: How is Akamai Functions built on Spin, and what changed after Fermyon joined Akamai?
Fermyon built an open source core, the Spin developer framework, and contributed it to CNCF. SpinKube runs Spin applications in Kubernetes, and Akamai Functions runs the Spin runtime as a hosted, managed service. At Akamai, Butcher says the service scales across a distributed network with compute in about 4,300 locations, deployed into regions worldwide, and serves billions or even trillions of requests per month on some endpoints. The audience also shifted from the developer alone to the developer and their coding assistant, with capabilities expressed as skills and tools so a coding agent can pick a database, build a function, or convert a containerized application.
“…it’s not the developer, it’s the developer and their coding assistant.” Matt Butcher, VP Product Management, Akamai
Q: What does general availability of Akamai Functions unlock for developers?
After the acquisition, Butcher says Functions grew from one region to a couple and then to 40 regions, with plans to expand by hundreds, so one deployment spreads worldwide and can absorb spikes such as a livestream sports event. The work leading to general availability focused on getting developers started quickly in the Akamai ecosystem, such as tying Functions to Linode object storage with Akamai DDoS and firewall for AI in front. That opens edge computing and AI at the edge to large Akamai customers whose business has been the CDN.
“You deploy once and it’s just spread out all around the world instantly.” Matt Butcher, VP Product Management, Akamai
Q: What is the open source story behind Agent Sandbox?
Because Spin was already a strong environment for running code you do not trust, Butcher says the team built Agent Sandbox so developers get a hardened environment while building agents. They then decided to open source all of it, with no trade secret to protect. Contributors at the conference have already suggested changes and offered pull requests, which gives Akamai engaged builders instead of a backlog of wishes. Butcher says the team also continues to release new versions of Spin and SpinKube.
“…open sourcing something isn’t necessarily just an act of goodwill to the community, but also a chance for us to get people engaged in building the better thing.” Matt Butcher, VP Product Management, Akamai
Q: Will AI kill open source or revitalize it?
Butcher says a year ago he would have predicted AI could end open source because anyone can write their own code. Now agents can read a codebase and help people contribute, which lowers the biggest hurdle, and he expects a revitalization. The early window of low-quality AI-generated pull requests and security reports is easing as models improve, and he says maintainers need to get comfortable using AI to triage and assess contributions.
“The learning curve to contribute to a new open source project used to be the biggest hurdle for somebody to clear.” Matt Butcher, VP Product Management, Akamai
Q: Why did Fermyon’s path lead to enterprise AI workloads?
Butcher says Fermyon tried hosted model inferencing in 2022 on rented NVIDIA H100s. Developers liked it, but it was too early to run anything notable in production, and inexpensive high-powered GPUs have since become scarce. With Akamai’s hardware capacity and large provider deals, the team can target large enterprise use cases. Had they stayed a startup, he says, the focus would have been smaller companies that care about efficiency and token management.
“In some ways it feels like there’s a fork in the road and we took a fork that was definitely headed us more toward enterprise workloads, enterprise applications.” Matt Butcher, VP Product Management, Akamai
Q: What happened to Fermyon after Akamai acquired it?
Butcher, who was CEO of Fermyon, became VP of product at Akamai, where he runs the whole edge compute portfolio, and the Fermyon and functions teams joined him. The Fermyon product is now Akamai Functions, the Akamai version of Fermyon Wasm Functions, which was announced as generally available the day before the conversation. Butcher says it already has many big customers, and the latest release focused on streamlining the experience.
“The product we were building at Fermyon is now Akamai Functions, which is part of the core offerings that Akamai has.” Matt Butcher, VP Product Management, Akamai
Resources & Documentation
- Akamai Functions, a managed platform for running WebAssembly functions on Akamai’s distributed network
- Akamai Agent Sandbox, a wrapper that runs an agent inside Akamai Functions to use its hardened sandbox
- Spin, the open source developer framework for building WebAssembly applications, contributed to CNCF
- SpinKube, tooling for running Spin applications in Kubernetes
***
👇 Click to Read Full Raw Transcript
Swapnil Bhartiya: As we all know that teams now let AI agents write and run their own code. An agent can clean up CSV or write a function for a new API, which of course saves a lot of time, but it’s code nobody reviewed from a source that nobody trusts. And when it runs near your data and system, one bad script can reach things it was never meant to reach. So what’s missing is a safe boundary with limits on what that code can reach and do. Running it safely is becoming a big problem and enterprises want solution. Akamai has been working on this with Akamai Functions and Agent Sandbox. And today we have with us once again Matt Butcher, now VP of Product Management at Akamai, to talk about, of course, Functions going general availability. First of all, Matt, it’s great to have you back on the show.
Matt Butcher: Oh yeah, it’s fantastic to be back again and in a kind of new phase of life for me. Right.
Swapnil Bhartiya: In both ways, right? With your beard is back.
Matt Butcher: The beard is back, yeah.
Swapnil Bhartiya: And of course, the new kind of stage in your journey, in your career. Of course, the whole acquisition happened. And when you were doing too many sessions with Akamai, I had that feeling. I didn’t want to talk about it. So I want to talk about your life at Akamai. How is Akamai treating you or how are you treating Akamai?
Matt Butcher: So let’s see, we talked— last time we talked, I was the CEO of Fermyon. Shortly after that, Akamai acquired Fermyon and I went into a role of a VP product. I run the whole edge compute portfolio. The whole functions team, the whole Fermyon team came over and joined Akamai with me. It’s been like, it’s been fantastic. The product we were building at Fermyon is now Akamai Functions, which is part of the core offerings that Akamai has. It’s been a really good transition for us and we’re coming up on, One year, and yesterday we announced that Akamai Functions, which is the new Akamai version of Fermyon Wasm Functions, now GA stable and out on the market. We’ve got tons of big customers out there, and this last release was very focused on streamlining things for folks. I know we’ll get into that a little bit coming up, but it’s been quite a ride and a very happy one for me.
Swapnil Bhartiya: It’s great to hear. And of course, Akamai is a great place either way, the company, The way they’re showing up on all these conferences is also great. That’s good. Now let’s get into the weeds of some of the things that we want to talk about today. One is, of course, the reality is that agents are no longer just chatbots. They are now writing codes, they’re running their own code, making decisions. And the fact is that that can make a lot of people nervous. Yes. Of course, you can talk about human-in-the-loop, but by that time, things can go wrong. So from where you sit, What problem do you feel are there? And then how, whether we look at sandboxing function, is it solving for them?
Matt Butcher: Yeah, I mean, as we all know now, we’re now getting used to having AI just as a part of our kind of problem-solving, software-building processes. I know you do that, I do that. And it’s fantastically powerful because it’s effectively trained on all the software that has been developed and the sources available and all the patterns that we use. And that’s great. Great, but we’ve built a system that is designed to be sort of like the kind of reasoning an LLM uses, the kind of reasoning a model uses, sort of what we would call like pragmatic reasoning, right? We tell it to get a job done and it goes and relentlessly pursues getting that job done, but it’s not necessarily, you know, adept at figuring out how it should do that and how it would fit into social norms. Or in other words, you know, sometimes it uses creative things that we would call hacking or something like that in order to solve the problem. Right. Right? And that’s what we don’t want it to do, right? So we wanna, on one hand, the model does what the model does, and there’s not a lot that I as an individual can do. I know Anthropic, OpenAI, they’re all working on that. But on the other hand, there’s the environment in which I run the agent that I can control. Mm-hmm. And, you know, we talked going back years now about Functions, and it’s built on WebAssembly, which is this great performance technology, this great multi-language technology. But one of the things that WebAssembly brings that ends up being a perfect fit for agents is that the sandbox environment that WebAssembly runs is very much hardened. And so in fact, it is really the only runtime that was built with the assumption that you can’t trust the code you’re running. Like all along we have said, oh, well, we’re writing the code, we’re writing the runtimes. Yeah, we can trust these. WebAssembly was built for the browser. The browser’s kind of the Wild West. We definitely have said, you know, we don’t wanna trust the code that’s running in there. Well, that works out Perfectly for agents because agents are generating code that we don’t often have time to review, can’t go into the nuances. But when you can put it in a sandbox like that, the sandbox is already saying, okay, I’m not gonna totally trust this. The agent’s trying to access these URLs. I’m not gonna allow them to do that unless you as the human in the loop say, yeah, it should be able to access this. And so that kind of hardened sandbox environment, that kind of hardened environment is what we call a sandbox right now, right? Yeah. And it just so happens that we had sort of accidentally built it at Fermyon, you know, using this WebAssembly technology. And now as we’ve kind of rolled this forward into Akamai Functions, tends to just be a virtue of the runtime. So when we announced Akamai Agent Sandboxes a couple of weeks ago, all that really is is a nice little wrapper to run your agent inside of Akamai Functions that takes advantage of that security layer that’s been there since day one for us.
Swapnil Bhartiya: What other projects, because this is a very big problem, very serious problem, uh, like OpenShell and the other projects that are happening. What are you seeing is happening in the ecosystem? And where, I mean, you have been part of the ecosystem for so long, where you see that they can also learn from each other? Because the idea is to solve the larger problem for the community. And second thing is that, as they were saying in the Jurassic Park, The life always finds a way. I feel the agents always find a way.
Matt Butcher: They do.
Swapnil Bhartiya: Yeah. So how do you also ensure that, you know, when we do talk about, you know, the sandbox?
Matt Butcher: Yeah.
Swapnil Bhartiya: Because it predates the whole agentic AI era, you know. So do you still feel some gaps that need to be filled to be ready for, or do you have filled those gaps and that became the Akamai Functions?
Matt Butcher: Yeah, yeah. So let’s— so starting at the beginning of your question, right? The term agent, Is a big term, right? But really, all it’s describing is an application development pattern. And we’ve talked—we’ve had all kinds of development patterns: microservices, cloud native, you know, And this is just one more kind of pattern. And the characteristic of this pattern is it kind of runs in this little loop thing where I give it a prompt and it uses its model to start interpreting the prompt and figuring out what to do to solve the problem. At some point, it goes from that sort of Reasoning phase into an action phase where it’s looking at the tools it has available and it’s starting to interact with them, maybe make some REST calls to something else or load a program and execute it on my behalf. So it goes from sort of reasoning into acting. And then at some point it says, okay, I think I hit a stopping point. Either the agent thinks it’s solved your problem. Mm-hmm. or the agent gets to a point where it says, I need some human input before I can keep going. So it goes into this kind of third phase of the loop and stores everything it’s done so far and says, Hey, look what I built for you. Is this the right thing? And you say, well, you know, I’d really rather that was, you know, blue, not pink, or I really need this button here that does this. And then it kicks off that kind of reasoning loop again. So that’s all an agent is. It’s just sort of something that follows that particular pattern. Now what’s really exciting is we’re seeing all these different ways that people are implementing agent runtimes, agent environments, right? We know everything from OpenCLAW to, you know, Claude Duo and all of these kinds of interesting patterns emerging. Right. And I’m not sure we’re ever gonna get to that point where we only have one style for running an agent or one particular agent platform. And that’s where like you see OpenShell coming in as a way to run sort of securely. And you’re seeing container, ways to do this with containers, way to do this with micro VMs. And for us, it’s ways to do this with WebAssembly. And again, the thing we like about WebAssembly is if you’re building the kind of agent that you wanna put out on the frontline, Right, where I am building something that my customers are gonna come and interact with. Not me, it’s not an internal thing that I’m gonna use, but for my customers. That’s when you start caring a lot about, okay, I wanna make sure that this scales really well. I wanna make sure that we’ve got kind of a secure perimeter around it, which is what Akamai is great at providing in our kind of core tools. But also that’s where I care about making sure that as the agent is reasoning and doing that problem solving you were talking about, It kind of can’t go off the rails, right? And it can’t just kind of go off and start doing its own thing and coordinating with other services we don’t necessarily want it communicating with. And particularly for Akamai’s customers, they’re starting to look at, you know, can I as a, you know, e-commerce platform or I as a media streaming provider create an agent that I can put out there and let other humans interact with it, but also other agents interact with it? Right. And I can be sort of the source of truth on whatever that particular vendor wants to be able to sell or provide or whatnot. And that’s where I think we’re gonna see this kind of big diversity of agents happening, where not only do we have different runtimes, but we have agents that are doing different things on behalf of different people, but can start sort of collaboratively solving these problems. Not where I’m running 9 agents myself, but where I run one that contacts your agent and contacts the Akamai agent. That’s, I think, the kind of future we’re seeing unfold very rapidly in front of us. So with the— that’s where we’re going. This KubeCon has been fun because we’ve seen it sort of unfolding in real time in front of us as different people talk about how they’re solving particular problems. So it feels here like sort of like this revitalization of a conversation about how do we actually build real production tools using these kinds of technologies or providing these kinds of technologies.
Swapnil Bhartiya: Initially, I mean, we started talking about your own journey, how You know, Fermyon came. I want to talk about, just dig a bit into the Akamai Functions, of course built on Spin, you know, as we talked about, not Fermyon as a company, but what has been the transition for the technology from, you know, Fermyon to Akamai?
Matt Butcher: The big thing that we decided early in Fermion’s history is that we were going to build a really fantastic open source core. And we focused, you know, on building a great developer experience so developers could very easily build applications. We created that in a tool called Spin. Then we contributed Spin into CNCF and it continues its sort of open source core. Today we, you know, we announced Spin Sandbox. We’ve got SpinKube for running Spin applications in Kubernetes. You know, all kinds of open source easy to modify, community-oriented tooling. Now, when we were at Fermion, we were building a cloud for hosting and running these kinds of applications. It was basically like we took the Spin runtime and we said, here’s how we’ll run it at a larger scale, you know, in a hosted managed environment. So you don’t have to set anything up and do anything. And in the transition to Akamai, both sides of this has changed a little bit. So what Akamai does best, we’ve got the world’s most distributed network and we’ve got compute power spread out across like 4,300 locations around the world. Now, not all of those can run something as big as functions, as big as Akamai Functions, but we’re certainly deploying that into regions all around the world and then being able to scale that thing we built at Fermyon, not to, you know, hundreds of users or thousands of users or tens of thousands, but to be able to run at this kind of massive global scale where we’re talking about billions and billions or even trillions of requests coming in per month to some of these endpoints. And that has been just a fantastic journey on the server side. But what changed on the developer experience side has been, you know, we were building a tool that was designed to help that developer go from blinking cursor to deployed application in 2 minutes or less. You’ve heard me say this so many times over the years. And now it’s like, no, no, it’s not the developer, it’s the developer and their coding assistant. And the audience has changed. And the way that you express your capabilities to an agent is different than the way we would sort of bootstrap an end user. I mean, similarly, we use text and we use sentences to describe it, but differently, we kind of encapsulate it in skills and in tools for the LLM to be able to make use of right away. And that’s introduced a really fun challenge that we’re solving right now as far as like suddenly you can have your coding agents say, hey, I can tell you which database is gonna be the best backend for this, and I can build this function for you. I can take your existing application and convert it over so that it’s a function instead of a containerized thing. And this has just become incredibly, like, profoundly efficiency, efficient, efficient. That’s the word. And it’s really exciting to see both the developer side of the equation change and lean into making it possible for casual builders to build enterprise-grade applications and then deploy them into, you know, Akamai Functions on the world’s largest, most distributed network. It’s been a fantastic kind of way to kind of hit 2 sides of that scale in ways that at Fermyon, as a small company with a small resource pool, we certainly would not have been able to accomplish. But then at Akamai, not only have we been able to accomplish it, but Akamai’s customers just love being able to do this kind of thing. It solves big problems for them and often at a good cost savings.
Swapnil Bhartiya: You actually almost answered my follow-up question, which was going to be, when we talked last time, you know, when you were still at Fermyon, we were not even talking about AI agents, you know? Yeah. It’s only been MCP and all the things. The things are moving so fast in this space, it’s very, very hard to catch up. I am seeing a lot of companies, like, they’re labeling everything as AI ready. And, you know, you can see that, you know, AI washing versus how the technology— Do you feel that if you were not part of Akamai, you know, how would you have seen the trajectory of, uh, Fermyon and all the things where you’re seeing, you know what, sometimes things happen for the right reasons? Yeah. Because this is where you would have either way, just the way everybody else, but the way the journey took shape is you’re like, this is much more like the path you would have taken or want to take. But as you mentioned, resource share and everything else. So you’re like, this is something that I would have envisioned either way. And it has happened.
Matt Butcher: We made a kind of early foray into hosted model inferencing at Fermion back in 2022, which was way too early, right? And we built this out and rented a couple of H100s, NVIDIA H100s, and had built this inferencing backend. Our users really liked it. Our individual developers really liked it. But there was no way back in 2022 to go from this cool, fun thing that could help me solve crossword puzzles to anything that was running in production on anything notable, right? And then, you know, fast forward only a couple of years and AI tooling has just, you know, sort of permeated through every little aspect of our industry. But the core pieces that we kind of took for granted at that time, being able to get, you know, high-powered GPU for relatively inexpensive— oh, that’s— those days are gone. And I, in a lot of these cases, Yeah. Fermion was oriented around value prop for customers. We were building a fast runtime that was very cheap to operate but could scale very fast. It would be hard to be— to have the Fermion budget and still try to be able to provide the kinds of GPU experience we were shooting for. and the kind of inferencing experience we were shooting for. I admire what I— the scrappiness I see in a lot of my peers who are still doing startups and going, well, you know, everybody’s going to realize pretty soon that this is really expensive and they’re going to have to figure out how to do cost control. So if we build it as a discipline into our startups, then we’re going to be able to offer this as value going on. And I think that’s— when I hear them talk that way, I think that is— that’s what I would like to believe I would’ve done had we stayed in the startup world. But also what I’m glad that having this sort of hardware capacity and the big deals with large providers that Akamai has means that we can really target toward the enterprise use cases, the large enterprise use cases that we’re seeing emerge. So in some ways it feels like there’s a fork in the road and we took a fork that was definitely headed us more toward enterprise workloads, enterprise applications. If we had gone the other way, I think we would be talking about how do we build for smaller companies who really care about efficiency and how do we bring that kind of discipline as far as token management and things like that to that particular class of customers. So it’s fun to kind of look back and say, well, it could have happened that way. Also, I’m a little bit relieved that we ended up on the one that just has led us on this kind of incredible growth trajectory and an incredible path to success.
Swapnil Bhartiya: And now of course, Akamai Functions are like generally available GA. So what has this availability unlocked for those developers who were till now just waiting on the sidelines?
Matt Butcher: You know, the big difference, there’s a lot that’s the same, right? We built Fermyon Cloud. It was a place that managed your entire runtime environment so you could just deploy an application and it would just be running. And, you know, day-2 ops was very simple. All of that translated directly into the new Akamai Functions platform. But what we’ve realized, again, Is that, you know, when you’re talking that kind of global scale that quickly, the first problems we solved were all the scaling problems. How do we run functions everywhere in the world? You know, we went from a couple of, we went from one region to a couple of regions and now we’re in, now post-acquisition, into 40 regions and we’re looking at expanding that by hundreds, right? So you deploy once and it’s just spread out all around the world instantly. But that means when you have huge loads of traffic, a big, You know, livestream sports event comes online and suddenly all of those are lit up. It’s a different scale of problem to solve. And that has been a fun one that definitely, again, in that fork in the road kind of thing, the Akamai fork led to scaling, global distribution and all of that taking off very, very rapidly. No way a startup could have afforded to do that, right? But with Akamai, it just became table stakes. So we did that between like January, the acquisition, and March. Yeah. And then this last half till we went GA, you know, yesterday was really focused on now that we’ve got the scaling and the global distribution nailed, how are we gonna help developers get started quickly within the Akamai ecosystem? You know, Akamai acquired Linode some time ago. Linode’s a fantastic cloud platform. Yeah. And we were like, we wanna make sure that a customer can take Functions and tie it to Linode object storage. And also, you know, know that they’ve got, you know, DDoS and firewall for AI from Akamai in front of these things, and we can just kind of layer these services together. GA was our opportunity to kind of put out the platform that had all the foundations for starting to bring all of these things together on behalf of the customer. Akamai being very oriented toward like us pairing with the organizations that we work with and bring solutions to them. This has meant we kind of open up a whole bunch of new opportunities for You know, the kind of the large-ish Akamai customer that’s kind of the bread and butter of the CDN to now edge computing and AI at the edge kind of environment.
Swapnil Bhartiya: Right. And as you also touched upon that, of course, Functions, they run on Akamai’s, you know, of course, distributed network, which means, you know, as you mentioned, the global presence. So what does running that close to User mean for, you know, of course, AI workload? Because latency and all those issues becomes a big—
Matt Butcher: Yeah. You know, when I think about what the actual coolest thing about AI is, it’s that we have finally built a machine interface that replicates the way we communicate as humans. And there’s a hidden contract in there, right? If I’m interacting with a computer as if, you know, using natural language, as if it were a human, then I expect it to respond back to me like it was a human. And the kind of first problem we had to solve was the hallucinating problem. And, you know, we used to talk about hallucinating all the time because the kind of earlier generation of models that hallucinated pretty frequently, that’s gotten a lot better. But now what we’re seeing is sort of that expectation that a conversation moves at a particular cadence. Voice is particularly a striking example of this, right? If I say, hey Swap, and it takes you 3 seconds before you say, oh, hey Matt, you know, that’s socially awkward. We’ve broken that kind of hidden contract that we have about how humans communicate. We need to, as we make this change into sort of like from the early stages of AI into just making it kind of normal, we need to be extra cognizant that we’re building systems that behave that way. So latency once again becomes the number one problem that we need to solve. So we need, you know, a lot of what you hear about is, well, let’s get smaller models, let’s tune our models a little bit better, let’s run ’em on bigger hardware. All of that is part of the problem, but so is proximity on the network, right? And distribution of this kind of processing. We don’t wanna be piping all of those queries all the way back up to one big data center halfway around the planet from us. And deal with all the congestion there and then pipe it all the way back. We want to the end user as we can have that happen and distribute that load so that, you know, when we’re here in Salt Lake City, we’re not also hitting the same GPUs that our colleagues in, I don’t know, like Frankfurt are hitting or even, you know, down in California are hitting, right? We wanna make sure that we’re sort of spreading that work around because then the GPUs can process it faster and then we can push it over the network faster. And then when I say, you know, hello AI thing, I don’t have to wait for 3 seconds for it to say, oh, good morning, Matt, you know? And again, we’re fulfilling that kind of hidden social contract that the technology is to behave as close to being a human being as we can possibly make it. And that’s where I’m really excited about the direction the industry is moving right now because that’s when we really kind of unlock this technology and make it comfortable for everybody. And performance is just a— One of those key hidden elements in there that I don’t think people think about until they hit those stutters in conversation or, Those long delays when they ask a question and are sitting there going, come on, when is it gonna answer my question about what hotels are available next week in Orlando? You know, that kind of thing.
Swapnil Bhartiya: Now let’s talk about open source and of course the Agent Sandbox. What is the open source story here?
Matt Butcher: Yeah, again, going back to Fermyon’s sort of heritage of strong open source community engagement and contributing things into CNCF, we’ve continued doing that and released new versions of Spin and new versions of SpinKube. But the Agent Sandbox is one of those pieces that we’re really excited about. That’s the one we just released earlier. And effectively what we did is we knew that the Spin environment was already a great environment for running code that you don’t trust, right? Agent, like agent-generated code. But we also knew that we needed to provide a little bit more there so that the developer who was creating these agents can build ’em pretty effectively and have a high degree of trust that they’re sort of sequestered appropriately, that the environment is hardened appropriately. Right. We built this intending for it to be part of Akamai Functions and then realized, well, we want the developer to experience that during the course of building the Spin application. Well, really we want to just make sure that everybody has that available to them should they want it. And really the value prop isn’t like any kind of big thing we need to have a trade secret or keep proprietary. We should just open source this whole thing. So that developers can take advantage of it and they can start contributing. And that’s, oh man, one of the best things about coming to a conference like this is I get to meet the people who I’ve never met before, but who have contributed PRs to our open source projects. And they come up and they’re like, oh, this Agent Sandbox is great. I’m thinking maybe if we could do it this way and maybe I’ll take some time to code that up next weekend. What do you think? And still that kind of human connection where we say, yeah, this is the direction that we can really go with it. This is where open sourcing something isn’t necessarily just an act of goodwill to the community, but also a chance for us to get not a bunch of issues of things that people wish that we could fix sometime in the future, but people engaged in building the better thing and helping us build a sandbox that matches expectations a little bit more, that allows the agent to do what it should do and prevents it from doing those things that we don’t want. So it’s been just really exciting to see Immediately the positive impact of open sourcing a technology like Agent Sandbox.
Swapnil Bhartiya: Because, you know, the way open source, I mean, I don’t have to tell you about that because you know better than I do already, but it’s more like, I mean, proprietary do peer reviews and all those things that happen. You get the feedback from customers, but that’s a one-way feedback. And here the thing is your customer, they’re bringing their own use cases. Which, I mean, use cases push the boundaries, but then they’re also actively involved in actually making your own code better, you know? So, and that is something you cannot, I mean, you cannot hire all the bright people in the world, but with open sourcing it, suddenly you are working with them and they’re making your— and I was actually talking to, of course, Craig yesterday, and we are talking about the whole, in the age of AI, the whole thing is that open source may not even be You know, because people are just wipe coding. But I felt that actually that is because okay, creating code base is the easy part. You have done that.
Matt Butcher: Yeah.
Swapnil Bhartiya: But maintaining it, managing it, scaling it, and actually when people start using it, actually that’s when the challenge starts. So the best thing yes, wipe coding as much as you want. Put on the GitHub, put it on the foundation so other people will you know and then build up. So I feel actually that. Open source is actually the next step of wipe coding, actually. And I was just talking to someone else before as well. I was like, if you look at the early days of when blogs came out or YouTube or TikTok and all those, people, you have to work with a studio, you have to work with a publisher. Now people are content creators themselves and they are MrBeast, people like MrBeast. So same thing is happening with open source and wipe coding. Yeah. You can suddenly create your own Photoshop suites, you know? I mean, no offense or whatever, but I feel that the framework that you folks have built with this community, I mean, of course the Linux Foundation, but you folks are the one who built it. The community is what has built it. So now the foundations are there for the next generation to build the software just the way we build content and suddenly democratize it. We have never seen that before.
Matt Butcher: That is such a good observation. If you had asked me this question last year, like, what do you, is open source gonna get killed by AI or assisted by AI, I would’ve said, oh, I think this could really be the end of open source because everybody can write their own code. And then what I’ve seen unfold from the technical point of view over the last year is people are using AI on open source projects to try and get their ideas out there and contribute them, open PRs, and put them out into open source on existing projects. I mean, I’m still involved with a number of projects from like Helm to Spin. And, you know, there was this window of time when we were fretting about we’re getting all these low-quality PRs that were AI-generated and we’re getting these low-quality security things. Well, the models keep getting better and better and the bar, the quality is improving very rapidly. And that means the bar for somebody to contribute to an open source project goes way down. Like way, I can’t even like articulate how much easier it is to, you know, send your agent out and say, I wanna start contributing on this project and it can read the code and it goes through and figures out how all the things work. And you say, I just wish it had this flag that could do this thing and it can do that. The learning curve to contribute to a new open source project used to be the biggest hurdle for somebody to clear. And that’s been brought so far down that I’m coming out of this year A year from when I would’ve said open source is in its death throes, a year in now, I’m saying, no, I think we’re gonna see kind of the revitalization of it. And the trick will be for us as project maintainers to also get comfortable using AI to help us triage through and assess the quality of these things. And if you walk around the conference today, you will see a whole bunch of people working on solving that particular problem as well. And that gives me actually a renewed sense of optimism that open source is gonna continue continue to be the best way to develop software.
Swapnil Bhartiya: Anything else that you feel like we should talk about? Or you think that we have touched on all the key points?
Matt Butcher: We’ve hit on that and then more. I really like this open source thing we hit on at the end because I think that’s a good topic to really help people understand that a new technology can look scary, can challenge our existing patterns. And then, you know, just the way you framed that was so good. Like, there’s a big opportunity here and the barrier of entry is lowered and You know, again, like I said, ending by saying there’s a renewed optimism that we’re going to see open source flourish. That’s just fantastic.
Swapnil Bhartiya: Matt, once again, thank you so much for joining us. And of course, not only talk about your journey, Fermyon journey, but also where things are going. Once again, thank you. And I would love to have you back on the show.
Matt Butcher: Yeah, thank you so much. And, you know, it’s been an absolute pleasure to take this journey with you from, you know, our early startup days through now where we’re seeing a big global impact. Thanks so much.
Swapnil Bhartiya: It’s my pleasure. Thank you.





