The rise of AI agents is forcing platform engineering teams to rethink their infrastructure - but not in the way you might expect. You don't need to tear down your internal developer platform (IDP) and start over. Instead, you need to evolve it into an agentic development platform (ADP): an architecture that supports human developers and autonomous agents working side by side.

Main insights

• Your existing IDP is the foundation for an ADP - you extend it, not replace it
• There are three core path types to master: probabilistic, deterministic, and hybrid
• Start with two paths - validate change and PR review - to build essential agent infrastructure
• The platform does approximately 90% of the work in agentic workflows; the AI model handles the remaining 10%

Kaspar von Grünberg and Ajay Chankramath recently led a working session on architecting agentic development platforms, breaking down the core architectural patterns emerging from the field. Kaspar helped establish platform engineering as a discipline and is currently CEO of Canyon, building the semantic data layer for enterprise AI. Ajay is CTO at Platform Engineering Advisory & Consulting and author of multiple books, including Effective Platform Engineering and Platform Engineer's Handbook.

You can watch the full discussion here if you missed it: How to architect agentic development platforms.

Your IDP is not obsolete - it's your foundation

One of the most common questions platform teams face is whether adopting agents requires starting from scratch. The answer is a clear no. As Ajay explains, "Everything that you have done in your IDP is indeed the foundation of how everything is going to work in the future."

The shift to agentic platforms is an evolution, not a revolution. Your existing tooling layer - your CI/CD pipelines, security scanning, observability tools, and resource management - stays exactly as it is. What changes is how work flows through these tools and who (or what) triggers that work.

Agents have, as Ajay puts it, "jumped out of the IDE into the open world." They're no longer just autocomplete features. They're becoming active participants in your development workflow - capable of reading context, making decisions, and executing tasks. But they still depend on the same underlying platform infrastructure that human developers use.

The four levels of agentic maturity

Understanding where your organization sits on the maturity curve helps you plan your next steps.

• Level 1: In the loop - Agents provide autocomplete and suggestions within the IDE. The human developer remains in full control. Most organizations with basic AI tooling are here.
• Level 2: On the loop - Agents execute tasks autonomously, but humans validate the results. This is where agents start reviewing PRs, fixing test failures, and generating code changes for human approval.
• Level 3: Orchestrated agents - Multiple agents work together with minimal human intervention. Throughput becomes the key metric rather than individual developer productivity.
• Level 4: Outside the loop - Fully autonomous platforms where agents can trigger, execute, and deploy changes without human initiation. For example, an agent listening to a customer success call could automatically fix a reported bug and ship it to production.

Most teams today sit between levels one and two. As Kaspar notes, "While there's still people that say we're not sure whether agents will make a difference, at the same time, you'll have these people at the forefront that are long between level three and four." Front-runners are already approaching levels three and four, particularly for front-end work.

The three path types you need to understand

Every workflow in an ADP falls into one of three categories. Getting this classification right is fundamental to architecting your platform correctly.

Probabilistic paths involve agent reasoning and decision-making. A PR review is the classic example: the agent reads the diff, loads context about coding standards and architectural decision records, evaluates the changes, and posts comments. Run the same review twice and you may get different - but equally valid - feedback. The key benefit, as Ajay explains, is that "time to first review goes from some number of hours to literally seconds."

Deterministic paths must produce the same output given the same input. Your CI/CD pipeline is deterministic - you don't want probabilistic behavior when building and deploying code. These paths remain unchanged in an ADP. The only difference is that an agent might trigger them instead of a human.

Hybrid paths combine both approaches and represent the most common real-world scenario. Consider the validate change workflow: a developer submits a PR, CI runs deterministically and fails with test errors. In a traditional setup, the developer reads the output, debugs, fixes the code, and pushes again. In an ADP, the failure signal routes back to an agent. The agent reads the failure, loads context, and resubmits a fix - all without human intervention. The deterministic gates (tests, linting, security scans) remain in place, but the agent handles the iteration loop.

The agent infrastructure layer: Where the real work happens

The most significant architectural addition in an ADP is the agent infrastructure layer. This sits above your existing IDP and handles everything agents need to operate safely and effectively. It has two main components.

Agent harness provides the execution environment for agents and covers four critical functions:

• Context assembly - gathering all relevant information (code, standards, history) the agent needs
• Capability provisioning - defining what tools and APIs the agent can access
• Execution environment - providing a sandboxed space where the agent can work safely
• Evaluation - validating agent output using rubric scores and LLM judges

Agent governance ensures agents operate within acceptable boundaries:

• Identity management - establishing non-human identities for agents with appropriate permissions
• Security controls - automatically scanning for PII leaks, secrets, and policy violations
• Observability - tracking token usage, retry counts, and agent-specific metrics (not just application metrics)

Kaspar makes a point that reframes how platform engineers should think about their role here: "If you just really do the job of reasoning step by step through everything that happens in the flow through an agentic platform, you'll see that this is sort of a 10% job of the model and all of the rest is orchestrators, infrastructure spinning up, eval frameworks and rubric scores firing."

The platform does the heavy lifting. The AI model is one component among many.

The eight core paths (and where to start)

Kaspar and Ajay have identified eight fundamental paths that cover most development activities:

1. Dispatch work - routing signals to the right agents or humans
2. Retrieve context - assembling relevant information for tasks
3. Implement code - generating and modifying code
4. Validate change - the hybrid path combining deterministic gates with agent iteration
5. Promote change - merge, approve, and release workflows
6. Deploy - provisioning and deploying to environments (must remain deterministic)
7. Observe - monitoring production systems (hybrid path with inference)
8. Remediate - diagnosing and fixing production issues (probabilistic)

You don't need to tackle all eight at once. Ajay's recommendation is direct: "Start with two paths. Start with your validate change and PR review."

These two paths are the right starting point for two reasons. First, the validate change path forces you to build the essential agent infrastructure - the harness and governance components you'll need for everything else. Second, the PR review path is lower risk because it doesn't modify code directly; it only writes comments. Even if the agent produces slightly different feedback on repeated runs, the worst case is inconsistent review comments - not broken production systems.

Once these two paths are working, you've built the minimum viable foundation:

• Identity management for agents
• Dispatch mechanisms to route work
• Execution environments
• Evaluation frameworks
• Observability for agent activities

With this foundation in place, adding additional paths becomes significantly more straightforward.

Practical implications for platform teams

The shift to agentic platforms expands the platform engineering mandate well beyond software development. As Kaspar points out, "The business will now build all sorts of new platforms, marketing platforms, sales platforms, finance platforms, legal platforms." These teams will need agent infrastructure, and they'll look to platform engineering for guidance.

The agent infrastructure layer is largely domain-agnostic. Whether you're building an agentic development platform or an agentic marketing platform, you need the same harness and governance components. This positions platform engineering teams as critical enablers across the entire organization - not just for engineering.

Two additional principles matter here. First, everything must be represented as code. Just as you manage your IDP with infrastructure as code, you must manage your agent infrastructure the same way - including model configurations, prompts, skills, and path definitions. Version control, auditability, and reproducibility are just as important with agents as with any other infrastructure.

Second, throughput becomes more important than individual productivity. When agents can iterate through fix cycles in seconds rather than hours, the bottleneck shifts from individual developer speed to overall system throughput. Your platform must support high-velocity, parallel workflows.

​

If you enjoyed this, find here more great insights and events from our Platform Engineering Community.

For more comprehensive guidance, check out the Platform Engineering Certified Architect Course and learn best practices from industry experts.

​

Key takeaways

• Don't rebuild from scratch - Your existing IDP is the foundation for your ADP. You're adding a new layer, not replacing what you have. This reduces migration risk and lets you leverage existing investments immediately.
• Master the three path types - Classifying every workflow as probabilistic, deterministic, or hybrid gives you a clear framework for deciding where agents add value and where deterministic controls must remain non-negotiable.
• Start with two paths - Begin with validate change and PR review. These paths force you to build essential agent infrastructure while keeping risk low. Once the foundation exists, adding more paths is straightforward.
• The platform does most of the work - Agent reasoning accounts for roughly 10% of an agentic workflow. The other 90% is platform orchestration, context assembly, evaluation, and governance. For platform engineers, this means your expertise is more valuable in the agentic era than ever before.