The evolution of code migrations from rules-based tools to agents

Coding assistants get much of the headlines today, but enterprises face a bigger challenge and opportunity for AI, which is using AI agents to orchestrate large-scale code migrations across their entire organization. Most enterprises have thousands of repositories, legacy systems and significant accumulated technical debt. Orchestrated fleets of AI agents can now support in modernizing these brownfield technology estates systematically.

Before agents the only viable solution for organization-wide migrations were rule-based systems like OpenRewrite, using deterministic ‘recipes’ to apply transformations. While these tools proved useful mostly for enterprises with both Java focussed codebases and the engineering resources to implement the tooling, these rules based approaches remained largely confined to large technology companies due to the complexity and narrow use-case applications.

Agents now present an opportunity to extend and improve on these rule-based foundations, democratizing migration capabilities beyond just large tech organizations. The ultimate vision for organizations here is codebases that are ‘self-healing’ where migrations are routine automated capabilities not disruptive, resource-intensive projects.

Migration attempts with rules-based code transformation

Before diving into agents, it's important to understand what came first. The most prominent pre-AI solution for enterprise migrations is OpenRewrite, a rules-based transformation system that uses hand-written "recipes" to implement changes across large codebases. OpenRewrite emerged from Netflix's familiar enterprise problem: their "freedom and responsibility" culture had accumulated technical debt in outdated libraries and inconsistent patterns. When asked to clean up technical debt manually, developers typically responded: "I don't have time, but if you do it for me, I'll merge it." Netflix created OpenRewrite in response, an automated refactoring engine built on Lossless Semantic Trees (LST), open-sourcing it in 2018.

OpenRewrite's adoption pattern reveals its typical customers: large enterprises with substantial Java codebases, particularly financial institutions. These organizations face challenges with aging systems creating security vulnerabilities and talent acquisition difficulties, as fewer developers want to work with legacy technology. Rules-based systems appeal to regulated industries because they prioritize predictability and auditability over speed, offering the deterministic transformations that compliance frameworks often require.

The challenges of the rules-based approach to migrations

However, whilst rules-based transformation systems represent a significant advance over manual refactoring, they do operate within constraints. By their nature, rule-based approaches are inherently brittle as they work only with pre-determined patterns which require upfront investment to script. This design approach creates a number of challenges:

• No recipes for custom frameworks: Rules based systems struggle with proprietary APIs, custom frameworks, and organization-specific code structures.
• The requirement for expertise: Creating custom recipes requires deep knowledge of Java AST and specific transformation logic that require specialized developers.
• Language and ecosystem constraints: Tools are often designed primarily for JVM languages like Java, Kotlin, Groovy as opposed to Python, JavaScript, or Rust.
• Context-less transformations: Rules operate on syntactic patterns without understanding business logic which can produce functionally inappropriate changes.

However, these gaps in rules-based systems represent exactly where AI agents can compliment and add value: understanding context and business logic, adapting to unique codebase patterns, and validating that changes actually function through comprehensive testing.

Why agent orchestration is the next frontier of migrations

Agents represent an alternative approach to code transformation. Unlike rules-based systems that operate on predefined patterns, coding agents can analyze context, make intelligent decisions, and adapt their approach based on what they discover. Where rules-based systems struggle with the edge cases, proprietary APIs, and context-dependent transformations we discussed earlier, agents can reason through these challenges dynamically.

To understand how this works in practice, it's helpful to examine specific implementations rather than discussing agents in abstract. Ona serves as our example as a platform designed for orchestrating secure development environments that can scale to support enterprise-grade agent operations. Each Ona agent operates within a complete, isolated development environment that functions as a secure sandbox with full access to compilers, testing frameworks, dependency management, and all the development tools a human developer would use. This means agents can not only transform code but also validate their changes by running tests, checking compilation, and iterating on solutions until they work correctly.

The power then comes when you consider fleets of these development environments. While rules-based systems typically operate on individual repositories and struggle with cross-system dependencies, agent orchestration platforms can coordinate hundreds of simultaneous transformations across thousands of repositories using the same configurations and setup that a human would use, as opposed to rigid transformations, providing the contextual intelligence and flexibility that rigid rules-based recipes cannot offer.

Putting 'at scale' migrations into practice with Ona

With Ona, organizations are already leveraging agent orchestration to solve the migration challenges that ruled-based recipes can't address. When security vulnerabilities emerge with agents organizations move from notifications to delegated auto-remediation with pull requests raised across multiple repositories. Enterprises can now execute language migrations at scale such as Java 8 upgrades, and treat architectural standardization as continuous routine to keep codebases inline with ADRs and RFC implementations.

Ona delivers these capabilities with isolated, sandboxed development environments where agents operate with full access to the same compilers, test frameworks, and dependency management tools that human developers use. This means agents don't just statically transform code, they fully validate it, run test suites, and iterate until migrations work. The platform orchestrates hundreds of environments simultaneously while operating entirely within your VPC, maintaining your security perimeter and regulatory compliance.

AI agents represent the infrastructure to make the shift from reactive, manual processes to strategic, automated, centrally-orchestrated migration capabilities. Ready to transform your migration work from disruptive events into routine operational capabilities? Explore how Ona enables secure, orchestrated agent migrations at the scale your organization needs.