Enterprise Agent Platforms Converge Without a Portability Contract

Key takeaways

1. Core idea: three hyperscalers, one architecture. In 9 months, Amazon, Microsoft, and Google have converged on the same six primitives for enterprise agents — runtime, memory, tool gateway, identity, observability, governance — under different brands. What was a fragmented collection of libraries 18 months ago is becoming a platform layer in its own right.
2. The gap: no contract, so no portability. Convergence of components does not produce portability. What's missing is the contract (in the PaaS sense) that would make an agent agnostic about where it runs. Today, session state, traces, and identity all end up with a single provider; moving the agent a year later means rebuilding everything.
3. The guiding analogy: PaaS 2011-2016. Before Cloud Foundry / Heroku, teams assembled VMs, load balancers, queues, secret stores, and monitoring agents, each with its own API. PaaS unified all of that around an application contract: "the app declares what it needs and stays agnostic about where it runs." What mattered was the contract, not the implementation.
4. Cloud Foundry lesson: the contract outlives the platform. Cloud Foundry did not win the market (Kubernetes did), but its principles traveled: buildpacks born at Heroku (2011) → Cloud Native Buildpacks (Pivotal+Heroku, Jan. 2018, accepted into the CNCF in October); the Cloud Foundry abstraction rebuilt on K8s via Korifi. Companies on that foundation in 2016 had a portability that most agent teams cannot buy today.
5. The three platforms, stripped of marketing. (1) AgentCore (GA Oct. 2025): 7 composable services (runtime, gateway, memory, browser, code interpreter, identity, observability); runtime = isolated 8-hour execution windows; gateway plugs in existing MCP servers; observability exported via OpenTelemetry to CloudWatch. (2) Microsoft Foundry (renamed from Azure AI Foundry on Jan. 1, 2026): managed runtime isolated per session, Entra Agent ID identity, session/user/procedural memory, OpenTelemetry tracing. (3) Gemini Enterprise Agent Platform (Vertex AI name dropped at Cloud Next 2026): Agent Engine → Deployments, plus Memory Bank, Sessions, Agent Registry, Policies, Gateways.
6. Convergence isn't a conspiracy, it's the margin. Infrastructure companies build vertically integrated platforms because "integration is where the margin is." The consequence falls on the customer: identity, telemetry, and deployment end up with a single provider → the operational layer beneath the agent is what resists migration.
7. The contract mapping (table, reusable for due diligence). 8 rows "PaaS abstraction → agent equivalent → where portability breaks": app source → code+instructions+eval suite (each framework has its own package format); buildpack → framework detection+packaging (no shared build contract across SDKs); backing service → model/memory/retrieval/tool (providers wired into the logic); service binding → authenticated attachment (credentials issued by the host cloud); router → MCP/A2A endpoint (the protocols exist, not the lifecycle); logs → traces/tool calls/cost/quality (GenAI conventions still in development); release promotion → evaluate/version/progressively deploy (eval coupled to a vendor harness); policy → identity/permissions/approvals (identity tied to the provider's directory).
8. Three design principles. (1) Package the agent as one deployable unit: code, instructions, tool dependencies, memory contract, permissions, and eval suite travel together or not at all. AWS comes close with its harness export (one command → Strands code preserving model, prompt, tools, memory, container), "the right instinct, pointed at a single cloud." (2) Attach rather than embed (the Twelve-Factor lesson): models, memory, retrieval, browsers, gateways = resources attached via config. "An agent that names its model provider in its application logic has already given up portability." (3) Integrate the operational layer into the abstraction: the right agent questions are whether the agent accomplished the task, chose the right tools, exceeded its authority, at what cost, and whether quality regressed after a model update.
9. An agent is not a web app with a model grafted on. Three differences carry all the weight: probabilistic behavior (same inputs → different tool calls); delegated authority from the user (a permissions bug becomes a real side effect, not an error page); dependencies change behavior without a code deployment (a model update or a revised tool description changes what the agent decides). The Twelve-Factor "stateless process" rule doesn't survive here: it requires disposable workers plus durable, inspectable, portable state. LangGraph demonstrates this in open source (checkpointing at every step, human interruptions, crash recovery) — but its control plane sits in the commercial product LangSmith: the fragmentation shows up within a single project.
10. What open protocols leave out of scope: the lifecycle. MCP (tool/data access), A2A (inter-agent discovery/communication), OpenTelemetry (GenAI conventions, most attributes still "in development"), OCI images (a packaging escape hatch): almost all the primitives exist. But a foundation that governs how agents talk to tools says nothing about how to version an agent, promote it across environments, or roll it back when an eval regresses. Protocols ≠ lifecycle platform.
11. The vendors' concession signal. The Linux Foundation announced the Agentic AI Foundation (December 2025); founding projects: MCP (Anthropic), goose (Block), AGENTS.md (OpenAI); AWS, Google, and Microsoft as platinum members; Google contributed A2A to the Linux Foundation. The hyperscalers admit that a neutral layer matters.
12. Three due diligence questions (to keep in mind when choosing an agent platform). (1) Governance: is the project controlled by a neutral foundation or by the vendor selling the managed version? (2) Packaging: does the same artifact run on two clouds without rewriting? (3) State: does the memory live somewhere exportable by the enterprise? No open project answers all three today.
13. The final stakes: whoever owns the control plane owns the definition. Just as Kubernetes defined pods/deployments/services and shaped the thinking of an entire industry, the agent equivalent is not yet settled. Whoever ends up owning the agent control plane won't just own deployment: they will define what an agent is, what components it contains, what a platform team is allowed to replace. A neutral project would give enterprises back the negotiating power that buildpacks and service brokers once gave them — to the benefit of vendors as much as buyers.
14. Related. "The Development Environment Is The Next Layer To Collapse" (Greyling) and "Building for trillions of agents" (Levie) on agent layers; agent identity (Uber Engineering entry, zero-trust/SPIRE) — the same delegated-identity problem handled on the infra side; the sovereignty / reversibility / Design to Exit family (ZML/LLMD entry) — the same logic of "paying upfront for the layer that makes the provider replaceable," transposed from silicon to the agent control plane.