The month everything became an agent
April 2026: every major lab shipped agent products in the same four weeks, an API I depended on got deprecated, and MCP quietly won.
April was the month the plumbing became the story. Within four weeks, every major lab shipped agent products: Anthropic put Managed Agents into public beta, OpenAI updated its Agents SDK, Google rebranded its whole cloud AI stack into an agent platform, and Microsoft open-sourced a governance toolkit. If you only read headlines, it looked like four companies copying each other. Under the headlines, something more useful was happening: they were all converging on the same plug.
First, the word. “Agent” had been marketing soup for a year, so here is the practical definition I settled on: an agent is a model in a loop with tools. It can call a search, read a file, hit an API, look at the result, and decide what to do next. A classic retrieval pipeline fetches five text chunks because a config file says five. An agent retrieves because it decided it needs to, and stops when it has enough. The difference sounds philosophical and is not. It is the difference between a conveyor belt and an employee.
The part of April that cost me a weekend: OpenAI deprecated the Assistants API, which a prototype of mine at work was quietly built on. The replacement path led through MCP, the Model Context Protocol. I want to describe MCP carefully, because I ignored it for months and should not have.
MCP is a boring standard, in the best sense. It defines how a model-driven application talks to the outside world: here are my tools, here is how you call them, here is what comes back. Before it, every lab had its own way of wiring tools to models, and switching providers meant rewiring everything. After it, a tool server you write once works with any client that speaks the protocol. The numbers say how fast this happened: over 10,000 public MCP servers, governed by the Linux Foundation since December, with SDK downloads in the tens of millions per month.
Rebuilding the deprecated prototype took the weekend. Writing an MCP server for our internal ticket system took one additional afternoon, which surprised me. It is honestly not much more than describing what your tool can do in a fixed format and answering calls. The afternoon-sized effort is the whole point: standards win when the boring path is also the easy path. USB did not win because it was elegant.
What did I actually gain? My ticket tool now works from every AI client we use, including two I did not plan for. When we tested a cheaper model on a batch task last week, the tools came along for free. And the security conversation with IT got easier, because “it speaks a Linux Foundation standard with a spec you can read” lands better than “I wired it up myself, trust me”.
A caution from the same weekend, so this does not read like an ad: an agent in a loop with tools is also a new way to be wrong at higher speed. My first agentic version of the ticket tool happily created three tickets for one problem because it retried on a timeout that had actually succeeded. A fixed pipeline fails loudly and stops. An agent fails creatively and continues. You need tools that are safe to call twice, logs you can actually read, and permissions that assume mistakes. Microsoft shipping a governance toolkit in the same month as everyone’s agent launches was not a coincidence; it was a confession about where the bodies are.
By end of April my mental model of the field had quietly inverted. I used to think the models were the product and everything around them was glue. Now the models look interchangeable and the glue looks load-bearing. Model choice: a preference. Tool layer: an investment.