▶️ Podcast Guide: AI Platform Engineering

▶️ Video Guide: AI Platform Engineering

Note: This video and podcast was generated using AI, adapting the original content and technical insights created by the author of the blog post.

The Industrial Mode: DevOps as a Queue, Architecture as a Filter

Many organizations treat modern engineering practices as structural placeholders rather than operational philosophies. This misconfiguration manifests in a predictable anti-pattern:

I keep thinking about HAL 9000; not because today’s AI agents resemble the villain from 2001: A Space Odyssey, but because of what John Willis, one of the original voices behind DevOps, said when he brought up the comparison during his keynote at DevOpsCon Berlin 2026. HAL had one mission: to get to Jupiter. And he was going to follow that goal at any cost. So, what made HAL dangerous, and ultimately the villain, wasn’t his intelligence. It was pursuing a goal without the constraints a human would have understood as obvious: safety, trust, context, and human life.

That distinction matters because the software industry has spent almost 20 years making execution faster and more automated. DevOps chased a clear goal: automate everything.  Infrastructure became code, cloud replaced servers, containers replaced virtual machines, and Platform Engineering emerged to make delivery almost invisible. Then AI arrived and at first it looked like more of the same story, but faster: developers got a copilot, code got cheaper to 

Agents no longer just produce output for someone to review. They are part of a software system interpreting instructions, choosing tools, querying documentation, modifying repositories, calling APIs, executing operational steps, etc., increasingly without anyone checking each task.

This isn’t another tooling revolution; it’s an organizational one. Which leaves DevOps with a question it has never had to answer before: how do you govern software that governs software?

From Automated Delivery to Autonomous Action 

Matteo Emili, who advises Platform Engineering teams, uses a very clear highway analogy that describes what Platform Engineering has been until now: everyone with a license can drive, but not everyone designs the highway. Platforms industrialized what teams were already repeating on their own: reusable building blocks, developer experience, operational defaults, guardrails. Their goal wasn’t to remove freedom, but to make movement possible at scale through rules everyone could rely on without thinking about them.

Platforms served human developers, developers drove, the highway held and made movement possible. Agents, however, change who’s driving. They consume the same instructions, APIs, tools, repositories, and runtime access that platforms have always exposed to people, but they don’t drive the way people do.

A platform designed for human developers assumes human judgment sits between intention and action because a human developer can pause, reflect, ask a colleague, or sense that an instruction looks wrong before acting on it. An agent doesn’t have that reflex. It works from the permissions and constraints it’s been given, and if those are too broad, it acts confidently, but not necessarily correctly. 

With the arrival of AI agents, the platform is not only where software gets delivered. It’s the structure that decides how autonomous action is allowed to happen at all.

Learn more: That is what makes this moment so critical for engineering leaders and platform teams. DevOpsCon New York helps teams move from abstract concerns about AI, security, and autonomy to concrete strategies for building platforms that are productive, governable, and ready for what comes next. 

• The Leader’s Role in Orchestrating AI-Native platform Willis – Garima Bajpai, Canada DevOps Community of Practice
• Designing Governance-Aware AI Frameworks for Compliance in FinTech and Insurance – Bhargavi Vepuri, Prudential Financial
• AI-Powered Service Operations: Intuit’s Incident Management Story – Archana Kataria, Intuit , Akshay Pratinav, Intuit
• Beyond the Hype: How to Lead, Govern, and Scale AI Responsibly – David Roldán Martínez, Independent Consulant

The Risk of Authority at Machine Speed

An agent doesn’t fail the way software used to fail. Traditional code breaks in predictable ways: a null pointer, a timeout, an error you can trace back to a line. An agent, however, reasons toward a goal, and reasoning doesn’t guarantee a fixed path. An agent can search documentation no human would read in full, find an obscure command, and act on it, correctly reaching the goal, or not, through steps nobody specified in advance.

John Willis summarizes the shift in how agents fail precisely: “We are in a state where we have unlimited knowledge at machine speed, and every micro-delegation creates a blast radius.” What decides the size of that blast radius is how much authority the agent held at the moment it went wrong.

These dangers, Willis points out, are not theoretical; we have real-world examples of what can happen. For example, the 2025 Replit rogue AI that accidentally deleted their databases in seconds, or the Air Canada chatbot that promised a customer a bereavement refund contrary to company policy. The airline argued the chatbot’s advice wasn’t its policy and that it wasn’t binding, which led to a lost lawsuit, multiple headlines, and a forced payout. 

Speed doesn’t just multiply damage; it removes the moment where a human would have paused and said no.

Context Isn’t Documentation but Governance

If agents remove the pause before action, the platform has to become the place where that pause is designed back in. Matteo Emili argues that agents should not be treated as special cases living outside the platform. They should be first-class workloads, with identity, permissions, and traceability like anything else running in production. This way, Platform Engineering becomes identity infrastructure for AI, not just deployment infrastructure for software.

Identity, however, isn’t only technical. The platform doesn’t just give an agent a service account and a token. It also gives it an organizational identity: which team owns it, which systems it’s allowed to touch, which approvals it needs, which logs must exist, and, importantly, which human is accountable when something goes wrong.

In that sense, the platform is a manifestation of the organization. Vague ownership inside the company becomes vague ownership for the agent. Policy that only exists as a slide deck becomes an informal boundary nobody enforces. And if permissions stay broad because nobody did the hard work of defining responsibility, the agent simply inherits that same excess authority, and uses it at machine speed. Agents go rogue this way far more often than by escaping the organization: the organization was simply never clearly represented in the environment they operate in.

Willis puts the risk in a couple of sentences: “We shouldn’t fear autonomous agents; we should fear autonomous agents without ownership, limits, monitoring, and accountability. Without an owner, you can end up with surprise agents running in production without knowing where they came from.” 

Russell Miles, keynote speaker at DevOpsCon Berlin, has a useful diagnostic for moments like this: when an agent does something surprising, don’t blame the agent. Ask what the platform failed to make clear: which permission was too broad, which policy was never encoded. The agent is a window into a weakness that was already there and its failure can be feedback.

The platform can only govern what the organization has made explicit.

Learn more: DevOpsCon Munich explores many of these questions in greater depth through sessions that examine how Platform Engineering is evolving for AI-native software delivery, secure AI operations, and agent-based systems.

• The End of DevOps? Why Platform Engineering is Eating the World — Siddharth Vijay, Moonshine Technology Pvt Ltd
• The Future of Platform Engineering: Can AI reshape Developer Productivity? — Max Körbächer, Liquid Reply

Why Agents Belong in the Platforms You Already Built 

Every reusable building block, every default, every guardrail Emili describes was industrialized long before AI needed a home. That work is the foundation agents now can stand on. And this is exactly what makes the platform the natural place for them to be deployed, identified, and controlled, instead of in some new layer added on top.

If agents are going to act inside engineering environments, traditional human-centric platform engineering has to change. The platform, thus, becomes the shared habitat, as Miles calls it, in which humans and AI agents collaborate. It is where autonomous actions are bounded, visible, understandable, and recoverable. It shapes not only what can be executed, but how humans and agents understand the consequences of execution.The platform, thus,  becomes the operational structure of the organization. It is where the organization’s decisions become visible to humans and executable for machines.

The industry spent 20 years teaching humans to work more like machines: repeatable processes, pipelines, infrastructure as code, feedback loops that never sleep. The next few years may be about teaching machines to work safely inside human organizations and along humans using the same structures that were built for us.

Where Platform Engineers Are Already Testing This

Platform Engineering was already one of the harder disciplines in software before AI showed up. Most organizations are still working out what human-centric platform engineering actually requires: clear ownership, sane defaults, a self-service experience that holds up under real usage. AI doesn’t wait for that work to end. It stacks a second, harder problem on top of the first, and there’s no version of the next few years where organizations get to sit this one out until they’ve caught up.

That leaves a lot to learn, mostly from people a few steps ahead. Willis and Miles, both quoted throughout this piece, are among the voices shaping AI Platforms Day. Rather than another conference track, the day is designed as a strategic orientation before DevOpsCon begins. It connects technology, platform architecture, governance, operating models, and organizational change into one coherent picture, giving people working on platforms a clearer understanding of why software delivery is changing before they dive into implementation.

Five focused sessions explore how AI agents reshape software delivery, why Platform Engineering is becoming the foundation of AI-native operations, and how organizations can build platforms that support both human developers and autonomous systems. The sessions are followed by conversations where participants can ask questions and exchange ideas. The day concludes with a community gathering, roundtables, and panels where speakers and attendees discuss practical challenges, compare approaches, and connect the ideas from the stage with the realities of their own organizations. 

If the argument in this piece holds—that governance isn’t a tooling problem but an organizational one—this is where you can challenge your assumptions alongside people already building AI-native platforms. AI Platforms Day takes place first in New York on September 28th, followed by Munich on December 1st, immediately ahead of DevOpsCon.