Skip to content

From DevEx to AgentEx: As AI Agents Become Platform Consumers

November 16, 2026 · Kishore Babu Gutta

Perspective, not a product announcement or a forecast. This article explores an emerging shift in platform engineering. I use AgentEx as a short label for the experience of AI agents consuming enterprise platform services. Related terms such as Agent Experience (AX) are already used in the industry; the point here is the engineering responsibility, not ownership of a new term.

As a platform engineer, I've spent years helping teams use engineering tools and platforms. Lately I've noticed AI agents becoming another consumer of that work.

Platform engineering has long focused on developer experience (DevEx): make complex infrastructure, CI/CD, cloud and security tools easier for internal teams to use.

An AI agent can read platform documentation, inspect a failed build, propose a configuration change and call APIs or tools on behalf of an engineer. The person still owns the goal. The agent can increasingly handle the interaction.

This suggests a shift:

From building self-service platforms primarily for humans to building platforms that humans and AI agents can consume safely.

I'll use AgentEx as shorthand for that shift.

Platform engineers have long been the bridge

External vendors already provide sophisticated engineering products. GitHub provides source control and CI/CD. Google Cloud provides managed Kubernetes. Terraform provides infrastructure-as-code workflows.

Inside an enterprise, platform engineering turns these products into usable internal services. Teams integrate them, establish identities and permissions, build golden paths, create scripts and templates, maintain standards, troubleshoot failures and support developers, testers, database teams and other consumers.

In my experience, a significant amount of this work is not inventing a new platform. It is adapting external products to the organization's identity, security, network and compliance constraints, work that depends on deep context.

Historically, that work required engineers to learn commands, APIs, configuration models and operational edge cases. AI may speed up parts of it, especially the lookup and first-draft parts.

The change is already visible in vendor products

This is not yet a world where autonomous agents can safely run every production system. But the direction is observable:

  • GitHub Actions: GitHub documents an Explain error action that opens Copilot to help diagnose a failed workflow run and suggest how to resolve it. A failure that once began with a platform support ticket can increasingly begin with assistance inside the product itself.
  • Google Cloud and GKE: Gemini Cloud Assist documents AI-supported diagnosis of GKE errors and investigations across logs and infrastructure. The feature is currently in Preview under Google's pre-GA terms; a diagnostic suggestion is not equivalent to an authorized production change.
  • Terraform: HashiCorp's Terraform MCP server exposes provider documentation, modules and selected HCP Terraform operations to AI clients. Its HashiCorp-hosted offering is described as beta, and HashiCorp strongly discourages using beta features in production.
  • Platform engineering practice: CNCF's July 2026 article describes agents becoming platform consumers alongside human users. Its September 2026 article distinguishes human self-service from machine-consumable agent interfaces.

None of this replaces platform teams. These examples do show vendors placing intelligence closer to the work those teams have traditionally supported, and the wider community treating agents as platform consumers.

DevEx and AgentEx serve the same engineering outcome

DevEx asks: Can a developer provision an environment, deploy an application or investigate a failure without unnecessary friction?

AgentEx adds: Can an authorized agent discover and request those same services with the correct identity, scope, boundaries and evidence?

The interface may change, but the required outcome does not.

Human intent
    |
    +----> Developer portal / CLI / CI
    |                 |
    +----> AI agent --+--> approved platform capability
                              |
                    identity + target + policy
                              |
                     provider-native operation
                              |
                     verification + evidence
                              |
                    GitHub / Cloud / Kubernetes

A portal is optimized for a person navigating forms and documentation. An agent needs discoverable contracts, precise inputs, machine-readable errors and safe invocation paths. Both need trustworthy results.

AgentEx does not mean removing humans from platform engineering. It means treating the agent as another caller acting under delegated authority, not as an unrestricted administrator.

What changes for the platform engineering team?

Today Increasingly also
Write scripts for repeated requests Define and qualify reusable platform capabilities
Maintain documentation for human operators Make supported operations discoverable and machine-readable
Configure developer access to tools Bind human and agent requests to appropriate identities and scopes
Handle routine CI/CD and infrastructure tickets Automate common diagnostics and remediations within approved boundaries
Apply standards through templates and reviews Express standards as testable, enforceable execution contracts
Investigate and support exceptions Own complex incidents, policy exceptions and system-level outcomes

These shifts change how platform teams demonstrate value. Value becomes more visible in reliable services and outcomes than in the volume of requests handled.

A plausible progression

The following is a scenario to test, not a forecast. Stages may overlap, and organizations will move at different speeds.

Stage 1: Assist the operator. AI explains failed builds, suggests Terraform changes, searches documentation and drafts remediations. A person often reviews and triggers execution.

Stage 2: Delegate bounded tasks. Enterprises may allow agents to resolve more routine requests using scoped identities, constrained tools, approved capabilities and explicit verification. Human operators may focus more on exceptions, reliability and risk.

Stage 3: Capability-driven platforms. A mature organization might maintain a catalogue of reviewed engineering capabilities that humans, CI/CD and agents can reuse. Agents may also propose new capabilities, but approval, qualification and change control must still be addressed.

The speed of any such transition depends on security, economics, regulation, vendor capabilities, failure rates and organizational trust. Some environments may remain heavily human-operated.

The difficult part is not reading the documentation

Suppose a developer asks an agent to create a service, configure its repository, provision infrastructure and deploy it to Kubernetes.

An agent may know the necessary GitHub, Terraform and GKE interfaces. Knowledge of the commands is not authorization to execute them.

The enterprise still needs answers to harder questions:

  • Identity: On whose behalf is the agent acting, and which provider-native identity may it use?
  • Scope: Which organization, project, repository, cluster and environment are in bounds?
  • Authority: What can the underlying service account technically do, and what is this request actually permitted to do?
  • Change control: Which actions require review or a separate approval?
  • Execution: How are steps constrained across providers without giving the agent a blanket credential or an arbitrary command path?
  • Verification: Did the provider's live state satisfy the intended outcome, or did a command merely return success?
  • Evidence: Can an operator investigate who requested the operation, what ran, what was denied and what changed?

Agent service identities, least-privilege provider scopes and credential isolation are essential. But a service account with limited permissions does not, by itself, express every enterprise-specific decision about when an otherwise permitted operation should happen. Likewise, an MCP interface helps a model call a tool; the interface alone does not define a complete enterprise execution policy.

And vendor intelligence raises a second question: if GitHub helps with GitHub, Google helps with Google Cloud and Terraform helps with infrastructure workflows, who owns the boundary for work spanning all three?

That boundary might be built into existing platforms, an internal platform service or a separate execution layer. Enterprises should evaluate the options on evidence rather than assume another product is automatically necessary.

One possible approach: Engineering Runtime

I'm exploring this problem through Engineering Runtime (ENGRT), an Engineering Execution Layer for reusable engineering capabilities used by human engineers, CI/CD systems and AI agents.

The idea is to separate reasoning about an operation from admitting and executing it. An agent can request a reviewed capability without becoming the authority that decides whether the operation is permitted.

ENGRT is one possible approach, not the only one. Vendor-native controls, IAM, policy-as-code and existing internal developer platforms may be the right answer in many environments. Current ENGRT scope and supported providers are in the release overview and product documentation.

How to know whether AgentEx is actually improving things

The goal is not to maximize the number of agents connected to internal systems. It is to deliver engineering outcomes with less friction without losing control.

Platform teams can measure:

  • Time from request to verified result, for humans and agents.
  • Percentage of common requests completed without a support ticket.
  • Number of operations refused appropriately at the execution boundary.
  • Verification success, false-success reports and recovery effort.
  • Reliability incidents and security exceptions introduced or avoided.
  • Engineering time spent maintaining capabilities versus repeating manual support.

A useful platform should make routine work easier while keeping failures understandable and high-impact changes accountable.

The next consumer of your platform may not be human

The developer remains central: developers, testers, DBAs and application teams still have the problems to solve. But an AI agent may increasingly be the interface through which they consume internal engineering services.

The role of platform engineering can evolve accordingly:

From enabling developers to operate enterprise tools, to enabling humans and AI agents to achieve approved engineering outcomes through those tools.

That is the opportunity behind AgentEx. It is also a challenge to the existing operating model: if agents can perform much of the routine integration and support work, platform teams have a chance to focus on what agents can't own: boundaries, reliability and the capabilities agents depend on.

The future is not guaranteed. But it is already worth designing for.


Further reading

Engineering Runtime is not affiliated with, endorsed by, or sponsored by GitHub, Google, HashiCorp, Microsoft or CNCF. These references provide industry context.