Moderne

What is Moderne?

Moderne is an automated code refactoring platform that runs deterministic transformation recipes across an entire software estate rather than one repository at a time. It is built by the team that created and still maintains OpenRewrite, the open source refactoring engine.

The approach starts with the Lossless Semantic Tree (LST), a representation of source code that keeps type information and original formatting. Moderne builds these trees in batches, serialises them and stores them, so recipes and searches can run against a codebase without recompiling it each time. A recipe is a rule-based program that makes a specific change, such as a framework upgrade or a security fix.

In 2026 the company positions Moderne as a deterministic layer for AI coding agents. Instead of letting an agent edit files repository by repository, the agent calls a recipe that performs the same change everywhere. Moderne, Inc. lists SOC 2 certification on its website and names large enterprise customers in finance, travel and software.

Key Features

Estate-wide recipe runs are the core capability, because one deterministic change can reach thousands of repositories and produce reviewable pull requests in a single operation.

• Lossless Semantic Tree: Moderne parses code into a tree that keeps types, formatting and comments intact. Because these trees are serialised and stored, later recipe runs and searches skip the slow rebuild step that plain OpenRewrite repeats on every run.
• Recipe catalogue: Recipes cover framework upgrades, language migrations, dependency changes and security remediation. One directory reports more than 10,000 recipes across over 40 domains, mixing Apache-licensed, source-available and proprietary Moderne recipes.
• Mass pull requests: A single run can generate commits and pull requests across many repositories at once. Teams review the diffs in their normal source control workflow, which keeps human approval in place for every change.
• Moderne CLI: The command-line tool builds LSTs and runs recipes on a developer’s own machine. Commands such as mod build, mod run and mod git handle tree creation, recipe execution and multi-repository commits and pushes.
• Agent tools: Trigrep offers type-aware code search and Prethink supplies codebase context to AI agents. The aim is to let an agent pick a proven recipe rather than generate edits from scratch in every repository.
• DevCenter dashboards: DevCenter tracks upgrade and security status across an organisation’s repositories. Leaders can see which projects still run old framework versions and how far a migration has progressed over time.

Pros

Deterministic output is why platform teams pick Moderne: the same recipe makes the same change in every repository, so results are predictable and easy to review.

• Predictable changes: Recipes are rule-based programs, so they do not guess or drift between runs. Reviewers see consistent diffs across hundreds of services, which makes large migrations safer to approve.
• Built for scale: Stored LSTs let one run cover thousands of repositories without rebuilding each project. Organisations with sprawling Java estates gain the most, since manual upgrades would take many months.
• Lower agent costs: Moderne’s own benchmark reported an agent using recipes needed about 30,000 tokens and 3 minutes for a Java 25 migration. The same task without recipes reportedly took 65 million tokens and 45 minutes.
• Open source roots: Any OpenRewrite recipe runs on Moderne, and many recipes are Apache-licensed. Teams can trial changes with free tools before committing budget to the commercial platform.
• Flexible deployment: Moderne offers SaaS, the air-gapped Moderne DX edition and a managed service. Regulated firms can keep code on their own infrastructure, while busy teams can hand migrations to Moderne staff.

Cons

Opaque, quote-only pricing is the catch with Moderne, because there is no public price list or self-serve plan for teams wanting to buy the commercial product.

• No public pricing: Moderne does not publish plan prices, and directories list it as custom pricing. Budget holders must go through a sales process before they can compare costs with alternatives.
• Enterprise focus: The platform is designed for organisations with many repositories and a central platform team. A small team with a handful of projects may get more value from free OpenRewrite alone.
• Learning curve: Writing custom recipes means learning OpenRewrite concepts such as visitors and LSTs. Reviewers note a steeper ramp-up than with general AI coding assistants, so plan time for training.
• Uneven language depth: Java and the JVM ecosystem have the deepest coverage, with Python, C#, JavaScript and Go support expanding. Teams relying mainly on other languages should test recipe coverage before committing.
• Build setup required: The CLI needs the right build tools and toolchains on the PATH to create LSTs. Complex or unusual builds can take extra configuration before the first run succeeds.

Who is Using Moderne?

Large enterprises with big Java estates are Moderne’s main users, and its homepage names Allstate, American Express, Bank of America, Capital One and SAP.

• Platform engineering teams: Central teams run upgrades across every service at once. They use recipes to move frameworks such as Spring Boot forward without asking each squad to do it manually.
• Security teams: Application security staff use proprietary remediation recipes to patch vulnerable patterns. They track progress across repositories through DevCenter dashboards.
• Financial institutions: Banks and insurers named on the site handle very large codebases. They use Moderne to cut technical debt while keeping changes reviewable for audit purposes.
• AI agent builders: Teams running coding agents connect them to Moderne’s tools. The agent calls deterministic recipes for estate-wide changes instead of editing each repository separately.

Pricing

Moderne sells its platform on custom, quote-based terms, with a free community tenant limited to open source projects (official site and directories, October 2026).

We could not read the official pricing page during research, so this table relies on the company blog and directory listings, which agree that no public prices exist.

Disclaimer: enterprise quotes usually depend on repository count and deployment model, so confirm current terms with Moderne directly.

What Makes Moderne Unique?

Stored, serialised LSTs are the concrete differentiator. Most refactoring tools and AI assistants rebuild context for each repository, while Moderne prepares the trees once and reuses them, which is what makes a single run across thousands of repositories practical.

The second difference is its stance on AI agents. Rather than competing with coding assistants, Moderne gives them a deterministic tool to call, and directories report integrations with Amazon Q, GitHub Copilot and Broadcom App Advisor through the OpenRewrite engine.

Compatibilities and Integrations

Moderne works with Java, Kotlin, C#, Python, JavaScript, TypeScript and Go codebases, through a CLI that runs on Linux, macOS and Windows.

• Languages: The homepage lists Java, Spring Boot, C# and .NET, Python, Kotlin, JavaScript and TypeScript. The company blog adds Go and YAML recipes.
• CLI platforms: The CLI installs through a script, Homebrew or Chocolatey. It covers Linux, macOS and Windows machines.
• AI assistants: Directories report integrations with Amazon Q, GitHub Copilot and Broadcom App Advisor. Moderne also offers Trigrep and Prethink for agent use.
• Source control: The mod git command checks out, commits and pushes across many repositories. Changes then arrive as pull requests for normal review.
• Security: The website displays SOC 2 certification. Moderne DX runs air-gapped for teams that cannot send code to a SaaS service.

Moderne Tutorials

Getting started takes six steps, beginning with the free CLI and a small group of test repositories.

1. Install the Moderne CLI using the install script, Homebrew or Chocolatey, then run mod to confirm it works.
2. Run mod doctor to check that your build tools and toolchains are on the PATH.
3. Clone a small set of repositories and run mod build to create their LSTs.
4. Pick a recipe, such as a framework upgrade, and run it with mod run.
5. Review the resulting diffs, then use mod git to commit and push changes for pull request review.
6. Once results look reliable, contact Moderne about the platform or DX edition for estate-wide runs.

How We Rated It

Moderne earns 4.1 out of 5 because its deterministic, estate-wide recipes are excellent, while opaque pricing and a learning curve pull the score down.

Summary

Moderne suits large organisations that need to upgrade, migrate or patch code across hundreds or thousands of repositories with predictable results. Its stored Lossless Semantic Trees and recipe catalogue make estate-wide changes practical in a way single-repository tools cannot match. The main limitation is access, since pricing is quote-only and the product assumes a platform team with time to learn recipe concepts. Language depth is strongest for Java, so other stacks need testing first. Before you talk to sales, run a few recipes with the free CLI or OpenRewrite on a sample of your own repositories to judge the fit.