The Moderne Technology Stack
The foundation for enterprise code modernization and coding agents.
Four primitives do the heavy lifting: a compiler-accurate code model, deterministic recipes, precomputed semantic context, and sub-second search. Built for the largest enterprise codebases and the coding agents working in them.
The Four Primitives
One stack. Four primitives that do the work.
Loss Semantic Tree (LST)
A compiler-accurate, format-preserving model of your code. Full type attribution, resolved dependencies, and comments preserved across languages and repositories.
Recipes
Deterministic programs that traverse the LST to search, analyze, and transform code. Thousands of open-source recipes in OpenRewrite, extensible with your own.
Moderne Prethink
Precomputed semantic context built from LSTs. Resolved architecture, dependencies, and conventions that agents read directly instead of re-deriving on every prompt.
Moderne Trigrep
Sub-second trigram-indexed search over text and LST. CPU-powered reconnaissance so agents stop burning tokens and GPU cycles on grep-style exploration.
Lossless Semantic Tree: the data layer
The LST is a compiler-accurate representation of your codebase. It captures full type attribution, symbol resolution, dependencies, and generics, while preserving every comment, whitespace, and formatting detail so diffs read like hand-written code.
Deep code understanding. Everything the compiler knows: types, symbols, generics, inheritance, transitive dependencies, all resolved and queryable.
Format fidelity. Indentation, comments, and style preserved so automated diffs are clean, reviewable, and trusted.
Multi-repo scale. LSTs are generated once, serialized to disk, and reused, so the same recipe runs across thousands of repositories in parallel.
Recipes: deterministic programs that run the same way every time
Recipes are programs that traverse the LST to search, analyze, and transform code. They are deterministic: the same recipe run against the same code produces the same result every time. That property is what makes safe, portfolio-wide automation possible.
Thousands of open-source recipes, plus Moderne's proprietary catalog. OpenRewrite community recipes cover migrations, security fixes, code quality, framework upgrades, and dependency management. Moderne adds proprietary recipes for enterprise-grade migrations, security remediation, and Prethink context generation.
Composable and extensible. Recipes chain together into larger workflows. Teams write their own for internal conventions, custom migrations, and org-specific standards.
Safe by design. Operating on the LST rather than raw text means transformations respect types, scope, and style. No regex fragility, no broken builds.
Moderne Prethink: agents read context instead of inferring it
Coding agents waste tokens reconstructing system understanding on every prompt. Prethink runs that work once, deterministically, against the LST, and writes the result where agents can read it directly: structured models of architecture, dependencies, call graphs, and service boundaries, available as resolved facts.
Not RAG, not embeddings, not prompts. Deterministic analysis of semantic code models produces compiler-accurate, reusable context, with guarantees that retrieval and vector approaches can't offer.
Built from LSTs, run as recipes. Prethink inherits the accuracy of the LST and the composability of recipes. Teams customize what gets precomputed for their agents.
Outputs agents can read. Markdown, CSV, and CALM artifacts written to your repo or a context registry. Refreshable via CI, on a schedule, or after major refactors.
Moderne Trigrep: the discovery layer
Agents constantly search code to orient themselves, and every grep burns tokens, compute, and latency. Trigrep replaces repeated file scanning with a persistent trigram index built from text and the LST, shifting the cost of reconnaissance from GPU tokens to CPU-powered lookup.
Sub-second, at any scale. Searching a billion lines of code takes roughly the same time as searching thousands. Trigrep is 13.5× faster than ripgrep on average in Moderne's testing.
Symbol-aware, not just text. Indexes built from the LST carry type and structural context, so agents can combine text discovery with semantic filters and skip the expensive follow-up reads that text-only grep forces.
A prefilter for automation. Search first to narrow scope, then run recipes only where matches exist. A search hit in 47 of 10,000 repos means the recipe runs on 47 (a 99.5% reduction in compute).
Scoped to organizational structure. Searches align with how enterprise teams actually work: by business unit, portfolio, or initiative, so results are immediately actionable, not noise.
Three ways to put the stack to work.
The four primitives power three consumer surfaces: Moderne's own chatbot inside the SaaS platform, a hosted MCP server that connects external coding agents to your full code estate, and a local MCP server that grounds external agents in the repository on a developer's machine.
How it fits together
Discover. Understand. Act.
Each primitive does one job well. Together they give agents and developers a complete loop for portfolio-scale software evolution: fast reconnaissance, resolved context, and deterministic change.
Discovery
Locate the repositories, patterns, and code that matter, across the entire portfolio, in sub-second time.
Understand
Reason from resolved structure: types, dependencies, and architecture, instead of inferring from raw files.
Act
Apply deterministic, format-preserving changes across thousands of repositories with coordinated rollout.
PUT THE STACK TO WORK
Coding agents become enterprise-ready when they run on this stack.
From one-repo experimentation to multi-repo execution: precise targeting, deterministic change, and resolved context, anchored to the LST.
Frequently asked questions
