Moderne
Also known as: Moderne.ai, Moderne Platform, Moderne SaaS
- Moderne
- Moderne is a commercial SaaS platform, built by the maintainers of open-source OpenRewrite, that runs deterministic refactoring recipes across hundreds of repositories at once using a compiler-accurate code representation called the Lossless Semantic Tree (LST).
Moderne is a commercial SaaS platform, built by the maintainers of OpenRewrite, that applies deterministic refactoring recipes across hundreds of code repositories at once instead of editing each one by hand.
What It Is
Picture a bank with three thousand code repositories, all needing the same security patch by Friday. Editing each one by hand is slow and error-prone; asking a language model to rewrite them one at a time risks silent regressions — where the code still compiles but quietly behaves differently. Moderne exists to make that kind of fleet-wide change a single, predictable operation rather than three thousand separate gambles.
The platform is the commercial side of OpenRewrite, the open-source refactoring engine that Moderne builds and maintains. According to Moderne, its core technology is the Lossless Semantic Tree (LST) — a compiler-accurate, type-aware model of your code that is built once, serialized, and then reused across every repository. Think of it as a detailed structural blueprint of a codebase: unlike a plain abstract syntax tree, it remembers types, formatting, and dependencies, so a tool can reason about what the code means, not just how it reads.
Changes are expressed as recipes — rule-based scripts that transform that blueprint and produce identical results every time they run. According to Moderne, the platform applies these recipes across hundreds of millions of lines of code spanning many repositories simultaneously. In 2026 the company describes itself as “the agent tools company”: it exposes its recipe catalog as callable tools for a multi-repo AI agent named Moddy, so a language model can decide what to change while the deterministic recipes carry out the change itself.
How It’s Used in Practice
The most common reason teams reach for Moderne is large-scale migration and remediation — the work that shows up when an organization has outgrown manual change. A platform team facing a Java version upgrade, a Spring Boot migration, or an urgent library vulnerability across hundreds of services runs an existing recipe (or writes one) and applies it everywhere at once, then reviews the results as pull requests rather than hand-editing each project.
A newer pattern pairs Moderne with AI code migration directly. Instead of trusting a language model to rewrite code line by line — the approach most prone to silent regressions — the model picks which recipes to apply, and the compiler-accurate recipes do the editing. The determinism lives in the tool; the judgment lives in the model.
Pro Tip: Start with a recipe that already exists in the OpenRewrite catalog before writing your own. Run it on a handful of repositories first and diff the results — the value of a deterministic tool is that the same recipe behaves identically at three repos and at three thousand, so a small pilot tells you exactly what the full rollout will do.
When to Use / When Not
| Scenario | Use | Avoid |
|---|---|---|
| Migrating a framework or language version across many repositories | ✅ | |
| Applying a security fix to a large fleet of services at once | ✅ | |
| Enforcing a change that can be expressed as a deterministic rule | ✅ | |
| A one-off edit to a single small project | ❌ | |
| A refactor that needs human design judgment per file | ❌ | |
| Expecting it to invent the migration logic with no recipe at all | ❌ |
Common Misconception
Myth: Moderne is an AI tool that uses a language model to rewrite your code. Reality: Moderne’s core engine is deterministic — recipes operating on the Lossless Semantic Tree produce the same result on every run. The AI layer (the Moddy agent) sits on top and chooses which recipes to apply; it does not do the rewriting itself.
One Sentence to Remember
Moderne is what code migration looks like when you want it to be repeatable instead of probabilistic: deterministic recipes do the editing at fleet scale, and any AI in the loop decides what to run rather than rewriting the code itself. If you are evaluating AI-driven migration, the question worth asking is which part is deterministic and which part is the model guessing.
FAQ
Q: Is Moderne the same thing as OpenRewrite? A: No. OpenRewrite is the open-source refactoring engine; Moderne is the commercial SaaS platform that maintains it and runs its recipes across many repositories at once, adding scale, serialized code models, and tooling around the engine.
Q: Does Moderne use AI to change my code? A: Not for the actual edits. The rewriting is deterministic, driven by recipes. According to Moderne, its AI agent Moddy uses those recipes as tools — the model decides what to apply, and the recipe makes the change.
Q: What is a Lossless Semantic Tree? A: According to Moderne, it is a compiler-accurate, type-aware representation of code, built once and reused across repositories. Unlike a plain abstract syntax tree, it preserves types and formatting, so tools can transform code safely at scale.
Sources
- Moderne: Moderne: The Agent Tools Company - Company positioning and multi-repo scale.
- Moderne: Moderne & OpenRewrite Auto-Refactoring Tech - Lossless Semantic Tree and recipe technology.
Expert Takes
The interesting property here is determinism. A recipe operating on a compiler-accurate tree is a pure function: same input, same output, every time. That is the opposite of a language model, which samples from a probability distribution and can produce a different rewrite on each run. Moderne’s design keeps the transformation deterministic and reserves the probabilistic part for choosing what to do, not doing it.
This is a clean separation of concerns. The recipe is the specification — an explicit, reviewable rule for what “migrated” means — and the agent is the orchestrator that selects and sequences those specs across a fleet. If you have ever watched an AI rewrite work in one repo and break in another, this is the structural fix: pin the behavior in a deterministic tool, and let the model handle routing, not editing.
The strategic shift is that migration stops being a project and becomes a capability. When you can apply the same change across an entire portfolio on demand, technical debt moves from a backlog item to something you retire continuously. The companies that treat large-scale refactoring as routine infrastructure, rather than a rare all-hands emergency, will move faster on every framework shift that follows.
Determinism is reassuring, but it relocates the risk rather than removing it. A recipe applied across thousands of repositories spreads a mistake just as efficiently as a fix. And once an agent is choosing which transformations to run, the accountability question sharpens: when a fleet-wide change quietly alters behavior somewhere downstream, who reviewed the decision — a person, or the model that selected the recipe?