Spend the better part of a week at a conference like SUSECON, and you start to see patterns develop.
Not in the keynotes. Not even in the official messaging. It shows up in the conversations, the demos, the offhand comments people make when they’re talking about what’s actually happening inside their environments.
Teams are making real progress on their platforms. Onboarding is getting smoother. Service catalogs are less of a mess. Golden paths are starting to look like something you can trust instead of something you work around. There’s a level of maturity here that wasn’t there all that long ago.
And then, almost casually, someone mentions that an agent opened a pull request. Or that a pipeline kicked off on its own. Or that configuration showed up in the system without anyone sitting down to write it.
They don’t stop on it. They move on.
But if you’re paying attention, that’s the signal.
We’re still talking about Internal Developer Platforms as if the only user is a human developer, while something else is already using them every day.
Call it agents, automation, or just the next layer of abstraction. The label doesn’t matter as much as the behavior. Work is getting done without a person driving every step. Systems are interacting with systems in ways that used to require a human in the middle.
At SUSECON, that wasn’t framed as some future state. It was just there, woven into how people described their workflows. Agents calling APIs, assembling configurations, triggering deployments. Not replacing developers, but operating alongside them.
That’s the part that hasn’t fully sunk in yet.
Internal Developer Platforms were built with a clear goal: Make it easier for engineers to get work done without friction. Give them a portal, a catalog, some guardrails, and let them move. In a lot of organizations, that’s finally starting to work the way it was intended.
But it was all designed around a user who can interpret what they’re seeing.
A developer can look at a service entry, read a description, and figure out what to do next. If something isn’t obvious, they’ll check documentation or ask a question. There’s judgment involved. There’s context.
Machines don’t bring any of that with them.
An agent interacting with your platform isn’t browsing your catalog. It’s trying to consume it as structured data. It’s not following a golden path because it “makes sense.” It’s executing steps that need to be clearly defined and repeatable. It doesn’t benefit from a cleaner interface or fewer clicks. It needs consistency, explicit inputs, and outcomes it can rely on every time.
That’s where a lot of platforms start to show strain.
Under the covers, many IDPs are still built as human-first systems. The workflows make sense if you’re following them as a person. The catalog is readable, but not always machine-consumable. Policies exist, but they’re sometimes enforced by process or convention rather than evaluated directly in code.
That works as long as a developer is always in the loop.
It gets shaky when that assumption breaks.
The failure mode isn’t dramatic. It’s quiet. An agent tries to do something, hits friction, and finds another path. It calls a lower-level API. It bypasses part of the platform. It completes the task in a way that works, just not the way the platform team intended.
From the agent’s point of view, nothing went wrong. From the platform’s point of view, you just lost a little bit of control.
Do that enough times and the platform becomes optional.
This isn’t about replacing developers. That’s the wrong frame. What’s happening is simpler and, in some ways, more disruptive. You’ve added a second class of user.
Humans need clarity, flexibility, and experiences that help them make decisions. Machines need structure, explicit rules, and interfaces they can consume without guessing.
Right now, most teams are optimizing heavily for the first and barely thinking about the second.
That’s understandable. Developers are visible. They give feedback. They complain when something doesn’t work. They shape the backlog. Platform teams respond to that signal, which is exactly what they should be doing.
Agents don’t show up in that loop.
They don’t tell you your catalog is confusing. They don’t ask for better onboarding. They don’t care about your UI. They just interact with the system. If something doesn’t work, they either fail or route around it.
That makes them easy to ignore until they’re not.
By the time their impact is obvious, the conversation has already shifted. It’s no longer about improving developer experience. It’s about whether the platform itself can be reliably consumed by systems as well as people.
That’s a different design problem.
Now you’re talking about APIs as the primary interface, not a secondary one. Service catalogs that are structured so they can be parsed programmatically. Policies that are enforced in real time, not just documented. Workflows that behave the same way every time, not just when a human is guiding them.
You can see early signs of this already. Agents opening pull requests with infrastructure changes. Systems making decisions about where workloads should run. Pipelines triggering off signals that never came from a person.
These aren’t edge cases. They’re early patterns.
And like most early patterns, they’re easy to dismiss until they’re everywhere.
Platform decisions tend to stick. The abstractions you put in place today become the foundation on which everything else builds. If those abstractions assume a single type of user, fixing it later isn’t a tweak. It’s a rebuild.
None of this means you stop investing in developer experience. That still matters. But it’s no longer the only axis you measure against.
There’s another user in your system now. It doesn’t show up in your dashboards the same way, and it doesn’t care how clean your UI looks. It interacts with your platform in a completely different way.
The teams that recognize that early will design for it. The ones that don’t will spend the next cycle catching up.
Your platform has two kinds of users now. Build for both, or watch one of them build around you.