Everyone's Talking About Agentic AI for Modernization. Nobody's Shipping Code.

Microsoft published a blog post in January called The Realities of Application Modernization with Agentic AI. It's honest in a way vendor content rarely is:

"Agentic AI does not magically modernize applications. What it changes is where effort goes and how knowledge is reconstructed when the original system understanding is gone."

That's a good framing. It's also incomplete.

Every major player in the modernization space is repositioning around "agentic AI" right now. AWS, Microsoft, vFunction, IBM. The messaging has converged: agents understand your codebase, agents plan the migration, agents orchestrate the work. The word "agentic" appears in every 2026 product announcement.

But look at what actually comes out the other end.

The Output Gap

vFunction 4.5 just shipped their "vFunction Agent." It has a conversational interface. It integrates with MCP servers. It generates architecture-aware context for coding assistants. It produces confidence signals for dead code removal.

What does it deliver? TODOs. Prioritized task lists. Implementation notes that humans review on a dashboard. Their own words: "Teams can move directly from architectural understanding to execution by reviewing, prioritizing, and acting on tasks." The agent recommends what to refactor. Humans still do the refactoring.

AWS Transform Custom went GA in December 2025. It handles Java version upgrades, API migrations, and framework updates at scale. Amazon claims it reduces execution time by 80% and saved $260M internally migrating to Java 17.

What does it deliver? Version upgrades. Java 8 to 17, .NET 4 to .NET 8, Spring Boot 2 to 3. Real code changes, but scoped to upgrading frameworks within the same architecture. It doesn't touch the architecture itself. Your monolith comes out the other side as a monolith on a newer framework.

GitHub Copilot App Modernization does .NET upgrades and Java-to-Azure migrations. IBM watsonx Code Assistant handles COBOL-to-Java conversions and WebSphere-to-Liberty migrations. Google Cloud's modernization suite rewrites mainframe code.

Every single one outputs either (a) analysis and recommendations, or (b) version/platform upgrades within the same architecture. Nobody extracts services. Nobody decomposes a monolith into independently deployable, tested microservices and delivers them as pull requests.

Why This Gap Exists

Microsoft's blog post actually hints at why:

"Application modernization rarely fails because of code alone. It fails because ownership is unclear, teams are fragmented, incentives favor stability over improvement."

This is true. Modernization is a sociotechnical problem. But it's also a convenient framing for vendors whose tools stop at analysis.

The technical reason the gap exists is that extraction is fundamentally harder than upgrading. Upgrading a framework is a well defined transformation: known input patterns, known output patterns, deterministic rules. OpenRewrite built an entire recipe catalog for this. AWS embedded it into Transform. Moderne raised $50M on it.

Extraction is different. You're making architectural decisions, not syntactic ones. Which code belongs in which service? Where do you draw the API boundary? How do you handle shared database tables? What happens to the 47 transitive dependencies that cross the cut line? There's no recipe for this because every monolith is different.

The big players solve this by punting the hard part to humans. Their agents analyze, recommend, and sometimes upgrade. But the structural transformation: actually splitting the monolith into services, wiring the integration, testing the result? That's still a manual job.

What "Deliver to Production" Actually Means

At CodeSplit AI, we took a different approach. Not because analysis isn't valuable (it is), but because the bottleneck was never understanding what to do. Every engineering leader we've talked to knows their monolith needs to be decomposed. They know roughly where the boundaries should be. What they don't have is the 6 to 18 months of engineering time to actually do the extraction.

So we built a platform that does the extraction.

Connect your GitHub organization. The AI analyzes the codebase and identifies candidate domains based on actual code coupling, not whiteboard diagrams. Pick a domain. The platform extracts it: new repository, refactored monolith with the extracted code replaced by API calls, wired integration between the services, tests generated and verified, delivered as pull requests you review and merge.

Not a TODO list. Not a recommendation. Not an upgraded version of the same monolith. A structurally different architecture, delivered as code, ready to ship.

But extraction is just the wedge. The real vision is modernization as an end to end outcome. Extraction today, framework migration next (Java 8 to 17, Angular to React), then CI/CD pipeline generation for the new services, cloud deployment automation, and production monitoring. The full lifecycle from "we have a monolith" to "we have independently deployable services running in production with observability."

Every capability in that chain compounds the one before it. Extraction patterns inform migration patterns. Migration patterns inform deployment patterns. The platform learns across the entire modernization lifecycle, not just one slice of it.

That's what "service as software" means. The modernization itself is the product. Not the analysis that precedes it, and not just the code that comes out. The outcome is services running in production, integrated with your cloud and your CI/CD pipeline, monitored and observable.

The Real Question

Microsoft is right that agentic AI changes where effort goes. But the interesting question isn't whether agents can understand your codebase (they clearly can) or whether they can plan a migration (planning is the easy part). The interesting question is: can an agent actually execute an architectural transformation end to end?

Everyone in the industry is betting on agents as advisors. Smarter dashboards. Better recommendations. More context-aware TODO lists. And when they do ship code changes, it's version upgrades within the same architecture. Your monolith goes in, your monolith comes out on a newer framework.

We're betting on agents as builders. Connect repo. Get extracted services. Review the PRs. Merge. Your monolith is now two independently deployable services, with the path to CI/CD integration and cloud deployment built into the platform.

The fact that $160M+ has been raised in the modernization space in the last 12 months (Rhino.ai $50M, Code Metal $36.5M, CoreStory $32M, Moderne $30M, Conduct $12M), and the fact that every hyperscaler is building tools for it, tells you one thing clearly: the problem is real, it's massive, and nobody owns the full lifecycle yet.

We think delivery is the answer. Not delivery of recommendations. Delivery of modernized services to production. Try it yourself and see what the AI finds in your codebase.