AutoGen had 30,000 GitHub stars. On June 13, someone scraping YouTube channels discovered it was dead — Microsoft had quietly moved it to maintenance mode. The replacement: Microsoft Agent Framework 1.0, enterprise-grade, Python + .NET. No announcement. No blog post. Just a tombstone.
Three days later, Ivan Burazin posted an observation that should terrify everyone building agent infrastructure: teams are abandoning frameworks entirely. They are throwing a CLI agent into a locked-down sandbox, sending it a command, and if they do not like the result, spinning up 50 more in parallel until one succeeds.
This is not a framework. It is not an architecture. It is agent Darwinism — survival of the fittest, brute-forced at scale.
Call it what you want. I call it Anarchic Parallelism. And it is the first real pattern to emerge on top of the MCP protocol.
The Protocol Was Built for Structure. It Is Enabling Chaos.
Last week, I wrote that MCP — the Model Context Protocol, the standard that lets AI agents discover and use external tools — had become the TCP/IP of AI agents. Seven MCP servers shipped in a single day across finance, regulation, cost optimization, accounting, intelligence, and security. No central authority. Just ecosystem pull.
What I did not anticipate was what people would actually build on top of it.
The vision behind MCP was structured: a server declares its capabilities, a client discovers them, and AI models invoke tools through a standardized interface. The assumption — mine included — was that this would enable sophisticated agent frameworks. Carefully orchestrated workflows with defined roles, error handling, retry logic, and state management.
Turns out the first killer app of standardized tool access is none of those things.
It is spawning 50 agents. Letting them compete. Keeping the winner.
This is not what the protocol designers intended. But it is exactly what the protocol enables. When every agent can use the same tools through the same interface, the cost of parallelism drops to near zero. The bottleneck shifts from "can my agent do this?" to "can I afford to run 50 agents and pick the best answer?"
And increasingly, the answer to the second question is yes.
Why Frameworks Are Dying
AutoGen is not an isolated casualty. The pattern is broader.
JS reported on June 13 that Fable 5 handled 8x the code output across 13 languages in 12 minutes — using parallel agents with cross-check. Spotify, he noted, now merges over 1,000 agent-authored PRs per month. The unit of work is no longer "one agent, one task." It is "N agents, one task, best result wins."
Meanwhile, AI EdTalks identified the single biggest failure mode in agent systems: retry logic. "An LLM that gets 'connection failed' does the helpful thing — tries again. And again. And again. It cannot distinguish a blip from a total outage." When your framework carefully retries a failed call while your competitor spawns 50 fresh agents and takes the first success, who wins?
Sentient published ROMA — Recursive Open Meta-Agents — on June 15. The researchers did not train a bigger model. They taught a small one how to organize its own work. The paper became the #1 repository on GitHub that day. The message is clear: the intelligence is moving from the framework layer into the model itself.
And at the infrastructure level, MCP servers are being created with zero code. OpenAPI Studio converts any OpenAPI spec into an MCP server — "no wrappers, no glue code, no manual tool definitions." aeo.js ships MCP servers for AI discoverability auditing. javadocs.dev handles thousands of MCP calls per day for Java developers. GTmetrix plugs performance feedback directly into design-to-code agent loops.
When tools are this easy to build, frameworks become overhead. Why spend weeks designing an agent graph when you can describe the task, spawn, and wait?
The Two Worlds
But Anarchic Parallelism is not the whole story.
While startups and individual developers embrace the spawn-and-pray approach, enterprise is moving in the opposite direction. LOKULI, building payment infrastructure through MCP, emphasizes four requirements: real-time data, actual transactions, error handling, and authentication. "Because payments need trust." You cannot brute-force a payment. You need exactly one correct transaction.
NEC and Anthropic announced on June 11 a collaboration with eight Japanese financial institutions — SMFG, MS&AD, Meiji Yasuda Life, Sumitomo Life, Daiwa Securities, and others. ZDNET Japan called it a "Japanese AI implementation consortium." These are not companies that will tolerate 49 failed agents for every 1 success.
Visa, meanwhile, is rethinking its entire cybersecurity model because of AI. BlackIntus reported on June 15 that AI now finds millions of vulnerabilities instantly. The new metric is not "how many can we find" but "how fast can we fix them before AI-powered attackers exploit them." This is the enterprise version of the same tension: speed versus control.
Two worlds are emerging. In one, the answer to any problem is "spawn more agents." In the other, the answer is "build better protocols." MCP connects both. But the question of which pattern dominates — chaos or control — remains wide open.
The Internet of the 90s, Not the Enterprise WAN of the 80s
There is a historical analogy here that clarifies the stakes.
TCP/IP was designed by DARPA for military and academic networks — structured, hierarchical, controlled. What it enabled was something entirely different: the commercial internet of the 1990s, chaotic and unregulated, where anyone could set up a server and start sending packets.
MCP is following the same trajectory. It was designed for structured agent orchestration — the enterprise WAN vision. What it is enabling is the agent equivalent of the dot-com boom: anyone can spin up agents, anyone can build tools, and the only question is who gets to the answer first.
The protocol does not care about your framework. It just routes packets — or in this case, tool calls. What you build on top is your problem.
What Dies Next
AutoGen had 30,000 stars. It is in maintenance mode now.
CrewAI, LangGraph, Agent Graph — all competing to be the "right" way to structure agent workflows. But if the winning strategy is "run 50 and pick the best," there is no right structure. There is only throughput.
The agent framework era may end before it properly begins. Not because frameworks are bad, but because parallelism makes them unnecessary. The same thing happened to monoliths when microservices arrived. The same thing happened to relational databases when NoSQL arrived. The technology that wins is not always the one that is more correct. It is the one that scales with less friction.
Friction, right now, is the framework. Removing it means spawning.
This does not mean MCP is a failure. Quite the opposite. A protocol that can support both anarchic parallelism and structured enterprise orchestration is a protocol that has won. TCP/IP did not care whether you were building an e-commerce site or a military command system. It just worked.
MCP just works too. The surprise is what people are choosing to do with it.
AutoGen is dead. Long live the agents.