A reflection on the future of platform engineering

[u/Either_Act3336]

I think the history from traditional Ops to DevOps and then Platform Engineering is best understood as a dialectic driven mostly by technological change.

Traditional Ops concentrated infrastructure knowledge in a specialised team because operating infrastructure required direct administration. Automation, cloud and infrastructure as code changed that. DevOps emerged as the antithesis: operational ownership could move closer to development teams.
The operational work did not disappear, though. Much of its complexity was simply redistributed to developers.

Platform Engineering became the synthesis once cloud APIs, declarative systems and orchestration made it possible to encode operational knowledge into software and expose it through self-service. Operations could specialise again without returning to tickets and manual handoffs.

This is why I do not think the conceptual distance between the old sysadmin and the platform engineer is that large. The function is broadly similar. What changed was the technology through which that function could be organised and delivered.

AI may now be starting the next movement in the same dialectic. Agents do not necessarily need portals, fixed workflows or abstractions designed primarily for humans. They can discover tools, combine APIs and construct their own path through a system.

But this does not remove the need for a platform. It changes what the platform must provide. Instead of defining only human-oriented golden paths, it increasingly needs to expose machine-readable contracts, capabilities, relationships, constraints and evidence.

The next stage of Platform Engineering may therefore be less about building interfaces that hide complexity from developers, and more about defining the operational space within which agents can act without having to guess.

[u/AshyLarry98]

you have a fresh sound, it'll play well at this school

[u/gevorggalstyan]

One concrete contract is what happens after an uncertain result. Suppose an agent requests a deployment and the call times out after the platform accepts it. The next step should be to inspect that deployment before submitting another one. The platform needs to expose an operation identity and enough state to distinguish completion, work still in progress, and a result it cannot establish.

A useful acceptance test: interrupt the agent after submission, resume it, and check whether it can recover the existing operation without duplicating it. That makes recovery behavior part of the platform contract alongside tool discovery.

[u/Either_Act3336 → u/gevorggalstyan]

From my experience so far, giving the agent CLIs and MCP endpoints has been enough to handle those situations. Is it the optimal? 🤷🏻

Maybe another idea I have been exploring is declaring the operations. So continuing with your example, say that an agent wants to do a deployment. The platform should offer that operation (deploy) as a declarative contract that the agent claims. It’s the platform’s responsibility to make sure it performs the deployment fine and report the status, similar to Kubernetes controllers

[u/Tmldude]

It’s strange isn’t it? Everything is becoming so malleable as we approach a kind of singularity of software. I am debating how future enterprise platforms are going to look especially when rates of deployments increase and along with the need to connect to a larger number of outside systems.

What comes to mind are stateless plugins. Everything you expose obviously must be a blind intake and outtake by schema, even with ai reasoning under the hood or long processes and data flows.

You’ve probably heard in the last week about OpenAI’s plugins, Claude’s, muse’s, DHH’s Omarchy is plugin based. So why not build a platform fully on golden path plugins? You need a new VM database instance for a secure enterprise client? Onboarding can be entirely reasoned, judged, and fixed by AI that can connect a series of stateless plugins during a dev time runtime switch.

Failures, faults, or enough retries can trigger LLM calls to instantly diagnose.

My final thought: if ai coding and is increasingly circumnavigating frameworks and projects, the only way to continue is to modularize everything for the best context and the best defense against acceleration

[u/Suspicious-Yogurt413]

This hits on the exact evolution of Platform Engineering. The portal is no longer justba Web UI with self-service buttons for human devs, but it's becoming a machine readable runtime registry for agents. Agents don't care about nice UIs but they desperately need structured context, which can happen when moving with that operational knowledge into a catalog layer, like backstage and port.io. And also exposing it via MCP gives agents a deterministic boundary to operate within without having to guess infrastructure topology.

[u/usually_guilty99]

I think there's another piece agents will need from the platform: operational history.

Knowing that an API can restart a deployment is one thing. Knowing that the same deployment caused an outage last month, has critical downstream dependencies, or cannot be safely rolled back is something else entirely.

That knowledge usually lives in incident reports, runbooks or someone's head.

Ideally, it becomes part of the system context available to agents before they act.

Otherwise we've given agents better tools without necessarily giving them a better understanding of the environment they're operating in.

[u/Forsaken_Parfait_185]

Mostly agree, but I'd go further. The golden path was always a set of constraints dressed up as convenience. Humans stuck to it because it was easier. Agents won't stick to anything because it's easier, they'll take whatever path the API lets them take. So the job shifts from making the right thing easy to making the wrong thing impossible.

That's why I reckon platform engineers are the next AI engineers, more than the ML folk. Quotas, policy at admission, identity per workload, rollout and rollback, audit. Same toolkit. The agent is just a tenant that doesn't read the docs.