Every team building with agents is betting on standards it doesn’t control. Whether those bets pay off depends less on any single protocol than on who stewards it, and whether the rest of the industry trusts that steward enough to build on top.
Manik Surtani, CTO and co-founder of the Agentic AI Foundation (AAIF), joined Dev Interrupted to talk about that trust and what it unlocks. Before AAIF, he led open source at Block. The foundation he helped build now houses MCP, A2A, goose, AGENTS.md, and agentgateway. His conversation offers a map of where agentic standards are heading, why vendor neutrality is load-bearing, and how engineering work is about to change shape.
A ten-seat ambassador program drew 150 qualified applicants
The AAIF ambassador program was meant to start small. The plan called for ten seats, an arbitrary number with room to grow later, and a scoring system that ranked community organizers by what they had actually shipped. Then more than 150 applicants came back scoring above 95 percent. Choosing ten from that pool was impossible, so the cap came off and the program launched with roughly 140 ambassadors on day one.
Surtani describes the response as incredible and overwhelming in equal measure. No marketing push produced it. It was grassroots demand for neutral governance of the standards agents run on, the kind of pull money can’t manufacture. The same signal shows up in the projects themselves, as initiatives with different origins and different problem spaces choose to live under shared governance.
Neutral governance exists to prevent the rug pull
The case for that governance came from experience. When goose was gaining adoption at Block, competitors and distributors like Red Hat wanted to use and repackage it, and they kept stopping short. The Apache license wasn’t the obstacle. Ownership was. “They couldn’t trust the roadmap. They weren’t guaranteed that there wouldn’t be a rug pull or something like that,” Surtani recalls. Without a neutral home, no downstream party could commit.
AAIF is designed to remove that fear by guaranteeing that no single vendor can redraw a project’s roadmap on its own. When David Soria Parra at Anthropic saw the same dynamic playing out with MCP, the two efforts joined forces. The growth that followed has looked like a hockey stick almost everywhere. Adoption of goose grew exponentially once the foundation formed, which was expected. The surprise was MCP, an already-dominant protocol that still found another gear. The same curve showed up for agentgateway, and A2A has the runway to follow.
Rival vendors’ standards can share one roof
A2A arrived at AAIF with most of the hard work already done. Google had donated it to the Linux Foundation months before AAIF existed, so it came with real governance and a track record of being run well. Bringing it in was less an act of construction than of recognition.
What matters more is what its presence alongside MCP shows. Some see the two as competing standards, but they address different needs (MCP connects agents to tools and data, while A2A connects agents to each other) and freely borrow ideas from one another. Hosting both, regardless of whether a project traces back to Google or Anthropic, is the clearest proof of vendor neutrality the foundation could offer. In Surtani’s words, “It also breaks any of the preconceived notions that this is an Anthropic foundation. It’s not. It is an open source foundation.”
Practitioners are already bending A2A to fit their own orchestration needs, extending the spec into custom protocols where agents make and keep commitments to one another. What stands out is how readily the agents themselves pick up the spec and conform it to what a team requires.
A stateless MCP puts state where teams can manage it
The 2026-07-28 MCP specification came straight out of community pain points. People wanted deployment and management simplified, and the project listened. It was deliberately not labeled 1.0, since that number would misrepresent what kind of spec it is. That responsiveness, more than any single feature, is what keeps MCP close to the people using it.
Statelessness is the headline change, and it’s easy to misread. “Just because the protocol is stateless doesn’t mean there’s no state,” as Surtani puts it. State still has to live somewhere. The spec moves that responsibility into the application layer, which turns out to be a good place to manage it and gives teams more control rather than less. Adoption suggests the change is landing. The MCP SDKs have now passed a billion downloads by his count, roughly five times the volume of eight months earlier.
Large organizations are still finding the patterns
Inside big engineering organizations, MCP is becoming connective tissue. Pockets of agentic experimentation form, start sharing capabilities, and then other departments want in. There is no standardized pattern for this yet. One department might run its own agents and lean on A2A to coordinate with another, package its work as a shareable agent skill, and expose its data as MCP endpoints so information flows across teams. It’s still the Wild West, and the honest posture is admitting the patterns haven’t been figured out.
Gateway tooling like agentgateway supplies some of the missing visibility, giving teams model independence and a clear view of token spend at a moment when the best model for a task can change vendors overnight. That visibility is also what makes measuring the returns on AI workflows possible. The right starting mindset is skeptical. Assume any workflow might deliver zero value, avoid growing attached to it, and stay ready to scrap or transform it. Change is cheap and fast right now, but letting go intelligently requires knowing what’s working. Pinning metadata to API requests and tying discrete tasks to their inference costs can reveal, for example, that most spend is going into brainstorming rather than execution. No PR count could surface that.
Software factories will turn engineers into foremen
Surtani is bullish on the software factory, where the middle of the SDLC automates end to end and humans anchor ideation and verification at either end. It isn’t here broadly yet, but it already exists in constrained pockets, and the direction of travel is clear. Engineers become something closer to factory foremen. History rhymes here. Programmers once wrote machine code and dismissed high-level languages as dumbing down the craft, yet that abstraction was the step that made scale possible. “The programming bit is not that important actually. The engineering side is much broader than just programming,” he says.
The tooling for that shift barely exists. GitHub was built for human-scale pull requests. It wasn’t designed to track the prompts that produced an outcome, to host adversarial workflows where different LLMs critique each other toward the best answer, or to give a human reviewer an audit trail through an agent’s reasoning, decision points, and abandoned paths. The Git forge is overdue for a rebirth. Beyond building software lies the unsolved territory of deploying and running it, where short-lived tokens, revocable access, and verification against hallucination all demand new infrastructure.
When code is nearly free, judgment is the job
Open source isn’t waiting for that infrastructure to arrive. Maintainers are already contending with a flood of low-quality automated PRs, which some have taken to calling “slop cannons.” Some projects, goose among them, have stopped accepting PRs entirely and instead ask for well-written issues an agent can pick up and build. The value has moved from code to ideas.
That relocation is the thread running through all of it. With code nearly free, the scarce inputs are judgment, alignment, and the ability to curate the slop out before it festers. Engineering leaders who adapt will measure token spend and task outcomes rather than counting merged PRs. They’ll also stay willing to sunset their own work and rally behind a project with more momentum, as Cisco did when its AGNTCY project set aside its own agent protocol and built on A2A instead.
Maintainers who thrive will build communities around shared experience rather than code contributions, and the ambassador surge was an early look at what that looks like. More than 150 people showed up ready to organize around standards no single company owns, and a ten-seat plan couldn’t hold them. When nobody can pull the rug, people are willing to build on the floor.
To hear more from Manik Surtani on vendor-neutral governance, the evolution of MCP and A2A, and the rise of the software factory, listen to the full conversation on the Dev Interrupted podcast.
