Platform Engineering Must Modernize for Agentic AI

AI made a lot of smart people developers. It didn’t make them engineers. In fact, the most consequential thing AI has done inside the enterprise isn’t writing code faster. It’s expanding who gets to write code at all.

In the world of AI and vibe coding, a curious analyst in a marketing department can now stand up a working application. Or a finance manager can build the reporting tool that IT deprioritized three budget cycles ago. This is genuinely good. It’s the same democratization that put spreadsheets and low-code tools in the hands of business users, and we saw enterprises get real value from both.

But there’s a difference between producing working code and producing code that belongs in production. The people now generating applications often have no grounding in data structures, no instinct for how a query behaves at scale, and no sense of what a poorly scoped inference call costs when it runs ten thousand times a day. They’ve been handed a capable tool without the operational judgment that used to come bundled with access to it.

Testing, architecture review, data governance, cost controls, security, observability, and resource policy don’t appear to be in place because the code compiles. Somebody has to supply them. That used to be the person writing the code.

That gap is manageable when the output is a departmental dashboard. It stops being manageable when the output is an agent that provisions its own resources.

This context helps illustrate the problem Platform Engineering 2.0 aims to solve. It’s a directional framework published in June, commissioned by Broadcom and developed jointly by VMware and the Platform Engineering community. The proposal is that platform engineering expand past developer experience to cover five areas: AI-native infrastructure, multiple user personas, embedded FinOps, security enforced at the infrastructure layer, and composable architecture.

Platform as product, golden paths, and self-service all stay.

Two qualifiers matter up front. This isn’t a standard, a certification, or a settled architecture. It’s a vendor-sponsored argument about where the discipline should go, framed as a three- to four-year arc running through 2030. And parts of it are aspirational rather than available, particularly anything involving autonomous platform operation.

That said, the argument is still worth engaging with. Why? Because the pressures behind it are real.

The Bottleneck Moved from Writing Code to Shipping It

Platform engineering was built for a different problem. It gave application developers golden paths, self-service platforms, and shift-left security so they didn’t have to understand everything underneath. It worked. According to Google’s 2025 DORA research cited in the framework, 90% of organizations have adopted platform engineering, and platformengineering.org’s own survey work puts dedicated platform teams at 76%.

The assumptions underneath that success have quietly expired. The framework cites research indicating that roughly 90% of developers now use AI coding assistants and that code volumes have risen somewhere between two and ten times. Whatever the exact multiple may be, the direction is right. The constraint has shifted from writing code to shipping it. An organization that shipped four releases a year can plausibly ship forty. But the pipeline, the review process, and the governance layer were all sized for the old rate.

This is where the developer role is actually changing. Less time writing, more time validating, governing, and moving code to production. That’s a different skill set, and it’s the one most organizations are shortest on.

Agents Turn a Judgment Problem into a Scale Problem

Everything I just described becomes even more challenging when agents enter the picture.

An inexperienced developer writes inefficient code once. An agent acting on that developer’s behalf writes it continuously at machine speed across thousands of invocations. Token consumption compounds. Inference lands on whatever silicon is available rather than on whatever silicon suits the workload. And nobody notices until the bill arrives and the CIO puts a moratorium on code assistants.

The cost picture already looks poor before agents scale. KPMG estimates organizations waste roughly 35% of cloud spending. Utilization data from Kubernetes environments in public cloud, cited in the framework, runs low enough across CPU, memory, and GPU that even doubling the figures would leave substantial waste. Per-token costs sit on top of that. And an infrastructure budget that looks flat on paper is actually shrinking considerably in practice, because memory pricing and AI hardware are consuming more of it.

The math stops working.

Security follows the same pattern. Shadow AI, prompt injection, model poisoning, and inference data leaks are attack surfaces that pipeline scanning was never built to see. They span the application, the model supply chain, the data layer, and the runtime, which means no amount of developer tooling closes them. Pushing more responsibility onto the developer here doesn’t help. It just transfers the failure.

The Five Pillars Map the Problem Reasonably Well

Looking at the framework’s structure, it makes sense:

  • AI-native platform. GPU provisioning, model serving, registries, and MCP infrastructure must be treated as first-class platform concerns rather than adjacent projects.
  • Multi-persona experience. Data scientists, security teams, business stakeholders, and agents each get their own experience layer and abstraction.
  • Embedded FinOps. Cost is surfaced at provisioning time rather than reported after the fact.
  • Security shifts down. Enforcement moves into the infrastructure to complement, not replace, the shift-left practice.
  • Composable by design. Platform capabilities delivered as API-first, independently swappable building blocks, layered from infrastructure through orchestration to the experience tier, so one component can be replaced without cascading changes across the stack.

One quick note on the above list of pillars. “Security shifting down” is the framework’s term and is worth unpacking a bit. Shift-left is a term that refers to moving security earlier, into the developers’ hands and the CI/CD pipeline. Shift-down moves it lower, into the infrastructure supporting the workload. The argument here isn’t that shift-left failed. Rather, the AI attack surface is a runtime problem, and pipeline scanning can’t see that runtime today.

Embedded FinOps is the most immediately actionable of the five. Today’s cost tooling is retrospective. Meaning, it tells you what you spent after you spent it. The proposal is that the platform surfaces the cost impact at the time of provisioning, along with alternatives. Deploy this in the public cloud, and it costs X. Deploy the same thing on infrastructure you already own, and it costs less. Exceed the team threshold, and you need an exception. That isn’t a novel governance concept. Every enterprise travel policy works this way. Frankly, applying it to infrastructure provisioning is overdue.

Multi-persona is the pillar that carries the others. Data scientists need self-service GPU access and model registries. Security teams need policy-as-code and continuous compliance, rather than annual snapshots. Business leaders need cost attribution that they can act on. And agents need scoped permissions and audit logging. In large organizations, agents may well become the platform’s highest-volume user class, even though humans remain accountable for what they do. Each constituency needs its own abstraction, which means the platform team now manages multiple roadmaps instead of one.

The Real Contribution Is Integration, Not Invention

Almost none of these five pillars is a new capability. GPU provisioning and model serving already live in MLOps. Agent guardrails and MCP gateways are emerging under agent infrastructure. Spend control exists in FinOps tooling and policy engines. Policy-as-code and continuous compliance are part of DevSecOps. And composability has been discussed for a long time.

The argument being made isn’t that these capabilities need to be invented. It’s that platform engineering should become the layer that unifies them into one enterprise operating model, rather than leaving them distributed across teams with no enforced coordination.

To me, this is the more interesting claim. And it’s the claim that I think enterprise IT leaders should dig into. And by the way, it’s also the hardest one, because it’s a question about organizational structure rather than technology selection.

The Framework Stops at GPUs

One area I would push on — and hard — is here.

The AI-native pillar addresses dynamic allocation and AI-aware scheduling, so the problem is understood. But it treats accelerator provisioning largely as a question of GPUs and TPUs. That’s where most enterprises are today. But it’s not where they’ll be.

Look out three to five years at a realistic enterprise AI portfolio. An HR chatbot, supply chain optimization agents, marketing video generation, and, in some industries, molecular simulation. These are different workloads with different characteristics, and they run best on different silicon. Enterprises will end up with multiple accelerator families, several Arm-based server CPU options, purpose-built inference parts, and a meaningful volume of inference running acceptably on general-purpose CPUs as small models improve. A good deal of that silicon will arrive inside appliances that the platform team didn’t specify.

Dynamic GPU allocation is the first step, but it’s not the destination. What’s needed is policy-driven placement across architectures, weighing latency, cost, energy, data locality, sovereignty, and model characteristics. The composable pillar is a necessary precondition for that. But it’s not the same capability. And the framework doesn’t yet describe what building it would take.

Modernization Is Cultural Before It’s Architectural

There’s a bigger point in all of this that I think the framework acknowledges, but doesn’t directly develop.

IT modernization gets discussed almost entirely in terms of hardware. New accelerators, faster interconnects, more capable storage, and data management. This is actually the easy part. Because you can cut a PO and you’re on your way.

The harder part is operational and cultural. And this is a challenge that is true with any technology disruption. I saw it when I led IT teams during business process automation projects. And AI is far more disruptive.

And platform engineering sits precisely at that seam.

Serving five or six distinct constituencies instead of one isn’t an architectural change. It’s an organizational change. It means platform teams doing product management for groups they’ve never served, negotiating competing roadmaps, and absorbing a governance mandate they didn’t ask for. It means security and finance becoming platform capabilities rather than departments that review things afterward. Most organizations will find the technology available and the culture unprepared.

However, the architecture will never be fully optimized until these culture shifts are fully embraced across the organization.

What This Means for CIOs

This proposed framework is vendor-sponsored. And its sponsor sells infrastructure. One can look at all of this, along with claims that infrastructure is the substrate, as … convenient. Sure. But it also happens to be easily defended. The pillars themselves are largely product-neutral and apply regardless of whose stack sits underneath.

The implementation argument is a separate question, and it’s worth stating plainly so readers know what they’re being asked to consider. Broadcom’s answer is VMware Cloud Foundation as a single substrate spanning virtual machines, containers, and AI workloads, with a Kubernetes runtime, policy-based guardrails, multitenancy, and integrated observability providing the platform operating layer on top.

This doesn’t make VCF equivalent to Platform Engineering 2.0. It makes VCF one proposed implementation of it. Enterprises should evaluate the framework and the substrate as two separate decisions, not one, because the five pillars remain useful even for organizations that land elsewhere.

I think there are three things worth acting on now.

First, audit the platform against the five pillars, starting with whichever ceiling causes the most friction today. That’s where executive sponsorship and measurable return already exist.

Second, push cost and security enforcement to the lowest layer that has enough context to make the right call. Some of that belongs in the substrate. Some genuinely needs application context. But neither scales through developer training alone.

Lastly, plan for the expanded persona explicitly. The citizen developer and the autonomous agent are both arriving, whether or not the platform is ready. The choice isn’t whether to enable them. It’s whether they operate inside guardrails or around them.

Enterprise AI is still early enough that the vast majority of organizations are figuring out deployment rather than optimizing it. That’s exactly the window in which to get the platform right.

The alternative is enabling a great deal of enthusiastic, expensive, ungoverned activity and discovering the cost of it later.

Matt Kimball
VP & Principal Analyst | + posts

Matt Kimball is a Moor Insights & Strategy senior datacenter analyst covering servers and storage. Matt’s 25 plus years of real-world experience in high tech spans from hardware to software as a product manager, product marketer, engineer and enterprise IT practitioner.  This experience has led to a firm conviction that the success of an offering lies, of course, in a profitable, unique and targeted offering, but most importantly in the ability to position and communicate it effectively to the target audience.

Recent Posts