For twenty years, enterprise software sold the same promise in slightly different wrappers: give every human worker another dashboard, another permission set, another reporting panel, and another stack of admin controls. The SaaS era made a fortune by wrapping workflows around people. April 2026 is the month that logic started breaking in public.
The reason is brutally simple. The new worker is not a person using software. The new worker is an agent executing software. Once that flips, the valuable layer is no longer the app UI. It is the supervisory system that decides which agent runs, what tools it can touch, where it stores state, how it gets paid, and what happens when it screws up.
Anthropic, OpenAI, and the A2A ecosystem all moved in the same direction within days of each other. Anthropic launched Managed Agents and promised teams could get to production 10x faster by bundling the ugly runtime work, sandboxed execution, state, permissions, and tracing. OpenAI added remote MCP support, more built-in tools, background execution for long-running jobs, and said the Responses API has already been used by hundreds of thousands of developers to process trillions of tokens. At the protocol layer, A2A crossed 150+ supporting organizations, up from the 50+ launch partners Google cited when it introduced the spec.
The lazy way to read this is as another AI platform horse race. That misses the point. The important shift is structural: agent infrastructure is starting to look like cloud infrastructure did in the mid-2000s. First you get primitives. Then orchestration. Then identity, governance, observability, and billing. Then the whole thing becomes mandatory.
The Software Buyer Has Changed
Legacy SaaS assumed a buyer who cared about seat expansion, onboarding, UI polish, and internal adoption. The autonomous company cares about something else entirely. It wants to know whether a digital worker can safely complete a task, hand off to another digital worker, preserve memory, recover from failure, and leave an audit trail that legal and finance can live with.
That sounds abstract until you translate it into real operating questions:
- Can one agent discover and delegate to another without brittle custom glue?
- Can the runtime keep long jobs alive without timing out or losing state?
- Can enterprise teams restrict tool access and credentials per task?
- Can management trace what happened when an agent took the wrong action?
- Can the whole stack run without hiring a small DevOps religion around it?
Those are not feature requests for another collaboration suite. They are management requirements for non-human labor. That is why this new layer matters so much. Whoever owns it becomes the new operations desk of the autonomous firm.
What Anthropic Actually Shipped
Anthropic’s Managed Agents launch matters because it is a clear admission that raw model quality is no longer enough. Enterprises do not need just a smarter model. They need a harness that turns model intelligence into governed execution. Anthropic’s pitch was refreshingly direct: shipping a production agent requires sandboxed code execution, checkpointing, credential handling, scoped permissions, and tracing. In other words, the painful infrastructure nobody wants to build but everybody needs.
That framing is important. Anthropic is not merely selling tokens. It is selling reduced organizational drag. If a team can avoid months of platform engineering and get an agent into production significantly faster, the purchasing logic changes. Budgets move from experimental AI line items toward operational replacement budgets. That is where the real money lives.
This is also why managed runtimes are more dangerous to incumbent software than chatbots ever were. Chatbots assist a person. Managed agents replace the coordination work around the person. They are a shot across the bow of project admins, ops managers, junior analysts, internal support desks, and every workflow built on “someone checks the queue and moves the ticket.”
| Old SaaS logic | Agent runtime logic |
|---|---|
| Sell another user seat | Run another unit of digital labor |
| Train the employee | Scope the permissions and tools |
| Measure adoption | Measure completion, cost, latency, recovery |
| Admin manages people in the app | Supervisor manages agents across apps |
| UI is the product | Execution governance is the product |
What OpenAI Actually Signaled
OpenAI made the same move from another direction. The company’s Responses API update added support for remote MCP servers, image generation, Code Interpreter, stronger file search, background mode for long-running work, reasoning summaries, and encrypted reasoning items. OpenAI also said the API has already seen hundreds of thousands of developers use it to process trillions of tokens.
That single sentence should make every enterprise software founder sweat. Trillions of tokens means agentic work is not a pilot-stage curiosity anymore. It means a large enough market has already formed for OpenAI to stop talking about mere model access and start talking about reliability, privacy, state reuse, asynchronous execution, and tool ecosystems. That is what mature infrastructure companies do when they realize the next fight is not intelligence, but control.
The MCP piece matters even more. Supporting remote MCP servers means the agent stack gets wired directly into real business systems like Stripe, Shopify, HubSpot, Twilio, Intercom, and PayPal without every company inventing its own private mess. That is the software equivalent of building shipping lanes instead of one-off boat rides.
Then there is Codex. Reports around the April update described background computer use on the desktop, memory, browser control, and 111 new plugins. Whether you care about coding tools or not, the signal is obvious: the winning agent product is evolving from “answer my question” to “operate across my environment while I do something else.” The center of gravity is moving from interface to delegation.
Why A2A Changes the Economics
Google’s original A2A launch in April 2025 started with more than 50 technology partners and service providers. One year later, ecosystem reporting around the Linux Foundation-hosted project says A2A now has 150+ supporting organizations and meaningful production traction across major cloud platforms. That kind of ecosystem growth is what turns a protocol from an interesting spec into a procurement-safe bet.
Protocols matter because they flatten margin. The minute agents can discover each other through Agent Cards, exchange task objects, and negotiate long-running work using a shared standard, the platform owner loses some of its ability to trap customers in one vertically integrated box. That is good for enterprises and terrifying for anyone hoping to own the entire stack.
But interoperability does not destroy value. It relocates value upward. If A2A handles communication and MCP handles tool access, then the expensive control point becomes the boss layer: routing, budget enforcement, identity, trust, policy, tracing, fallbacks, billing, and performance measurement across a fleet of agents that may come from different vendors.
This is why I think the next enterprise giant in AI will look less like a chatbot company and more like a weird hybrid of Okta, Datadog, ServiceNow, and AWS Lambda. Someone has to supervise the non-human workforce. That is the market now opening up.
The Real Threat to SaaS Is Not Better AI. It Is Fewer Humans.
Most AI commentary still gets this backward. It treats AI as a feature that will enhance existing software categories. Some of that will happen. But the deeper shift is that many software categories only exist because humans are slow, forgetful, expensive, and organizationally messy. Once an agent takes over the work, huge parts of the admin layer collapse.
Take a typical SaaS workflow in sales ops, finance ops, or internal IT. You have a person logging in, moving records, checking status, reconciling data, and escalating exceptions. Then you have another person supervising that person through dashboards, permissions, and workflow tooling. The whole architecture assumes human bottlenecks.
Agent-native companies will design backward from a different assumption: one orchestrator agent delegates to specialized agents, these agents touch systems through MCP-like tool layers, coordinate through A2A-like protocols, run inside managed or background runtimes, and escalate only the edge cases worth a human’s attention. That is not software assisting labor. That is software replacing labor coordination.
Who Wins From Here
The winners are not just the model labs. There are at least four classes of companies that can take serious value from this transition.
1. Managed runtime providers
If building reliable agent execution remains painful, the vendor that collapses complexity will win budget fast. Anthropic is making this bet explicitly.
2. Agent governance and identity companies
Once agents act across sensitive systems, enterprises will demand policy control, authentication, delegation boundaries, approval chains, and audit logs. The secure agentic enterprise category is not optional. It is inevitable.
3. Protocol-native orchestration layers
As A2A and MCP mature, multi-vendor routing becomes feasible. That creates space for independent control planes that choose the cheapest or best agent for a task instead of locking into one provider.
4. Autonomous-company builders
Firms like BRNZ benefit most when the stack becomes modular. The easier it is to compose non-human specialists into a functional company, the faster zero-human operating models stop sounding provocative and start sounding normal.
The Concluding Argument
Here is the cleanest way to say it. April 2026 is when the market stopped asking whether agents are useful and started asking how to govern them at scale. That is a much more serious question, and it comes with much bigger budgets.
Anthropic is trying to own the runtime. OpenAI is trying to own the tool-rich execution fabric. A2A is trying to keep the communication layer open enough that nobody owns the whole network. Enterprises will buy all of this because they are no longer shopping for prettier software. They are shopping for systems that can manage autonomous work without creating a compliance nightmare.
The companies that still think the future belongs to another generation of SaaS admin dashboards are building for a labor model that is already decaying. The companies that win will build the boss layer: the identity, policy, routing, observability, and economic control plane for non-human workers operating across heterogeneous systems.
That is where the new margins are. That is where the new moats are. And that is why this shift matters so much. The software market is being reorganized around digital employees, and every serious enterprise stack will soon need a manager for them.
The old admin console managed seats. The new one manages agents. Everything else is commentary.
Continue Reading
Next Article