MCP was already a hit before it had a neutral home. Then Manik Surtani helped launch the Agentic AI Foundation, and MCP's SDK downloads grew fivefold to over a billion. This week on Dev Interrupted, he joins Andrew to share why he expects the same kind of growth for A2A and the foundation's other newest projects, and why these protocols belong together in a neutral place. Manik also shares the unique reasons behind A2A’s rapid adoption in China’s mobile app ecosystem. They close the conversation on why open source projects like Goose now want your ideas instead of your pull requests, and the neverending roadshow making it all possible out in the community right now.
Show Notes
- Agentic AI Foundation (AAIF): The foundation's home for working groups, blogs, events and news https://aaif.io
- The Daily Agentic AI Newsletter: The AAIF's news and views, published on LinkedIn.
- A2A: The agent-to-agent protocol that grew out of Google and recently joined the AAIF https://a2a-protocol.org
- A2A joins AAIF: The foundation's announcement.
- Model Context Protocol (MCP): One of the AAIF's founding projects https://modelcontextprotocol.io
- goose: The open source agent Manik oversaw at Block, now an AAIF project https://block.github.io/goose
- AGENTS.md: The AAIF's third founding project https://agents.md
- agentgateway: An open gateway for agentic AI traffic, including token spend tracking https://agentgateway.dev
- Agent Router: The related AAIF project Manik mentions alongside agentgateway https://theagentrouter.ai
- AGNTCY: The Cisco-backed agent stack whose ACP spec gave way to A2A https://agntcy.org
- Connect with Manik: LinkedIn | X
- Manik's Substack: Manik's writing on open source and AI https://maniksurtani.substack.com
Transcript
(Disclaimer: may contain unintentionally confusing, inaccurate and/or amusing transcription errors)
[00:00:00] Andrew Zigler: usually I just know exactly where I wanna start, but this one there's like actually s- more things than I can bite into, so it's gonna be a real treat for me. And I, I, I wanna start by saying, Manik, welcome to the show. It's so great to have you on Dev Interrupted.
[00:00:12] Manik Surtani: Thank you, Andrew. I'm very excited to be here
[00:00:15] Andrew Zigler: Yes, and just to kick things off, I just wanna say that, you know, as an AAIF ambassador, I feel like I have been drowning the airwaves over here at Dev Interrupted about all the things coming out of the foundation, so we're really excited to dive into those topics today, really excited to host you and get some insights for our listeners, which are, you know, engineering leaders that are trying to understand how to grapple with these changes in technology and the things that they've taken for granted and how they're evolving.
[00:00:42] Andrew Zigler: And a part of that involves learning about the latest trends in technology, but also getting ahead about how most cutting-edge teams are applying them, uh, to actually deliver value and, and make all of this AI stuff, you know, worthwhile in the end. But I just gotta say, before I jump into our conversation today, I wanted [00:01:00] to ask: What has been the most exciting for you as you've kicked off the AAIF ambassador program and you've started rounding up a bunch of nerds like me under one banner?
[00:01:11] Andrew Zigler: What has that experience, uh, been like? 'Cause I just feel like I've seen so much love on every social media network since the program started.
[00:01:19] Manik Surtani: it's been incredible. It's been overwhelming. And first off, thank you for being an ambassador. Uh, I mean, the, the response has been crazy. Here's a funny story. When we first came up with the idea, the, the plan was we're gonna have 10 ambassadors around the world, and we're gonna start with 10 and then gradually expand.
[00:01:36] Manik Surtani: An arbitrary number, we just pulled it, pulled it up out of thin air. And the moment we announced it, we got so many response of people wanting to be ambassadors that we, we, we had a mechanism of scoring them as well, and, you know, what have they done before and as community organizers, things like that, right? Um, and we had a, a whole little algorithm place, and we had over 150 people which scored over [00:02:00] 95%. And it's like, we're gonna have a really hard time picking that, the 10 people out of this. So we just blew the top off saying we're just gonna remove the cap. There is no arbitrary cap of 10, and we launched with, I think, 140 something ambassadors from day one.
[00:02:15] Andrew Zigler: Yeah, it was a big cohort, and it's so exciting because that's such a champagne problem to have. Like, oh, there's so many extremely qualified and really amazing people out there all across the world that are looking to spread the news about MCP and other projects, some of which we're gonna talk about today.
[00:02:29] Andrew Zigler: So, and I, and I, and I definitely know when I saw the announcement that there were, you know, gonna be 10, it definitely put this, like, competitive spirit in my mind too of like, oh, wow, like, what a great opportunity. And so that, uh, made a lot of people surge to the, to the challenge. 'Cause, you know, you and Angie have done so much for kind of getting folks ov- aligned around how the technology is moving and getting folks informed about how to use it every day that there are so many folks that are willing to jump in and start making this kind of content, some of which [00:03:00] we're gonna dive into, including A2A being one of these latest additions to the AAIF.
[00:03:05] Andrew Zigler: And I kind of want to start there because as one of the most recent announcements, it definitely has some of the, the biggest excitement around it. I wanna know from your, your perspective, uh, at the AAIF, what does the A2A or the agent-to-agent protocol, uh, bring, and what does it signify for the trajectory of, you know, open source agent ecosystems?
[00:03:26] Andrew Zigler: Like, what do you think its role will be to play alongside the other things you have under your wing?
[00:03:31] Manik Surtani: Yeah. So A2A is genuinely exciting. I'm really happy that it's here. A2A as a project grew out of Google as you're, as you're aware, and it already took the first few steps towards vendor neutrality and neutral governance. So A2A already became a Linux Foundation project before it joined the AAIF.
[00:03:49] Manik Surtani: In fact, it did that before the AAIF even existed. for us to bring it in, um, it already meant that a lot of the hard work had already been done. It already had good governance, it already [00:04:00] had, um, good open source chops, um, and then the way it was run already was, was, was, it was run well. It was run well.
[00:04:07] Manik Surtani: So it was easy to incorporate and bring it into the foundation. but the really interesting thing to me though, what it's, what it signifies is genuine vendor neutrality. Now, as you're well aware, the AAIF was founded by MCP and Goose and AgentsMD. Uh, MCP, some people see it as a competing standard to A2A. I don't think it is, but you know, there is a perception out there that it is a competing thing, and I think this really shows that no, firstly, they're not competing, but even in the areas where they do overlap, it, it's genuinely vendor neutral here. We don't actually care where the, these projects came from, whether it was from Google or from Anthropic, um, and such projects can coexist.
[00:04:49] Manik Surtani: They can learn from each other and grow together. It also breaks any of the preconceived notions that this is an Anthropic foundation. It's not. It is an open source foundation. We're all friends. We're all [00:05:00] serving a greater purpose.
[00:05:01] Andrew Zigler: Yeah. I, you know, now that you, you say that, it really jogs my memory. I remember us covering on Dev Interrupted the original movement of A2A into the foundation, and then other projects getting moved under the AAIF, and then now all of them being brought under one umbrella. It makes sense to see this trajectory of them coming to live under one.
[00:05:19] Andrew Zigler: I love how you call, you called out that it's like it was already primed and ready and, like, in the right shape for us to, like, make it part of this, and I think that's a big challenge, uh, getting all of these different stakeholders in the ecosystem to come to the table and w- work in these working groups and develop these standards.
[00:05:34] Andrew Zigler: I've definitely have experienced that here in conversations, uh, both, like, on the show and out in, like, the field at events. A general confusion even around A2A versus MCP. I feel like MCP tends to be, like, the golden stepchild that everyone loves, and A2A is, like, deeply misunderstood and, like, just, like, no one really gets it, and it's just, like, kinda angsty, but it's serving its own [00:06:00] real purpose as well.
[00:06:01] Andrew Zigler: I, I will say myself, I've had a lot of luck using A2A. Uh, we're also really big fans of Steve Yegge and how he talks about software factories and agent orchestration here, and we're practitioners of that as well. We have a lot of, like, factory work behind the scenes here at Dev Interrupted and LinearB.
[00:06:18] Andrew Zigler: And a big part of that for me has been he talks about seats and identities that exist with agents over time and how they own their work and the things they do. And for me, as I've adopted that kind of way of working too, A2A has just become instantly much more prominent and useful in defining ways for them to communicate with each other.
[00:06:37] Andrew Zigler: My agents used A2A to come up with a protocol called Pinky, where they make promises to each other about things they're going to do, and they use A2A to do that, and I just was kind of, uh, shocked that they were able to pick up the spec and u- conform it to what they needed. And those, I think, are the most exciting tools that, that are, th- they are to give to agents.
[00:06:57] Andrew Zigler: So to folks that haven't played around with A2A, you know, [00:07:00] I really recommend bringing it into your agent fleets and seeing, asking them what they think th- how this could help them because that's how this documentation is set up to help them as well. What, what have you experienced with, like, adoption around those tools?
[00:07:11] Manik Surtani: No, that's awesome. I love the name Pinky for that protocol, by the way. That's very cool
[00:07:15] Andrew Zigler: I was, I was like, "Great job." And there's even the little pinky emoji. I was like, "Y'all figured this all out." Um, A+ to them. But
[00:07:23] Manik Surtani: that's
[00:07:23] Andrew Zigler: what have you seen on, on your side?
[00:07:24] Manik Surtani: Um, no, I'm, I'm seeing-- I mean, it's really interesting from my perspective because I think the two protocols have come from different places, and I'm not talking about the companies that created them, but the, the, the, the problems they attempted to address. And there is a lot of convergence, and some of that is happening, and they are definitely borrowing ideas from one another, but that's all right.
[00:07:44] Manik Surtani: That's a healthy and a good thing to do. But they broadly still address somewhat different markets, um, and that, that's sort of what I'm seeing. One interesting tidbit I can share is we've seen a lot of A2A adoption in China, for example, on mobile devices, [00:08:00] where the ecosystem there is quite different from what you and I might be used to in the West. Um, whereas over here, a lot of at least corporate workloads tend to be exposing SaaS systems or server-side systems or custom corporate systems to agents. Um, whereas what we're seeing in China is an ecosystem of apps on mobile devices, and those apps have built-in agents themselves, and they need to talk to one another discover
[00:08:28] Andrew Zigler: the moat is completely different. I see. So where...
[00:08:32] Manik Surtani: the mode of interaction is completely different.
[00:08:34] Andrew Zigler: Yeah, because here the moat is around the data. There the moat is around the agent. You have all these agents that are living
[00:08:40] Manik Surtani: 100%.
[00:08:40] Andrew Zigler: and they have to coexist with each other. Whereas us, we think about these layers of data and then what's the ultimate in gesture or like everything's a lake flowing into another data lake these days.
[00:08:49] Andrew Zigler: We've talked about that with, with a few leaders on the show. And so it's a fascinating also to see then taking a step back, it's almost like with technology, you have this whole thing with [00:09:00] Conway's Law where how companies organize themselves and their cultures and their teams org is reflected in the shape of the software and services that they provide.
[00:09:07] Andrew Zigler: Now that software is a more ubiquitous thing that's used even like in all across the world in a lot more different circumstances because of AI, you also get this like Conway's Law that's like of culture. So the, maybe the shapes of the East and the shapes of the West are just fundamentally different in what they use the agents for because now it's an interpersonal mode of communication and both of them have their own systems for doing those things.
[00:09:31] Manik Surtani: That's right. That's exactly it
[00:09:33] Andrew Zigler: And, and so like moving on with A2A, I, and now that it's under the umbrella, you know, what's gonna be its, its future? What, what kind of exciting things do you see on the horizon for, um, A2A now that it's kind of under the umbrella?
[00:09:49] Manik Surtani: So a couple of things, right? Like if I apply the lens of what has happened to other projects when they've joined the foundation, I expect a similar story here, and that story simply is [00:10:00] far broader adoption, far wider appeal. Now, that's part of the reason why I started the foundation in the first place. I don't know if I told you that story, but I was at Block at the time, and I was leading open source for Block, and one of the projects under my purview was Goose.
[00:10:14] Manik Surtani: We just created Goose. We had just launched it. It was gaining a lot of adoption, and some of the pushback I started to see in the community was around neutral governance. Um, we had competitors using Goose. We had, you know, potential competitors, uh, distributors wanting to use Goose, like Red Hat wanted to package it and redistribute it.
[00:10:32] Manik Surtani: But they all sort of stopped at the I-I'm actually doing it because while it was Apache licensed, it wasn't in a neutral place, which meant they couldn't trust the roadmap. They, they didn't, they couldn't, uh, they weren't guaranteed that there wouldn't be a rug pull or something like that, right? So that's where I started to see the push for, for neutral governance and that that was the birth of, of the Agentic AI Foundation, and, and David at Anthropic saw the same thing with MCP, so we kind of joined forces and we launched the thing. But what we've [00:11:00] both seen is the Goose story was Goose's adoption just grew exponentially after the creation of the foundation. That was kind of to be expected. That's why we did it. The surprise to me was what happened with MCP. MCP was already flying high. MCP was by far and away one of the most popular projects and protocols out there before the foundation. It's almost like how much further can it go, right? And guess what? It did, like five times, in fact, the number of downloads. We have over a billion downloads right now of the MCP SDKs. Um, and it's, it's basically 5X in, in the eight months since creating the foundation, right? Uh, and that's only for a well-known project.
[00:11:40] Manik Surtani: For a slightly lesser known project still, that's the sort of hockey stick sort of growth we are seeing. We saw that with Agent Gateway. Um, we're, we're seeing that with other projects too, and I expect to see the same with A2A. I again know A2A is a popular project. It has a lot of adoption, but I think it's going to increase a lot more.
[00:11:57] Manik Surtani: There's a lot more runway for it to [00:12:00] grow.
[00:12:00] Andrew Zigler: I'm excited to see that kind of hockey stick and, and where it's going to take it. And, you know, you talked about Goose. I will say big fan of Goose here on the show. We talk about Goose a lot, but also I myself am a user of Goose. I'm an early practitioner, and I, uh, was on an episode of codeTV with Angie Jones for Goose actually back in, like, October, and that was a ton of fun.
[00:12:21] Andrew Zigler: We had a coding challenge where me and my, my coding partner, who's my friend from Google, we had to create an app that you can- cannot control with a keyboard or a mouse, and we had to make it in four hours, and we did it with Goose. Uh, so you can watch us, like, totally fool around. This is, like, try to figure out how to combine our two code bases.
[00:12:39] Andrew Zigler: This is sub-agents were just then starting to be a thing. Like, I don't even think we were at Opus 4.5 yet. Like, it was a hard time for us on that show. It's a total blast to watch it. And so we used Goose, and I've s- I've used Goose since. A lot of my workflows are built on Goose, um, and I think it's a really powerful tool and I, I totally agree with you.
[00:12:58] Andrew Zigler: I've loved to see how much it's grown. I [00:13:00] love to see how that happens with MCP as well. Um, and speaking of MCP, the darling golden child, I guess we must move on to the favorite one that everyone loves to talk about, and us too here on Dev Interrupted because I feel like we talked about the, the MCP when it first hit the scene.
[00:13:16] Andrew Zigler: We talked about MCP when it first died. We talked about MCP when it came back to life. We talked about MCP when it died again. We talked about MCP when there was a scoreboard about how many times it died. And then now we've covered the latest spec where it became the 7.28 spec. We're not calling it the 1.0 because that's a misclassifier for what it really is.
[00:13:33] Andrew Zigler: And it was all about the stateless design, and what that's unlocking for teams now is they can get more operational with MCP. And it's been really exciting to see how that architectural evolution has shifted us towards, like, a wider adoption. Just curious what your thoughts are coming out of the 7.28 release and what you're most excited about.
[00:13:51] Manik Surtani: Yeah. So I mean, like that release is super interesting, right? But again, just like most things happening in, in MCP, it, it's, it's, well, responding to [00:14:00] demand from the community. I actually think the MCP project is an incredibly well-run project where they're very close to the community, they really listen, um, and, and the 7.28 release was an example of that. We understood what people's-- where people's pain points were, people were looking for ways to simplify things and improve and, and we were able to do that. So I think that's really powerful. Um, like I said, excellent community stewardship. Um, in technical detail, I mean, statelessness of course is a big deal.
[00:14:28] Manik Surtani: It's simpler to manage, it's easier to deploy, things like that. Easier to just wrap your head around. So I th- I think that that's, that's been a really interesting change.
[00:14:36] Andrew Zigler: And what do you think is the maybe biggest challenge for teams now that that's... Like, now that it's stateless, right? And, uh, teams can more thoroughly adopt and, and have these as, as, like, workflows that are exposed to customers or their employees, and they don't have to worry about juggling this state, which w- before was kind of, like, very, very much a nightmare for serving MCPs at scale that were embedded within services and doing what, what folks [00:15:00] love.
[00:15:00] Andrew Zigler: But now that MCP is stateless, what we envision to see is, organizations finding ways to pack the value that they give to customers and their users into MCP tools that are then delivered into other surfaces, too. I, I also think about things like MCP apps and UI, and you have lots of, uh, MCP that pushes now interfaces into chat.
[00:15:20] Andrew Zigler: Do you think that becomes the next things that these things optimize for? I'm just curious how you see, like, all the whole spec evolving even beyond the stateless situation.
[00:15:29] Manik Surtani: Yeah, I don't know. It really depends on what people do with it. So I think a lot of-- I mean, just because the protocol is stateless doesn't mean there's no state. State still has to live somewhere. People still have to manage that, and that ends up
[00:15:40] Andrew Zigler: Right
[00:15:41] Manik Surtani: into the application. That's not a bad thing.
[00:15:43] Manik Surtani: That's a great place to manage state really. Um,
[00:15:45] Andrew Zigler: Yeah
[00:15:46] Manik Surtani: and I think, well, it really depends on now what sort of shape those applications take. So yes, it's something to watch and learn and see, see how it evolves.
[00:15:55] Andrew Zigler: For sure. And for, let's say that we're a team, [00:16:00] like a larger engineering team, and we're using MCP servers internally to serve things between teams. That's what I've seen as a really common use case, especially as ecosystems of enablement start to pop up within like a large engineering org. You get this pocket over here that's really agentic, this pocket over here that's building agents and doing cool stuff.
[00:16:19] Andrew Zigler: They start to connect and share things with each other. Other teams and departments now wanna tap into this and use things, and now those teams start to think, "Is MCP the tool that we use to open those gateways and allow the teams to interop with each other?" I'm curious if you think MCP has a place there or what you would say to that kind of team that's trying to figure out how to share their AI success across their different departments and stuff.
[00:16:44] Manik Surtani: absolutely. I, I think those patterns have yet to be, I don't know, standardized, I suppose. Um, there's
[00:16:50] Andrew Zigler: Yeah. It's the Wild West out there.
[00:16:51] Manik Surtani: It's the Wild West. There are many ways to skin
[00:16:52] Andrew Zigler: Yeah.
[00:16:52] Manik Surtani: that cat, right? Like, each department could have their own agents and using A2A to talk to each other and coordinate perhaps, right?
[00:16:59] Andrew Zigler: [00:17:00] Yeah.
[00:17:00] Manik Surtani: Perhaps you could encode what you do as an agent skill and share that, and then anyone else can pick up that agent skill and run with it. Uh, and
[00:17:07] Andrew Zigler: Yeah
[00:17:07] Manik Surtani: you expose your data endpoints as MCP endpoints, so you have access to, to information from each department. So yeah, it absolutely is the Wild West.
[00:17:15] Manik Surtani: There's a little bit of, there's no right answer, I suppose, is what I'm trying to say, and everyone's kind
[00:17:19] Andrew Zigler: Yeah.
[00:17:20] Manik Surtani: different. That's okay because we haven't figured out.
[00:17:22] Andrew Zigler: There's no right answer. There's no Scantron that you can grade. You know, unfortunately, not a lot of people have a lot of answers, so the answer becomes to experiment. So now it becomes a matter of having a bold experimental mindset, but then also having diligence and good record keeping and, and good understanding of what you're building and where it's going.
[00:17:43] Andrew Zigler: So a lot of this too, especially with agents, right? You start introducing agents and you have stuff working and running underneath you, you start to get very abstracted from all of the cognitive stuff going on in your org, and that can make it really hard to be strategic. But then also too, to track the [00:18:00] impact and understanding of like, oh, I have all these agents.
[00:18:02] Andrew Zigler: I'm using all these tokens. I have all these workflows. But what is it giving me? What is it giving my team? What is it delivering to, like, the, the end user, for example? Um, do you have strategies for folks that are increasingly agentic to be able to tie and show the work they do, uh, back to, like, ROI or prove that maybe these workflows that they're building have this kind of durable value to them?
[00:18:27] Andrew Zigler: Because as you're g- as you've, uh, rightfully said, like, it's the Wild West. There's no w- there's no right answer. So how do you start to, um, draw some lines down so folks can start agreeing?
[00:18:38] Manik Surtani: Yeah, absolutely. No, that's a, that's a tricky thing to do for sure. I think there are a few things that need to happen. Like one is, um, always have a skeptical mindset, right? Always come in to say, "I actually don't know how much value this is gonna provide. It's very possible it'll be zero," right? So you cannot be emotionally tied to your work.
[00:18:56] Manik Surtani: You should be willing to throw it away. Um, and even some of the patterns we [00:19:00] talked about may not be the right patterns, and okay, that's fine. Be ready to scrap it. Be ready to move on or transform it.
[00:19:06] Manik Surtani: Luckily we're in an era where some of that change can happen very quickly and relatively easily. So okay, cool.
[00:19:13] Manik Surtani: Embrace that. Embrace the change. Embrace being able to throw away stuff, let go of things. Um, but then it also goes back to what you were saying around measuring that ROI. That's really important as well, so you know what to change, what to let go of, what to drop, what's working, what's not.
[00:19:27] Andrew Zigler: Yeah. So you need, you need visibility and an understanding of, of, uh, of your inputs and also those outputs. And, you know, a really interesting tool within the, the AAIF ecosystem that I've ha- found really useful for this is Agent Gateway. That's a, that's a tool that I've picked up and I've used personally, and now I route most of my Claude Code or whatever other sessions through this, this proxy, through, uh, the gateway, and the benefits of that have been really multiple for me.
[00:19:57] Andrew Zigler: And not only you get, like, the, the tracking on [00:20:00] your, on your token spend across all your tools, and it's very well labeled just out of the box, but now you have an ability to pin all sorts of really cool and informative metadata to all of your API requests and do all sorts of really interesting analysis.
[00:20:14] Andrew Zigler: I, I wrote this article, uh, that I published on my website la- uh, very recently about how, I... For example, I use Beads, uh, the task tracker, to do, uh, like agentic task work. And what — I created a system where they could pin their beads to the inference that they put in the gateway, which then unlocked an ability to tie tasks, like discrete tasks that were thought through and then brainstormed and completed, to their inference calls, therefore tying them to, like, a cost.
[00:20:40] Andrew Zigler: And it wasn't totally accurate, but it started to give me a ballpark about, you know, the different costs of the different things that I did every day or the workflows that I ran, and it became really informative for me. But it had to start by, like, getting that level of visibility. I didn't know what questions I needed to ask.
[00:20:56] Manik Surtani: Right
[00:20:56] Andrew Zigler: I saw the data, and I was like, "Oh, why is, [00:21:00] why is 80% of this cost in the brainstorming?
[00:21:03] Andrew Zigler: Maybe I'm using the wrong model. Maybe I'm giving it way too much stuff to read." And, and that's actually unlocked a lot of opportunities for me to get better personally. So I've, I've thought of a lot of, like, interesting abilities for maybe teams to utilize that kind of thing as well. But, but there's, uh, but there's so many, uh, complications involved with being able to have that kind of good tracking and visibility.
[00:21:23] Manik Surtani: Absolutely. I was going to bring up Agent Gateway, but also Agent Router, which is a similar and related project and gives you a different set of information. Um, the interesting thing with both of those though, the, the really interesting thing for me is that it gives you model independence. And in this day and age, I think it's really important to have model independence. Things are changing so
[00:21:43] Andrew Zigler: Yeah
[00:21:43] Manik Surtani: quickly. I mean, what's the b- the best model for a particular task today may not be the best model tomorrow, and it's not just bumping a version number. Quite often it's a different model from a different vendor, possibly an open weights model. And being able to do that I think is really, really important. Um, you don't wanna lock
[00:21:58] Andrew Zigler: completely agree. [00:22:00] Yeah, it's, like, important to have, like, a substrate where you can collect all of those. It's good to have these layers when you're working with these tools where any kinda, any kinda tool ecosystem layer where you're working where there's a lot of providers and a lot of consumers on either side of it, it really benefits you as that person to also draw your line and have your block in there that everything moves through.
[00:22:21] Andrew Zigler: Otherwise, you just kinda end up in this, like, spaghetti web of, like, "Oh, I use this, and it goes to this, and then that goes to that." But if you have a centralized place, you can then start to have real meaningful conversations. So, um, so th- then I guess maybe that's one strategy we've kind of unpacked here, is, like, having visibility as a team on, you know, your usage, and then tying that back to tasks as well.
[00:22:42] Andrew Zigler: But I wanna talk for a moment about the engineers out there and the engineering leaders, especially to those listening to this episode, because they're in, like, a slightly different position with how they have to manage agents because they're not only all up and around the meta stuff of the work they're doing, but it's also their day-to-day grind, you know?
[00:22:58] Andrew Zigler: We're talking about, [00:23:00] in our recent research from LinearB, we found that even in, like, some of the most advanced or the most, like, uh, mature AI adoption organizations where they have, like, a higher percentage of agentic PRs to human PRs, you still see overwhelmingly that those PRs sit at, like, a really high n- unmerged rate.
[00:23:17] Manik Surtani: Yeah
[00:23:18] Andrew Zigler: in some cases, 70% of agentic PRs in, like, in, in a moderately agentic organization goes completely unmerged. So then you have to start thinking about, like, what kinds of costs go into that and what do you get out of that. And parts of that are obviously our SDLC has new bottlenecks. We talk about that a lot here, es- especially bottlenecks around review.
[00:23:40] Andrew Zigler: That's the new, uh... That's where a lot of the work is happening now. What advice would you give for engineering teams that maybe are struggling under those kinds of workflows or encountering those new bottlenecks? How can they get ahead, um, instead of choking at them?
[00:23:53] Manik Surtani: Yeah, that's really interesting. So I'm, I'm seeing that not just in engineering, by the way, but in other disciplines as well. So, [00:24:00] um, I had, I had an interesting term yesterday. Someone referred to people who, who publish PRs like that as slop cannons.
[00:24:08] Andrew Zigler: Yes.
[00:24:09] Manik Surtani: do we do with the slop cannons, you know? You got, you got these people just shooting stuff at us constantly, and I mean, like, how do you deal with this, right? It's, it's interesting. I don't think there's a clear answer yet. I've seen teams approach, um, fight AI with more AI, right? Great. If you're getting lots of AI-generated PRs, we need AI-generated code review. Sure, that makes sense. Is that enough? Probably not, right? Are you still gonna get swamped by those?
[00:24:33] Manik Surtani: Probably. And then also in the age of, um, I don't know, code being generated for next to free, right, or, or just the cost of tokens, um, do I really value a PR anymore? I mean, am I just using that PR as a way to get someone else's tokens or someone else's token budget? That's all it is, right? So what's the point of the PR really?
[00:24:55] Manik Surtani: Just give me the token budget, I'll do it myself. Um,
[00:24:58] Andrew Zigler: Yeah
[00:24:59] Manik Surtani: there's a little [00:25:00] bit of that as well, as I'm thinking there. And then there's another bit of thinking around the code review itself. Like code review at scale, um, f- for open source projects it's different, but if you're talking about within a corporate environment, sure, code review happens.
[00:25:13] Manik Surtani: How good is the code review or how high is the quality? Is it useful? I don't know. You're more relying on the author of that code to actually know what they're writing. That's more important than the code in some of those cases, right? Um, the problem that I've seen in, in larger corporations is where the code generation part is happening automatically, even though it's being signed off by an author. That person's not even reading that code, so why then should someone else go and review that code, right?
[00:25:40] Andrew Zigler: Yeah. Yeah
[00:25:41] Manik Surtani: you what, how about this as a trade-off? I will skip the code review part. I'll have an AI do the code review, provided you as the author read your own code that you've generated, right, and approve it.
[00:25:52] Manik Surtani: And how do you hold that person accountable to that? So that's a more interesting question really at this point, and probably more relevant as well. [00:26:00] So that, that's as far as like what happens within a corporation. In the open source space it's a bit different, um, because again, you have no accountability to one another.
[00:26:08] Manik Surtani: It's a bit harder. I've seen a couple of projects do, in- including Goose by the way, uh, doing this now, which is quite interesting, where they've stopped accepting PRs full stop. Like, we don't want your PRs. It's nothing but a conduit to your tokens. We want your ideas. If you have a bug, tell us about it. If you see a bug, tell us about it. If you want a feature in, tell us about it. We're accepting issues. File an issue, a detailed, well-written out issue, and we'll point an AI to that to generate the code.
[00:26:37] Andrew Zigler: Yes. Uh, absolutely. That has been a really interesting shape, and you're actually getting into a burning question that I had for you because it's something we talked about many a times on this show is about the open source ecosystem just completely drowning underneath the, the AI world. Like f- I was, uh...
[00:26:53] Andrew Zigler: I remember the... There, there was an early canary in the coal mine, and that was Hacktoberfest, right? And it's like there were... [00:27:00] Everyone saw the evolution of this getting really spammy, and then now it got to a point where you have open s- very big, uh, very important open source projects that actively turn away or don't allow those kinds of contributions.
[00:27:11] Andrew Zigler: You see really in a total evaporation of new c- uh, contributor, new mainten- main- maintainer onboarding because good first issue doesn't exist in an agentic world. And so, a- and, and so you really kind of, um, it... And, and then that ruins the ability to, like, make maintainers of tomorrow. At the same time, this is like a, a mini, a mini version of the whole build versus buy conversation that everyone's having on everything on their line budget about do we just build this?
[00:27:38] Andrew Zigler: Do we buy this? And there's a l- whole bunch of reasons for why. We've un- we've unpacked that up, down, left, right on, on Dev Interrupted, including in a number of, of webinars and workshops about it. But... A- and I even tried to build LinearB. You know, at one point I was like, "Can I just like build our own thing?"
[00:27:53] Andrew Zigler: And I just did it, like, live on a live stream because everyone was trying to figure this question out. And a- another part of it too is that those [00:28:00] folks that had those projects, they didn't know how to engage with their community anymore. They became, uh, a- in fact, estranged from their users because their users were no longer humans that loved the project and it fixed some problem for them.
[00:28:13] Andrew Zigler: It was some random agent who plugged them into a package JSON somewhere, and then they just ended up deployed, and there's no more of that kind of fostered connection. So what is your advice to the open source world? Is it right for them, or do you think that the strategy is going to scale for them to keep the walls and the gates closed?
[00:28:30] Andrew Zigler: Do you think they have to change their mindsets? Because what you've just described around the whole issues approach is the approach that I have seen work in the last year. There's a number of open source projects that I respect and use a lot, one of them being the beads-rust library from Geoffrey Emmanuel that I use, and he doesn't take any PRs either.
[00:28:49] Andrew Zigler: The man has like 1,000 Claude Max accounts. He doesn't want your tokens. He just wants your ideas, and he just wants to make sure they're perfectly aligned with whatever mental system him and his [00:29:00] agents have mapped out in all of the way of the how they thought the software should work. And so people drop in issues, and he closes them, opens them.
[00:29:07] Andrew Zigler: It's really fascinating actually. I have one of my issues then got turned into something that they merged. But, you know, I, I did feel as a contributor, I guess, in this situation a little divorced from the contribution experience. So how do you think this is all gonna evolve? What's your advice for those folks?
[00:29:22] Manik Surtani: I, I think the contribution experience, as you say, changes drastically. It shouldn't go away. I think it's important for project maintainers to stay connected to their communities, but the shape of that community changes now. The community is no longer a community that's giving you code because that's, again, not where the value is.
[00:29:39] Manik Surtani: The value has moved.
[00:29:40] Andrew Zigler: Right.
[00:29:40] Manik Surtani: The value is in sharing ideas, in sharing experiences, in sharing thoughts, and I think a good maintainer will shift gears now and spend a lot of time creating those community spaces where the community can, can contribute where the value is, right? Like, tell us about what's going on with the project when you're using it.
[00:29:59] Manik Surtani: [00:30:00] Tell us what goes wrong. Tell us what goes right. Tell us what you wished you had. All of that stuff. Share ideas, share experiences, and that's where the value is. Um, and spend time writing it out perhaps, right, in a really well-crafted issue that an agent can pick up and run with and go build. But, you know, don't just throw slop in terms of here's a PR that I don't actually
[00:30:19] Andrew Zigler: that's the key thing is like you do have to curate the slop out. It's like a lot of a nucleus now of starting like a good project or a project that's going to be able to foster collaboration across multiple people is you have to fight really hard at the beginning to get a crystallized super clear version of what you want without any of, any echoes of those weird slop things in there, 'cause those echoes just, they, they just boom once you let them, uh, f- like fester in some original document.
[00:30:47] Andrew Zigler: And so there's al- like the scope of the work where you've put your attention changes. You've rightfully called out how, um, you know, code is cheap now, code is free now basically. So it's not about the value of you giving [00:31:00] your code contribution. That's not what I need. I need your idea because that's the real bottleneck in, in open source it's around discovery, engineering teams it's around alignment and delivery, but those are like the main kinds of bottlenecks for sure. Diving back out of the open source world for a second and talking about those engineers again that are more in like a traditional like, uh, engineering org, a lot of them too, I wanna get your perspective on this evolving narrative of the software factory, of this idea that, you know, all of this is going to become automated in some sense from end to end, and humans kind of get relegated to these cornered aspects of it where you have the domain experts at the very beginning, you have the ideas and the alignment where you bring in customer ideas, and then you have the, uh, verification and check and alignment and review on the end.
[00:31:46] Andrew Zigler: But a lot of the stuff in the middle gets automated. Are you bullish on the software factory? Do you see it taking a different shape?
[00:31:52] Manik Surtani: I'm pretty bullish on it. I think that is the way it is going to end up. Are we there yet? Are we there now? I don't think
[00:31:58] Andrew Zigler: No.
[00:31:58] Manik Surtani: I think we
[00:31:59] Andrew Zigler: Yeah
[00:31:59] Manik Surtani: in [00:32:00] very constrained, you know, pockets perhaps, um, or very narrow pockets, but I, I don't think we're broadly there. I, I do think that's where we go, for sure.
[00:32:10] Andrew Zigler: Do you think engineers evolve to become like these factory foremen, these like people who are building the factory? Do you think that's what happens next?
[00:32:16] Manik Surtani: 100%. 100%. And I think that's a mindset shift that we need to be prepared for and prepared to take. I think it's a really important shift, and shifts like this have happened before. Like once upon a time, being a programmer meant writing machine code, and, know, people who wrote machine code would laugh at, you know, anyone using a high level language saying, "You're dumbing down programming.
[00:32:36] Manik Surtani: What are you doing?" But of course, that was a necessary step to achieve scale. And similarly, I think this will be the next, you know, step of scale that we achieve by adopting something like a software factory. Um, and we then have to move to a higher order of thinking and thinking in terms of systems and broader, broader sort of outlook versus just thinking about the programming.
[00:32:57] Manik Surtani: The programming bit is not that important actually. [00:33:00] The engineering side is much broader than just programming.
[00:33:02] Andrew Zigler: Yeah, absolutely. And it, it is a lot about a mindset change, and it's about, um, changing the ownership about the work that you do. We talk a lot about the show about you owning now, like, the decisions behind what happens as opposed to the actions being directly done themselves. And so it's definitely a, a shift for folks that are typically used to everyday writing code, but a lot of opportunities, too, to change the way and evolve the way and discover the new ways that we're gonna be working.
[00:33:30] Andrew Zigler: Because like you said, there's no right or wrong ways to do this, which allows a lot of us to then kind of experiment. And, and for those that are maybe experimenting and they're pushing the edges of what agents can do and how they can collaborate with each other, you know, there's a lot of interesting lessons that I see coming out of these open source standards and these ecosystems that you're maintaining.
[00:33:50] Andrew Zigler: And obviously, you have MCP addressing the whole question around tool usage and how do we make them action-wise and useful. And you have A2A, which is [00:34:00] starting to answer this bigger question of how do you allow agents to communicate and coordinate and collaborate? These are, these are, are deeply, like, systemic elements of can these things be productive?
[00:34:12] Andrew Zigler: Do you think there are other systemic elements of them being productive that maybe are, are still missing, or maybe that we're still trying to figure out or that you think would be, would be next? An- any, any opportunities you see?
[00:34:24] Manik Surtani: Oh, opportunity is everywhere. Opportunity is galore right now. Uh, which direction do you wanna go in, right? Like from a tooling perspective
[00:34:31] Andrew Zigler: Yeah
[00:34:32] Manik Surtani: absolutely. There's a ton of stuff that we still need as humans to interact with machines in a software factory type environment, right? For starters, um, is GitHub the right answer there anymore?
[00:34:43] Manik Surtani: I don't think it is.
[00:34:44] Andrew Zigler: Mm-hmm.
[00:34:45] Manik Surtani: We need something that'll track more than just human scale pull requests. We need something that will give you the genesis of what prompts were used to get a particular outcome, things like that. Um, but
[00:34:56] Andrew Zigler: Yes, the Git forge. The, the birth of the rebirth of [00:35:00] the Git forge. It's way, way, way overdue. I feel like we cover this a lot on this show because everyone is just chomping at the bit for a new Git forge 'cause the problem has changed, and what needs to live in the forge has changed too
[00:35:11] Manik Surtani: problem has changed, the type of usage has changed, all of this stuff, right? And then you've got the situation where you potentially want adversarial agents building a thing, right? I think that would be fantastic if you had something built into something like Git or something like GitHub, where you could have multiple agents tackling the same problem backed by different LLMs even, and sort of fighting it out to find the right answer, the best answer, critiquing one another and things like that. Again, GitHub isn't built for that. it,
[00:35:39] Andrew Zigler: Right
[00:35:39] Manik Surtani: human scale and it doesn't work like that. Um, so, and there's a whole bunch of stuff around the tooling over there, but even on the review side, as a human reviewer, where you wanna sometimes be able to st- step in and check or just to be able to, to view an audit trail of what happened when a bunch of adversarial agents tried to build a thing.
[00:35:57] Manik Surtani: What were the things they considered? What were the things they [00:36:00] dropped? What were the decisions they made? What were the decision points? And you wanna be able to walk through that. That's more important, again, than the code, right? It's sort of inquiring what the thinking process was. Um,
[00:36:10] Andrew Zigler: Yeah
[00:36:11] Manik Surtani: for that either.
[00:36:12] Manik Surtani: I mean, we've, we've got a log of stuff, but no one's gonna read through all that. We need something a lot more intuitive and easier to use. Um, and then of course, there's a whole bunch of stuff around, around security and identity and authorization, who is allowed to do stuff, right? And we haven't even touched...
[00:36:27] Manik Surtani: So far we've just talked about building software. There's still the
[00:36:30] Andrew Zigler: Right
[00:36:30] Manik Surtani: deploying and running of software, which I think, again, is a whole separate area that needs a lot of work and the tooling around that. Um, same thing again, the audit trails. How are you gonna, uh, ensure the thing did what it was supposed to do? How do you provide the right levels of access? How do you revoke the right levels of access at any given point, right? Like really short-lived tokens, things like that. And then of course, there's overarching all of this is the issue of hallucination, which yes, is being, is driving down. It's less and less common, but still you want [00:37:00] verifiability. You wanna be able to know that an action taken was based on real information, not something made up. How do you trace that? How do you, uh, how do you make sure you can verify that and roll something back if something bad had happened along the way? So yes, there's a huge tooling gap, I think, all the way across.
[00:37:16] Andrew Zigler: Yeah. So if you're listening to this and you're thinking, "Gosh, I wish I could invent the next MCP or the next A2A," there are still plenty of opportunities out there is what I'm hearing, and there's...
[00:37:28] Manik Surtani: Yes.
[00:37:28] Andrew Zigler: Yes, and, and also too the, just the development overhang that we have right now. Like, there could-- we could cease having all development and improvement with mo- models as they are today, and there would still be so much work to be done across all industries and all places of the world based on what we've found so far just in the last few years, that we have plenty to keep us busy.
[00:37:48] Andrew Zigler: And so I think it's really interesting to explore the problems and the f- and to figure out what's gonna be most important and, two, to see how these organizations are coming together to collaborate on these specs, [00:38:00] um, but also too to come into working groups and kind of mature these standards that are gonna be powering the technology of tomorrow.
[00:38:07] Andrew Zigler: It's all a really exciting opportunity, and maybe this is an opportunity too for our listeners if many of them are on teams where they are using these types of technologies. But also, maybe they've rolled something of their own that's like a weird cousin or a weird, uh, brother to like one of these things.
[00:38:24] Andrew Zigler: It definitely is happening. I've-- I'm talking to orgs that are kind of hand rolling and hand creating all sorts of different ways and systems of their t- uh, teams communicating or their agents communicating. And so what, what advice would you say to teams that are experimenting and maybe haven't conformed to the standards or maybe they have ideas about what the standards could do that doesn't match what they need, so they ended up evolving into something different?
[00:38:48] Andrew Zigler: How do they come to the table? How do they make, uh, these kinds of tools match what they need and join, um, that way we can all kind of work together as an ecosystem?
[00:38:56] Manik Surtani: Yeah. So experimenting is great, right? Like I love it when people do that. I'm [00:39:00] glad people are doing that, and we sort of seem to have found ourselves in this Cambrian explosion of ideas. I love it.
[00:39:07] Andrew Zigler: Yes.
[00:39:08] Manik Surtani: It's gonna shake down. Some things are gonna go away. I mean, that's normal, right? Um, I think that, uh, I mentioned this before, teams need to be not too married to a particular idea or a particular approach they have.
[00:39:19] Manik Surtani: If you do see a better approach, be ready to drop one and move in with the other. So a, a really good example is, is Agency, um, is a Cisco, um, Cisco consortium that they, that they stood up around agentic tools and frameworks, and one of the things that AGNTCY built was something called ACP, uh, not the Agent Client Protocol ACP, uh, not the Agent Commerce Protocol ACP either. An overloaded acronym. Um, it's a different ACP which turned out to be very similar to A2A. And when A2A came about, in the end, Cisco realized, you know what? Even though we've spent a lot of time and a lot of effort developing this protocol, and it's in production use and everything [00:40:00] else, we're gonna sunset this, and we're gonna double down on A2A.
[00:40:03] Manik Surtani: In fact, we're gonna move our resources over. We're gonna join that project. So I thought that was a really healthy sort of way of sunsetting one thing and doubling down on the thing that's getting a lot more momentum.
[00:40:14] Andrew Zigler: Yeah
[00:40:14] Manik Surtani: I love the fact that people are experimenting. That's great. Bring in the ideas, right?
[00:40:18] Manik Surtani: Contribute the ideas. Um, at some point you might end up joining another project and sunsetting it. That's okay. Be prepared to do that. Or the opposite might happen. You might find other people sunsetting theirs and joining yours. That's, that's also a win. So yes,
[00:40:31] Andrew Zigler: It's
[00:40:31] Manik Surtani: think
[00:40:32] Andrew Zigler: about experimenting, like you called out at the beginning of our talk.
[00:40:35] Manik Surtani: And,
[00:40:36] Andrew Zigler: Yeah.
[00:40:36] Manik Surtani: point of experimenting is you can't be too tied to an outcome.
[00:40:40] Andrew Zigler: Exactly. You have to have that bold experimental spirit, and that means throwing away experiments when they don't work or joining others when they're maybe onto more of a hunch. But it's also too, I love the ACP, uh, narrative, not first ACP, you're not the second ACP, but the other ACP. But I love that narrative...
[00:40:58] Manik Surtani: yeah, it's between other two for, you [00:41:00] know
[00:41:00] Andrew Zigler: Okay, well, when there's a fourth one that pops up, we'll add them to the list. And actually, what, what, what I loved about that story is it reminds me of a guest we had at, on the very beginning of the year. They might've been, like, the first episode of 2026 or the second. It's Tyson Singer. He's the platform leader over at Spotify, and we talked about Spotify Backstage, and we talked about the IDP.
[00:41:20] Andrew Zigler: And you know how Spotify is basically, like, synonymous with the IDP in the engineering world, and Backstage is a, and Portal are, like, a, an industry standard. And we talked about their story of how they established that standard, but then also too how strategically for them, the reason that they established and created that standard when no one else was doing it was because it was gonna save them a huge cost and mental burden later of not aligning to something or not establishing an industry-wide standard, and then later having to change theirs to m- match and march up with everybody else once they all caught up with the memo, 'cause Spotify was way ahead on what these engineers needed at scale.
[00:41:59] Andrew Zigler: [00:42:00] So that was a fascinating conversation for them, that it was just as much about the technology, uh, but also on a strategy level of just avoiding the pain of having to do a really painful transfer later. So right now, what I'm hearing from you and your story is, like, we're in an experimental phase. We wanna be bold and experiment.
[00:42:18] Andrew Zigler: We, but we also wanna be bold and be able to join larger standards as they start to formalize, because that's where you're starting to get more standardization around how the things are used. You get more cross-compatibility across orgs, and, uh, you just get more people bought in in conversations around the technology you're building because you're using the same language as everyone else.
[00:42:37] Andrew Zigler: And it doesn't have to mean aba- abandoning things either, so
[00:42:40] Manik Surtani: Momentum as well, right? Like, if an existing project has more momentum, it will go further than yours.
[00:42:46] Andrew Zigler: Right.
[00:42:46] Manik Surtani: Looking at where it's going to go in the future as well, it's better to get behind something that has that kind of momentum behind it. So I guess the answer is really keep experimenting, that's a good thing, but also keep an eye out.
[00:42:57] Andrew Zigler: I wanted to end by asking you, which A2A [00:43:00] project do you think doesn't get enough attention?
[00:43:04] Manik Surtani: That's interesting. Um, I don't have a good answer for that. Um, we're, we're still pretty new with A2A right now.
[00:43:10] Andrew Zigler: You love all your children. There's no, there's no, there's no one where it's like, "Ah, well maybe that one just doesn't get quite the spotlight as the others."
[00:43:17] Manik Surtani: Now, I'm spending a lot of time with A2A at the moment as we are onboarding them and they're still new to the foundation, so getting to know where the opportunities are and where things can be boosted. Um, that stuff is still working out and where they need help and things
[00:43:31] Andrew Zigler: Yeah, totally. Totally.
[00:43:33] Manik Surtani: They've got a lot of momentum.
[00:43:34] Manik Surtani: It's great to see the momentum behind them. Um, lots of momentum in places I wasn't expecting, like I said, with the China mobile story. Um, and I mean, the stuff there happens at such a scale. They, they try a little beta experiment on, you know, 40 million users. It's like, what? You deploy that to 40 million users and that's a little tiny beta experiment running in the corner.
[00:43:55] Manik Surtani: Wow, okay. The scale there is just crazy
[00:43:59] Andrew Zigler: [00:44:00] Scale is, is very crazy and, and the systems are just totally different too, so it's a whole different game. But it's been really interesting to explore just even the shape of how this technology matches the different teams. We talked about how it matches different cultures and also different companies, but also conforms to the individual needs and of the, and of the, of the developer.
[00:44:18] Andrew Zigler: Uh, and so there's just so many ways that this technology can be customized, but then also augmented with these really powerful and important technologies within our ecosystem that we're all sharing and figuring out how we're going to be using today, tomorrow, and the days to come. And so, Manik, it's been, like, amazing to have you on this show to kind of give us a high-level view of the different things in, in your ecosystem, how you see them evolving, and you've given us a lot of tips for the engineering leaders listening about maybe how they take this back to their teams, think about their bottlenecks as well.
[00:44:49] Andrew Zigler: Where could our listeners go to learn more about some of the latest work coming out of your org and, and the things you're working on?
[00:44:55] Manik Surtani: Absolutely, yeah. Um, well, thank you for having me, for one thing. It's been a really fun conversation. [00:45:00] Um, I'd like to point people to AAIF.io. That's the AAIF website. It's got information on our working groups, on our blogs, events, news. We even have a newsletter called "The Daily Agentic Newsletter," which is on LinkedIn. You can find it there. And of course, I, I personally blog as well on maniksurtani.substack.com. Um, so look for me on Substack, you'll find me there. Um, I, I write a lot about all things open source and AI.
[00:45:28] Andrew Zigler: Amazing. We'll, we'll include those, uh, links with our show notes and also in our newsletter that we include with all of these episodes because, you know, if you're listening to this and you made it this far, maybe you're watching us on YouTube or listening to us on Spotify or Apple, definitely be sure to give us a like or a subscribe wherever you're listening.
[00:45:43] Andrew Zigler: Drop a comment as well. But definitely come and find Manik and I online, tag us, share your opinion, bring us into some of the projects you're working on or how- to show us how you're using MCP or A2A. Uh, we would love to hear from you based on our conversation today, so definitely be sure to tune in, uh, and be sure to follow [00:46:00] Manik online as well.
[00:46:01] Andrew Zigler: So Manik, thanks again for coming on Dev Interrupted. It has been a total blast hosting you. I'm gonna have to have you again very soon on the show, or maybe we'll see each other on the road, 'cause I know there's lots of events on the horizon for you. Um, so it's been really great chatting.
[00:46:15] Manik Surtani: Absolutely. Thank you again for hosting me. This has been fun.
[00:46:18] Andrew Zigler: Thank you.
