Best AI Code Migration Tools in 2026 for Legacy Modernization

Almost every engineering org has a service nobody volunteers to touch: a Java 8 application pinned to Spring Boot 2, a .NET Framework 4.8 app that only builds on Windows Server, or a COBOL batch job that closes the books every night. The work needed to move those forward is well understood and extremely boring, which is exactly why it keeps losing to feature work in planning.

The arithmetic on that tradeoff changed this year. AWS Transform now bills agentic code transformation at $0.035 per agent minute, and AWS's own published examples put a Java language version upgrade of roughly 17,000 lines at about 72 agent minutes, or $2.52. A Node.js SDK upgrade across ~3,000 lines lands at $0.70. Those are not typos, and they are the entire budget conversation for work that used to be quoted in engineer-weeks.

The deterministic side got faster too. While writing this guide I ran OpenRewrite's UpgradeToJava21 recipe against a Java 8 Maven project on a laptop. It finished in 87 seconds on a cold Maven cache, 18 seconds once the artifacts were local, rewrote the build configuration, and printed Estimate time saved: 15m. It also did not touch a single line of the Java source, which turns out to be the most useful thing I learned all week. More on that below.

Why This Category Took Off in 2026

Three things converged.

Runtimes go end of life faster than teams can chase them. Java ships an LTS every two years, .NET ships a major version every November, and Node drops even-numbered releases out of maintenance on a fixed calendar. A codebase that was current in 2022 is now two or three upgrade hops behind, and each hop carries its own breaking changes: javax to jakarta, System.Web to the ASP.NET Core hosting model, new Buffer() to Buffer.from().

AI writes more code than teams can hand-refactor. The volume of generated code landing in repos means the tail of small inconsistencies - deprecated calls, outdated idioms, duplicated helpers - grows faster than any manual cleanup rotation can absorb. Migration tooling stopped being a once-per-decade project and became continuous maintenance.

Vendors started metering the work instead of the seat. This is the underrated shift. When a migration is billed per agent minute rather than per developer per month, running one on a low-value internal service becomes a defensible decision rather than a budget request.

Two Approaches, and Why the Difference Matters

Everything in this guide sits somewhere on a line between two techniques, and picking the wrong one is the most common way these projects go sideways.

Deterministic engines parse your code into a typed tree, apply a rule, and print it back. OpenRewrite calls its representation a Lossless Semantic Tree; ast-grep uses tree-sitter syntax trees. The rule either matches or it does not. Same input, same output, every time, with no model in the loop. The tradeoff is that somebody has to write the rule, and a rule only handles the cases its author anticipated.

Agentic transformers hand the job to a model with tool access: read the file, edit it, run the build, read the error, try again. They handle the messy long tail that no recipe author predicted, including the case where the fix requires understanding what the code is supposed to do. The tradeoff is nondeterminism, per-run cost, and a diff that genuinely needs review.

The practical answer for most teams is both, in that order. Run the deterministic pass first because it is free, instant, and reviewable in bulk. Send whatever is left to an agent. Every serious platform in this category has converged on that hybrid, which is why Codemod markets its engine as compiler-aware steps combined with AI steps, and why Moderne now publishes an agent skill that lets Claude invoke OpenRewrite recipes instead of freehand editing.

Comparison Table

Open-Source Migration Engines

Start here regardless of budget. These three cover more ground than most teams expect, and none of them send your source anywhere.

OpenRewrite

OpenRewrite is the closest thing this category has to a standard. Maintained by Moderne and licensed Apache 2.0, it parses source into a Lossless Semantic Tree, which is a typed AST that also preserves formatting and comments, then applies packaged recipes to it. Because the tree carries type information, a recipe can tell the difference between your Result class and a Result from a dependency, which is the thing plain regex and search-and-replace can never do.

Coverage is Java-first and deepest around framework migrations: Java version upgrades, Spring Boot 2 to 3, the javax to jakarta namespace move, JUnit 4 to 5, plus a large static analysis catalog. The community publishes over 2,800 open-source recipes, and Moderne's commercial catalog claims tens of thousands of composable recipes across 40+ domains and 10+ languages.

One operational change to know about before you start: OpenRewrite releases are moving from Maven Central to the Code Genome Project repository at https://artifacts.codegenomeproject.org/maven, which requires an account and a download token. Apache-licensed recipes stay available to any authenticated user, while source-available and proprietary recipes need a Moderne subscription. Earlier releases remain on Maven Central, which is why the run below still resolved without credentials on August 25, 2026. Keep Maven Central configured alongside the new repository, because transitive dependencies still come from there.

What it does well: Type-aware transformations that no regex can express, reproducible output, recipes that compose into larger migrations, and a real estimate of the manual time each run replaced.

What it doesn't do: It does not reason about intent. If no recipe exists for your framework or your internal API, nothing happens, and writing a new recipe means writing Java against the OpenRewrite API.

Pricing: Free and open source, Apache 2.0.

ast-grep

ast-grep is what you reach for when the change is simple, the codebase is large, and you want it done in the next 30 seconds. Written in Rust, MIT licensed, currently at 0.45.2, it does structural search and replace using patterns that look like the code itself rather than like a regex. It supports 20+ languages through tree-sitter, including Java, C#, Go, Python, Rust, and TypeScript, and you can register custom parsers.

The mental model is grep and sed with a parser attached. You write the code shape you want to find, with $A standing in for a single node and $$$ARGS for a list of them, and ast-grep rewrites every structural match while ignoring anything that only looks similar in text.

What it does well: Near-instant runs on large trees, one-line invocations with no project setup, and a pattern syntax you can learn in about five minutes.

What it doesn't do: No type information, so it cannot distinguish two identically named symbols from different packages. It also has no notion of a multi-file migration: updating a call site and its import is two separate operations.

Pricing: Free and open source, MIT.

Codemod

Codemod is the JavaScript ecosystem's answer to "who maintains the migration scripts." It is an OpenJS Foundation partner project, and its registry hosts the official codemods for React, Node.js, Express, React Router, Nuxt, pnpm, and Webpack, among others. ESLint published its own migration through Codemod in July 2026.

Its runtime, jssg (JavaScript ast-grep), shipped in February 2026 as a successor to jscodeshift: you still author transforms in JavaScript or TypeScript, but the engine underneath is ast-grep, so the same transform can target any language ast-grep parses. The CLI (codemod, currently 1.15.3, Apache 2.0) also runs multi-step workflows that mix deterministic transforms with AI steps, which is the hybrid pattern described earlier made concrete.

jscodeshift itself is not dead, by the way. It is still maintained at 17.4.0 and still the right answer if your team already has a pile of transforms written against it.

What it does well: A curated registry means the framework upgrade you need has probably already been written by the framework's own maintainers. Multi-step workflows handle migrations that require several passes in order.

What it doesn't do: The free tier is the engine and the CLI. Campaign tracking across many repos, insights, and the GitHub/Jira integrations sit behind the paid tier.

Pricing: Community $0 forever, unlimited seats · Team from $1,000/month · Enterprise custom.

Commercial Migration Platforms

Moderne

Moderne is OpenRewrite's commercial counterpart, built by the same people. The pitch is scale: instead of running a recipe against one repository from your build tool, Moderne ingests Lossless Semantic Trees for your entire portfolio and runs queries or transformations across all of them at once. Their materials describe operating on a single repo or 100,000 of them, with customers including Walmart and Allstate.

The 2026 addition worth noting is the agent integration. Moderne publishes skills that let an AI agent search a repository fleet and invoke vetted OpenRewrite recipes rather than editing files itself, which keeps the deterministic guarantee while letting the agent handle orchestration and the cases no recipe covers.

What it does well: Cross-repository impact analysis before you commit to a migration, and a single run that touches hundreds of services.

What it doesn't do: It is not a self-serve product. There is no public pricing page and no free tier beyond OpenRewrite itself.

Pricing: Quote only, via demo.

AWS Transform

AWS Transform is the rebuilt home of what used to be Amazon Q Developer's transformation capabilities. It is organized as specialized agents: a mainframe agent that analyzes COBOL on z/OS, decomposes it into business domains, plans modernization waves, and refactors to Java; a Windows agent for .NET Framework and SQL Server; a VMware agent for infrastructure; and a custom transformation agent for Java, Node.js, Python, and organization-specific migrations. The mainframe agent reached general availability in May 2025.

The pricing model is the interesting part. Assessment, the Windows modernization agent, the mainframe modernization agent, and the VMware migration agent are offered at no cost. Only the custom transformation agent and continuous modernization bill, at $0.035 per agent minute, counted only while the agent is actively planning, reasoning, analyzing, or modifying code. User idle time and CLI-side operations like file reads and builds are excluded. AWS Transform for .NET is also available through a Visual Studio extension at no cost.

What it does well: The only tool here that credibly covers mainframe COBOL, Windows .NET, and ordinary Java upgrades under one roof, with the largest workloads priced at zero.

What it doesn't do: It assumes AWS as the destination. If you are modernizing to stay on-prem or to land on another cloud, much of the agent lineup is aimed somewhere you are not going.

Pricing: Assessment and the Windows, mainframe, and VMware agents at no cost · custom transformation and continuous modernization at $0.035 per agent minute.

GitHub Copilot App Modernization

GitHub Copilot app modernization went generally available for Java and .NET in September 2025, and it is the lowest-friction option in this guide because it runs where the code already is. In VS Code or Visual Studio, it assesses the project, identifies outdated frameworks, deprecated APIs, and upgrade blockers, then applies changes, updates build files, and iterates on build errors and CVEs until the project compiles.

Java coverage follows the upgrade path most shops actually need: 8 to 11 to 17 to 21, Spring Boot 2.x to 3.x, javax to jakarta, and deprecated API replacement. The .NET side covers framework upgrades, dependency updates, and containerization for cloud deployment.

What it does well: No new vendor, no new contract, no export of your source to a separate platform. If your team already pays for Copilot, this is included, which makes it the cheapest way to find out whether agentic migration works on your codebase.

What it doesn't do: It works one project at a time, in an editor. There is no portfolio view and no fleet-wide campaign, and agent usage draws down the same monthly AI credit allowance as the rest of Copilot.

Pricing: Not included on Copilot Free · Pro $10/month ($15 in monthly credits) · Pro+ $39/month ($70) · Max $100/month ($200) · also included on Business and Enterprise.

IBM watsonx Code Assistant for Z

If the legacy system in question is on IBM Z, watsonx Code Assistant for Z is the purpose-built option. It runs IBM's Granite models across the mainframe modernization lifecycle: application discovery and analysis, code explanation for programs whose authors retired a decade ago, automated refactoring, and selective COBOL to Java transformation with the business logic preserved.

The deployment flexibility matters for this audience. The foundation models can run on-premises through IBM Software Hub or as a service on IBM Cloud, which is often the deciding factor when the code cannot leave the building for regulatory reasons.

What it does well: Understands COBOL, JCL, and the surrounding z/OS context that general-purpose coding models handle poorly. Code explanation alone justifies it on systems with no surviving documentation.

What it doesn't do: Nothing outside the mainframe estate, and pricing is a sales conversation rather than a signup form.

Pricing: Subscription, quote only. Deployable on-premises via IBM Software Hub or as a service on IBM Cloud.

vFunction

vFunction solves the problem that comes before the migration: deciding what to change. It combines static analysis with runtime observation of a live JVM or CLR to build an architectural picture of a Java or .NET application, identify the domains hiding inside the monolith, surface the dependencies that make decomposition painful, and produce a prioritized roadmap. Their 2026 positioning leans on feeding that architectural context to AI coding tools, on the argument that an agent rewriting a service without knowing the real call graph is guessing.

Licensing is worth understanding up front: vFunction counts each JVM or CLR as an application, with similar codebases counted once and microservices not licensed separately, under a fair-use ratio capping total JVMs and CLRs at 10:1 against business applications. The Assessment Hub is sold in packs of 10, 20, 30, and 50+ applications.

What it does well: Answers "should we even break this apart, and where would the seams go" with evidence from runtime behavior instead of an architect's memory.

What it doesn't do: It is analysis and planning, not a code transformer. You still need one of the tools above to execute, and there is no free tier or published price.

Pricing: Usage-based by application size and count, quote only.

How to Run Your First Automated Migration

Every command below was run locally on August 25, 2026 with Java 24, Maven 3.9.12, and Node 25.5.0. The order matters: cheap, reproducible passes before anything billed by the minute.

1. Branch and baseline the tests. Record what already fails, or the migration diff is unreviewable. Those same tests are the acceptance criteria at the end - verify behavior, not the diff.

2. Run the version upgrade recipe. For Maven, OpenRewrite needs no pom.xml changes at all:

Bash
Copy
mvn -B org.openrewrite.maven:rewrite-maven-plugin:run \
  -Drewrite.activeRecipes=org.openrewrite.java.migrate.UpgradeToJava21 \
  -Drewrite.recipeArtifactCoordinates=org.openrewrite.recipe:rewrite-migrate-java:RELEASE

On a Java 8 project this took 87 seconds cold, 18 seconds on a warm Maven cache, and printed Estimate time saved: 15m.

3. Expect less than you think, then run a second pass. In my run UpgradeToJava21 rewrote maven.compiler.source and maven.compiler.target from 8 to 21 and left every line of Java source untouched. new ArrayList<String>() was still there. That is correct behavior: the migrate recipes handle build configuration and API-level breakage, while source modernization lives in a separate static analysis catalog. Missing this is how teams conclude the tool "did nothing."

Bash
Copy
mvn -B org.openrewrite.maven:rewrite-maven-plugin:run \
  -Drewrite.activeRecipes=org.openrewrite.staticanalysis.UseDiamondOperator \
  -Drewrite.recipeArtifactCoordinates=org.openrewrite.recipe:rewrite-static-analysis:RELEASE

That one rewrote new ArrayList<String>() to new ArrayList<>().

4. Sweep the patterns no recipe covers with ast-grep. Replacing the deprecated Buffer constructor across the JavaScript half takes two commands:

Bash
Copy
npm i --no-save @ast-grep/cli@0.45.2
./node_modules/.bin/ast-grep run \
  -p 'new Buffer($$$ARGS)' \
  -r 'Buffer.from($$$ARGS)' \
  --lang js -U upload.js

Use $$$ARGS, not $A. I ran -p 'new Buffer($A)' first and it reported Applied 1 changes, silently skipping new Buffer(payload, 'utf8') because $A matches exactly one argument. A pattern that quietly matches half your call sites is the most dangerous failure mode in structural search, and nothing in the output warns you.

5. Send the remainder to an agent. Whatever the recipes and patterns did not cover is where Copilot app modernization or an AWS Transform custom job earns its keep. Give it the failing build as the goal, then review the diff like an outside contributor wrote it, because functionally one did.

How to Choose

If you have a Java or Spring codebase: Start with OpenRewrite. It is free, it runs in one command, and the recipes for your exact upgrade path already exist. Add Copilot app modernization for the leftovers.

If you are on JavaScript or TypeScript: Check the Codemod registry for an official transform first, since the framework's own maintainers probably wrote one. Use ast-grep for anything custom.

If the legacy system is a mainframe: AWS Transform if the destination is AWS, watsonx Code Assistant for Z if the code needs to stay on IBM Z or on-premises. Both start with analysis, and both analysis phases are worth running before committing to a direction.

If you have hundreds of repositories: Moderne, or Codemod's Team tier. The bottleneck at that scale is not the transformation, it is tracking which of 400 services have adopted it.

If you don't yet know what to migrate: vFunction for Java and .NET monoliths, or the free assessment agents in AWS Transform. Both produce a prioritized list, which is more useful than a tool that transforms the wrong service quickly.

If you just want to test the water this afternoon: OpenRewrite plus ast-grep, on a low-stakes internal service, in a branch. Total cost zero, total setup time about ten minutes.

What These Tools Still Get Wrong

Silent partial matches. The $A versus $$$ARGS case above applies to every pattern-based tool. Both runs exit zero and print a success line. Always diff the count of matches against a plain grep -c for the same symbol before trusting a sweep.

Recipes cover the popular path only. Spring Boot 2 to 3 is well trodden. Your in-house framework from 2014 is not, and no catalog will ever include it. That gap is exactly where agents help and where their per-minute cost stops being trivial.

Agent cost is legible but not predictable. $0.035 per agent minute is a clear rate, but the minutes depend on how many times the agent has to rebuild after a failed edit. A project with a slow or flaky build burns more of them, and the AWS examples assume the agent converges.

Test coverage is the real constraint. Every tool here changes code faster than a weakly tested codebase can validate it. On a service with 20% coverage, the migration is not the hard part, and no vendor solves that for you.

Review fatigue is real. A 4,000-file mechanical diff gets approved without being read, which quietly defeats the purpose. Split runs by recipe so each pull request contains one kind of change that a reviewer can actually reason about.

Conclusion

The change in 2026 is not that AI can refactor code. It is that the deterministic 80% got cheap enough to run casually, and the remaining 20% got priced by the minute instead of by the quarter.

Run OpenRewrite's version upgrade recipe on your oldest Java service this week. It costs nothing and tells you concretely how much of your backlog was mechanical. Add ast-grep for the sweeps no recipe covers, and check the Codemod registry before writing any JavaScript transform by hand. Bring in a paid platform only at a specific wall: Copilot app modernization when the leftovers need judgment, AWS Transform for mainframes and Windows fleets, Moderne when the unit of work is 400 repositories, vFunction when nobody can agree on what to decompose.

The discipline does not change. Baseline the tests, run one kind of transformation per pull request, and verify behavior rather than reading the diff. The tools got dramatically better at doing the work. They did not get better at knowing whether the result is still correct.

Related Tools and Reading

• XML Formatter - Format and validate the pom.xml, web.xml, and .csproj files these migrations rewrite
• JSON to Java Class Converter - Generate POJOs when replacing legacy data structures with typed Java classes
• NPM Package Info - Check versions, dependencies, and maintainers before running a JavaScript framework codemod
• PyPI Package Inspector - Verify Python package compatibility ahead of a runtime or library upgrade
• Best AI Code Review Tools - Review layer for the diffs these migrations produce
• Best AI Coding Assistants - The IDE-level tools that handle the leftovers after a recipe pass
• Best MCP Servers - How agents get read access to your repos, issues, and CI

Pricing and product capabilities in this category change quickly. Verify current pricing with each vendor before committing to a platform.