Most organizations are running AI coding experiments. Few are seeing the business results they expected. The gap isn't about model quality - it's about whether your production systems are designed to capture the value those models generate. This webinar breaks down the leadership decisions that determine whether agentic development compounds into real throughput or stalls at the individual level.

Main insights

• 88% of firms experiment with AI coding tools, but only 5.5% report significant business impact - the missing layer is the platform
• Moving from L1 to L2 maturity requires redesigning three core systems: work dispatch, validation loops, and risk governance
• The quality of your governance determines how much autonomy is safe - governance enables velocity, it doesn't restrict it
• Success requires executive alignment on production system changes, not just tooling experiments

Ajay Chankramath is CTO at Platform Engineering Advisory & Consulting, with over three decades of technology leadership experience. His research focuses on agentic AI in platform engineering - including AI-enabled platforms and platforms purpose-built for agentic coding workflows. He is the author of Effective Platform Engineering, Platform Engineer's Handbook, and Domain Driven Platform Engineering.

​

You can watch the full discussion here if you missed it.

The productivity paradox: Why individual gains don't scale

The data reveals a striking disconnect. While 88% of organizations have deployed AI coding assistants like GitHub Copilot or Cursor, only 5.5% report significant business impact. "This is not a rounding error," Ajay emphasizes. "This is a true structural gap."

The problem isn't the tools themselves. Individual developers report real productivity improvements, and the technology continues to advance rapidly. SWE-bench pass rates have climbed from single digits to over 50% in just 18 months, and organizations are seeing 18-38% productivity gains on workflows requiring multi-step reasoning.

Yet these individual improvements consistently fail to translate into organizational throughput. The missing layer is your platform. "The platform is what turns that individual productivity into your organizational throughput," Ajay explains. "No amount of AI models can fix organizational bottlenecks."

The L0-L4 maturity model: Where does your organization stand?

Ajay introduces a five-level maturity model that maps where organizations sit on their agentic journey:

• L0: All code written by humans, traditional SDLC
• L1: AI-assisted development where developers inspect, modify, and accept suggestions
• L2: Agents generate pull requests, humans review and approve
• L3: Platform runs continuously in the background, leaders define rules not tasks
• L4: System self-initiates work from signals, humans govern policies

Most organizations currently operate at L1, with some reaching L2. The jump from L2 to L3 represents the biggest leadership challenge - and the biggest opportunity. "The tooling leap from L1 to L2 is small," Chankramath notes. "But what you would have to do as a leader to leap from L2 to L3 is where the biggest pitfall lies."

Three bottlenecks no AI model can fix

Moving beyond L1 requires addressing three fundamental production system challenges. These aren't technical problems - they're organizational design challenges that require executive sponsorship and mandate.

Work dispatch: Your sprint model assumes humans write code sequentially. When agents generate PRs in parallel, you need a dedicated dispatch path with clear identity, scope, workspace provisioning, and output routing. Without it, agent work has nowhere to land.

Validation loops: Traditional validation acts as a gate requiring human approval. For agents, validation must become a loop. Agents iterate through deterministic checks - CI, security scans, policy enforcement - until they pass or hit a trigger requiring human intervention. Your CI capacity, security scanning, and policy enforcement must scale for this volume.

Risk governance: Who approved an agent-generated change? Which non-human identity modified that API contract? "Your compliance model needs agent-aware audit trails," Ajay explains. "Without this, you cannot pass a regulatory audit."

From IDP to ADP: Evolution, not replacement

Internal Developer Platforms (IDPs) standardize golden paths for humans through self-service portals, templates, and human-triggered workflows. Agentic Development Platforms (ADPs) take those same paths and make them machine-readable and autonomously executable.

ADPs operate on two complementary layers:

• Probabilistic layer: Foundation models, coding agents, context retrieval, reasoning, and code generation. This layer is inherently non-deterministic - agent output varies by design.
• Deterministic layer: CI/CD pipelines, validation loops, policy enforcement, RBAC, identity audits. This layer remains predictable, repeatable, and auditable.

"It doesn't matter how powerful the agents are," Ajay emphasizes. "It's how well your platforms govern their behavior. The quality of your policy definitions determines how much autonomy is safe."

Your existing tools don't disappear. The platform evolves to support both human and agent workflows, with the IDP becoming a subset of the ADP over time.

The eight platform paths that must become agent-executable

Ajay identifies eight core platform paths that define an ADP. Each must be API-addressable, event-driven, and executable without human button-pressing:

1. Dispatch work: Convert human direction into bounded agent tasks
2. Retrieve context: Scale retrieval across multiple repos, ADRs, and environment states
3. Implement change: Enable agent-executed code to run in parallel
4. Validate change: Create loops where agents iterate through deterministic checks
5. Promote change: Define tiered promotion with auto-merge and escalation rules
6. Deploy system: Automate deployment workflows
7. Observe system: Monitor and collect signals
8. Remediate issues: Enable automated incident response

At L0, humans control everything. At L4, systems self-initiate with humans governing policies. The maturity of each path determines your overall organizational maturity level.

Five leadership decisions that determine success or failure

Engineering teams cannot make these decisions alone. Leaders must address each of the following:

1. Validation loop design: Define what checks agents must pass, when they run, and what passing looks like. Leaving this to individual teams creates inconsistency and chaos across the organization.
2. Promotion model: Define your tiered promotion - what auto-merges, what escalates, where it goes, and how much time passes between activities. Agents can execute these rules, but leaders must define them collaboratively.
3. Agent accountability: Teams must own their agents. If a team can't explain what their agent does, they're not qualified to run it. Leadership sets the structure to ensure clear ownership.
4. IDP to ADP evolution path: Determine how you evolve without disrupting existing workflows. Platform paths must become agent-executable while maintaining human access throughout the transition.
5. Human-in-the-loop boundaries: Define which changes require human review versus auto-promotion. This policy question sets your maturity level and requires organizational mandate, not just engineering preference.

"These are not purely engineering team decisions," Ajay stresses. "These require executive sponsorship and organizational mandate because consistency is the key."

Common anti-patterns that stall progress

Three anti-patterns repeatedly trap organizations before they reach meaningful maturity:

The co-pilot ceiling: You deploy AI coding tools, see a modest productivity bump, and declare victory. But you never changed how work is dispatched or validated. Your org structure becomes the bottleneck, and you get stuck at L1.

Shadow agent problem: Different teams experiment independently without shared governance, common evaluation frameworks, or agreed identity models. You create AI sprawl that mirrors the tool sprawl problem - 25 different solutions to one problem.

Compliance as an afterthought: You ship agent-generated code and discover your audit trail is broken. Manual security reviews don't scale with agent volume. Governance must be designed from the ground up, not retrofitted after the fact.

A practical playbook: L1 to L2 in three months

Ajay outlines a phased approach that any organization can execute:

Month 1 - Assess and align:

• Map current maturity against the L0-L4 model
• Identify which platform paths are agent-ready versus human-only
• Get executive alignment - this is a production system change, not a tooling experiment

Month 2 - Design and decide:

• Design the validation loop - define what checks agents must pass
• Define agent identity, scope, and workspace provisioning
• Build the promotion model with auto-merge and escalation rules
• Clearly define the dispatch work path

Month 3 - Pilot and measure:

• Run a controlled pilot with one team, 2-3 agents, and bounded scope
• Measure cycle time, review load, and defect rate
• Monitor CI pressure - identify what breaks first when code generation volume increases
• Build the business case for IDP to ADP evolution based on results

"Start with one team before scaling organization-wide," Ajay advises. "The pilot proves the model. The metrics fund the expansion."

The throughput race: Winners redesign production systems

The competitive advantage doesn't come from having the best models. It comes from redesigning production systems to leverage those models at scale. Over 50% of enterprise platform teams are remodeling for agent-first execution in 2025. Organizations report 3-5x increases in PR throughput without increasing headcount - but only when they redesign review models and validation loops.

Ajay concludes. "This is becoming reality as we speak."

The question isn't whether your organization will adopt agentic development. The question is whether you'll redesign your production systems to capture the value - or get stuck at the co-pilot ceiling while competitors pull ahead.

​

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

If you want to dive deeper, explore our instructor-led Platform Engineering Certified Leader course and connect with peers from large-scale enterprises who are driving cultural transformation.

​

Key takeaways

• The 88% to 5.5% gap reveals the real challenge: Most organizations have AI tools but lack the platform infrastructure to turn individual productivity into organizational throughput. Success requires redesigning production systems, not just deploying better models.
• Maturity is defined by where humans sit in execution: The L0-L4 model provides a clear framework for assessment. The hardest transition is L2 to L3, where humans move from reviewing every change to orchestrating rules while platforms run continuously in the background.
• Three bottlenecks block progress: Work dispatch, validation loops, and risk governance cannot be solved with AI alone. These require intentional platform design with agent-executable paths, validation as loops not gates, and agent-aware audit trails for compliance.
• Governance enables velocity, it doesn't restrict it: The quality of your guardrails determines how much autonomy is safe. Organizations that design governance from the ground up - not as an afterthought - achieve the highest levels of agent autonomy while maintaining security and compliance.