DEV Community

Cover image for The Future of Platform Engineering Is Agent-First
Remo H. Jansen
Remo H. Jansen

Posted on

The Future of Platform Engineering Is Agent-First

For the last few years, platform engineering has been focused on one thing: improving the developer experience.

We've built internal developer portals, self-service infrastructure provisioning, deployment dashboards, observability platforms, service catalogues and all sorts of other tools designed to make developers' lives easier.

We've invested in better user interfaces, intuitive workflows, documentation and golden paths.

And rightly so.

But I think something fundamental is changing.

We're entering a world where developers won't necessarily interact with these platforms directly. Increasingly, they'll delegate tasks to AI agents that interact with the platforms on their behalf.

And this raises an interesting question:

Are we still building platforms primarily for developers, or should we now be building them for the agents that developers use?

I think it's time for platform engineering to make that shift.

We've spent years optimising for humans

Think about the typical internal developer platform.

It might have a developer portal where engineers can discover services, create new projects or provision infrastructure. There might be dashboards for monitoring deployments, visual interfaces for managing environments and forms for requesting access to resources.

These tools have a common design assumption: a human is sitting in front of a computer, interacting with the platform.

We optimise for that person.

We ask questions like:

  • Is the interface intuitive?
  • Can developers easily find what they're looking for?
  • Are workflows straightforward?
  • Can we reduce the number of clicks required to complete a task?
  • Is the documentation easy to understand?

This is what we've traditionally meant by developer experience (DevEx).

But what happens when the developer stops being the primary person interacting with the platform?

The agent is becoming the interface

Imagine a developer asking an AI coding agent:

  • Deploy my application to a new environment.
  • Investigate why the latest deployment failed.
  • Provision a database for this feature.
  • Find out why this service is experiencing high latency.
  • Create a new service using our standard golden path.
  • Tell me which services depend on this API.

The developer doesn't necessarily want to open a portal, navigate through several screens, fill in forms and copy information between tools.

They want to describe the outcome they need.

The agent figures out how to achieve it.

To do that, the agent needs to interact with the internal developer platform. It needs to discover capabilities, authenticate, invoke operations, retrieve information and understand the results.

And suddenly, all those things we previously considered secondary become incredibly important.

Does the platform expose a usable API?

Can the agent interact with it through a CLI?

Is the output structured and machine-readable?

Can the agent authenticate without requiring a human to complete an interactive login flow?

Can it discover what operations are available?

Can it understand errors and recover from failures?

These are no longer just technical implementation details. They're fundamental parts of the developer experience.

From human-first UX to agent-first UX

I think we need to start considering a different set of priorities when building internal developer platforms.

Historically, we've often prioritised the graphical user interface. We built APIs and CLIs to support the GUI, or as additional interfaces for more technically minded developers.

That relationship might need to change.

Consider some examples:

Human-first thinking Agent-first thinking
A beautiful developer portal A comprehensive, discoverable API
Intuitive navigation Discoverable capabilities and schemas
Forms and buttons Programmatic operations with structured inputs
Interactive login Secure, non-interactive authentication
Human-readable error messages Structured, actionable errors
Visual dashboards Queryable observability data
Documentation for developers Documentation agents can reliably consume
Manual workflows Composable, automatable operations

This doesn't mean graphical interfaces are no longer important.

Humans still need visibility, oversight, investigation tools and the ability to understand what's happening.

But the GUI should no longer be the only well-supported way to interact with platform capabilities.

The platform should expose its capabilities in a way that works equally well for humans and agents.

What does an agent-friendly platform look like?

I think there are several areas platform teams should start paying much more attention to.

1. APIs should be first-class citizens

If a developer can provision an environment through the developer portal, an agent should be able to provision that same environment through an API.

This sounds obvious, but many internal tools still have functionality that is only accessible through their graphical interfaces.

That creates friction for agents.

Platform capabilities should be exposed through well-designed APIs with predictable behaviour, consistent schemas and clear contracts.

The GUI should consume those capabilities rather than being the only place where they exist.

2. CLIs matter more than ever

CLIs have always been useful for developers, but they become particularly interesting in an agent-driven world.

Agents can execute commands, pass arguments, inspect output and chain operations together.

However, a CLI designed for humans isn't necessarily a good CLI for agents.

Think about things like:

  • Consistent command structures.
  • Machine-readable output, particularly JSON.
  • Predictable exit codes.
  • Clear error messages.
  • Non-interactive execution.
  • Reliable behaviour that doesn't depend on terminal formatting.

A command that prints a beautifully formatted table might be great for a human but less useful to an agent than a structured JSON response.

We need to start treating agent usability as a design requirement for our CLIs.

3. Authentication must become frictionless

This is potentially one of the biggest challenges.

Many developer tools assume an interactive human authentication flow.

Open a browser, log in, complete MFA, approve access and perhaps copy a token into a configuration file.

That works reasonably well for humans.

It doesn't work particularly well when an agent needs to perform a task autonomously.

Agents need identities. They need to authenticate securely, obtain appropriately scoped permissions and access the resources required to complete their tasks.

We need to think about workload identities, delegated authorisation, short-lived credentials and secure token exchange.

Importantly, frictionless authentication doesn't mean removing security controls.

It means designing authentication and authorisation around automated actors rather than assuming every interaction originates from a human sitting at a keyboard.

4. Capabilities need to be discoverable

Imagine asking an agent to provision infrastructure.

How does it know what infrastructure your platform supports? How does it know which parameters are required? How does it know the organisation's standards and constraints?

Humans might discover these things by browsing a portal or reading documentation.

Agents need more structured ways to discover them.

APIs with schemas, machine-readable documentation, service catalogues and protocols such as MCP can all help.

The important thing is that platform capabilities shouldn't be hidden behind interfaces that agents cannot understand.

5. Everything needs to be composable

One of the most interesting things about agents is their ability to coordinate work across multiple systems.

A developer might ask an agent to investigate a failed deployment.

The agent could:

  1. Retrieve deployment information.
  2. Inspect the application logs.
  3. Query observability data.
  4. Identify a likely infrastructure issue.
  5. Check recent configuration changes.
  6. Suggest or execute a remediation.

This requires multiple platform capabilities to work together.

If every tool has its own authentication model, interaction pattern, output format and set of assumptions, the agent experience becomes fragmented.

We should be thinking about how platform capabilities can be composed into larger workflows.

Developer Experience is becoming Agent Experience

I think this is the most important shift.

We've traditionally measured developer experience by looking at how easily developers can use our platforms.

But increasingly, developers will interact with those platforms through agents.

That means the quality of the agent experience directly affects the quality of the developer experience.

A platform might have a fantastic developer portal, beautifully designed dashboards and an extensive catalogue of self-service functionality.

But if an agent can't discover those capabilities, authenticate and invoke them programmatically, how useful is that platform in an agent-driven development environment?

We need to introduce another dimension to our thinking: Agent Experience (AX).

Not as a replacement for Developer Experience, but as an increasingly important part of it.

The question shouldn't just be:

How easy is it for a developer to use our platform?

It should also be:

How easy is it for an agent to use our platform on behalf of a developer?

Does this mean developer portals are dead?

Absolutely not.

I don't think this is an argument against developer portals, dashboards or graphical interfaces.

Humans will continue to need them.

There will always be situations where developers want to explore information visually, investigate problems themselves, review what an agent has done or approve sensitive operations.

But I think we need to change the role these interfaces play.

Rather than building a graphical interface and then exposing some of its functionality through APIs, we should build platform capabilities that are accessible programmatically from the beginning.

The GUI becomes one consumer of those capabilities.

An agent becomes another.

Both should have access to the same underlying platform functionality, subject to appropriate permissions and controls.

A new set of questions for platform teams

As platform engineers, I think we need to start asking ourselves some different questions when evaluating the tools and capabilities we're building.

  • Can an agent discover what our platform can do?
  • Can it perform the same operations as a human using the GUI?
  • Can it authenticate without interactive human intervention?
  • Are our APIs and CLIs designed for machine consumption?
  • Are our tools composable?
  • Can an agent understand failures and take appropriate next steps?
  • Can we give agents the permissions they need without giving them unrestricted access?

These questions should become part of how we evaluate our internal developer platforms.

Because a platform that is easy for humans to use but difficult for agents to operate will increasingly become a source of friction.

The next generation of internal developer platforms

Platform engineering has always been about reducing friction for developers.

We've built abstractions, golden paths, self-service capabilities and tools that allow engineers to focus on delivering value rather than dealing with infrastructure complexity.

Now the way developers interact with those platforms is changing.

The developer of tomorrow might not spend much time navigating our portals, clicking through dashboards or filling in forms.

They might simply describe what they want to achieve and delegate the work to an agent.

Our job as platform engineers is to make sure those agents can interact with our platforms as effectively as humans can today.

The next generation of internal developer platforms won't be judged solely by how good their portals look or how intuitive their dashboards are. They'll be judged by how effectively agents can discover, understand and operate their capabilities.

We've spent years optimising the developer experience.

It's time to start optimising the agent experience, too.

Because increasingly, the developer experience depends on it.

Top comments (0)