cs.SEOct 25, 2026

CodeMeepo: A Multi-Agent Workflow for Repository-Level Code Migration and Optimization

Authors: Farzad Habibi, Changrong Wu, Jinzhou Jiang, Guohan Lu

Organizations: University of California, Irvine · Microsoft · OpenAI

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

Repository-level code migration rewrites an entire project in a new programming language while preserving its observable behavior. It is challenging because behavior spans interdependent modules, dependencies and build infrastructure must be adapted to the target ecosystem, and the source code is often the only specification. Large language model agents can now attempt these migrations end to end, but three challenges remain. First, an agent that writes both the translation and its acceptance tests may overlook the same requirements in both, leaving missing or incorrect behavior undetected. Second, large repositories can exceed a model's context window, and dividing the work into smaller tasks does not ensure that all required behavior is migrated. Third, even behaviorally correct translations may be slower than the original implementation. We present CodeMeepo, a multi-agent pipeline for complete and efficient migration of large repositories. Each milestone is evaluated against a fixed external oracle that the agents neither author nor modify. A separate parity assessment compares source and target components in scope and adds identified gaps back into the plan as required work. Ordered milestones limit the scope of each task, while cumulative regression checks guard against breaking already-migrated behavior. A benchmark-guided optimization phase addresses performance, followed by full-suite conformance testing and repair. Eight specialized agent roles communicate through file artifacts, and a deterministic state machine governs repair, deferral, scope changes, and termination. On nine subjects in three language pairs, CodeMeepo achieves the best pass rate on every subject and passes 18% more tests than a state-of-the-art multi-agent baseline using the same model. On a production daemon, its optimization phase improves half of the benchmarks, by 25% on average.

Figures & tables

Fig. 1: Repository-level code migration: task and challenges.
Fig. 2: CodeMeepo control flow and artifacts. Phase 1 (top) runs left to right; the optional Phase 2 (bottom, dashed) runs right to left after a complete parity verdict. Numbers mark the steps in the order traced in Section III-D . The acceptance oracle between the panels is run by the Validator of each phase, on the cumulative gate GkG_{k} in Phase 1 and in full in the conformance milestone, which reuses the Phase-1 Translator–Validator repair loop. Bands show the target working copy that agents write or run, and tabs name the file each step writes. Validation advances after either a pass or a recorded give-up, and eligible deferred-test retries take precedence over accepting the parity verdict. Terminal failure edges and bootstrap entry points are omitted.
RoleArtifactResponsibility
Translation phase
Analyzeranalysis.mdSource analysis and target design
Scopermilestones.jsonInitial work scope and gap-driven extensions
Plannerplan.json ; skeletonImplementation plan and target structure
TranslatorTarget working copyImplementation, unit tests, and repairs
Validatorreport.jsonTest execution and failure diagnosis
TABLE I: Agent roles and authoritative handoff artifacts.
SubjectSource LOCModulesTests
AlphaTrans, Java →\rightarrow Python
commons-cli2,31522381
commons-csv2,30811298
commons-fileupload1,634300 39
commons-validator6,95063462
CRUST-Bench, C →\rightarrow Rust
TABLE II: Subjects, grouped by suite.
Fig. 3: Test pass rate of every arm on every subject, one panel per suite. E marks a crate that did not compile or a test suite that ended in an error, and is not a zero. CodeMeepo achieves the best pass rate on every subject and passes 18% more tests than ReCodeAgent using the same model.
Fig. 4: Oracle tests gated at each phase-1 milestone of the xcvrd run.
Role (unit of work)Ph.ModelCallsWrote
Analyzer149%66analysis document
Scoper (re-scope)196%9milestone list
Planner198%53plan
Translator (M17)118%16310 crate files
Validator (M16)13.5%16its report
Parity agent196%60its report
TABLE III: The last recorded session of each agent role in the xcvrd run.
Fig. 5: Benchmarks on which the optimized port improved by more than 5% over the unoptimized port, from one back-to-back run of each. Labels give the improvement and the values before and after.
More in this topic

Code Translation

Code translation converts programs between languages, frameworks, and representations while aiming to preserve behavior and sometimes improve safety or performance.

See all 42 papers

Explore similar work

CardsList
Aug 24, 2026

SWE Refactor Bench: Can Coding Agents Complete a Long-Horizon, Whole-Repository Stack Migration?

Modern software systems accumulate technical debt over decades of development, which makes migration expensive and largely manual. As coding agents become increasingly capable at bug fixing, can they autonomously perform such migrations? Existing benchmarks cannot answer this question because they evaluate only behavioural correctness, not whether the migration actually occurred. This leads an easy hack: agents copy the original implementation to make tests pass. We call this Blindness. To address this problem, we introduce SWE Refactor Bench, a benchmark comprising 20 whole-repository migrations, covering 4 kinds of technical debt. A three-stage evaluation protocol measures both migration completeness and behavioural correctness. (1) Migration Audit verifies that the migration occurred. (2) Behavioural Tests measure correctness with a fixed test suite. (3) Agentic Verification uses 6 independent coding agents to generate targeted tests for hidden behavioural differences. Across 520 runs from 8 frontier models and 26 model-effort configurations, only 28 of 520 runs (5.4%5.4\%) pass all three stages, 13 of the 20 tasks receive no accepted solution, and the best model (claude-opus-5) scores 47.0/10047.0/100. Migration completeness and behavioural correctness are distinct abilities: a few runs preserve behaviour by skipping the migration and are stopped at Migration Audit; most attempt it and break behaviour, and are stopped at Behavioural Tests. Agents cannot deliver a perfect migration: among the 340 runs that pass Migration Audit, 58%58\% reach 99%99\% of the fixed checks, yet only 26%26\% reach 100%100\%. Agent capability differs across migration categories: agents score 31.431.4 on build toolchain rewrites but only 5.65.6 on language rewrites. Together, these findings position SWE Refactor Bench as a rigorous testbed for developing coding agents for reliable whole-repository migrations.

Deyao Hong, Yizhe Chi, Wenyi Li +7

Navers Lab, Einsia.AI · Tsinghua University

Automated Software EngineeringAI Coding AgentsAutomated Code RefactoringSoftware Engineering BenchmarksLLM Agent Reliability
AskPDF
Apr 8, 2026

ReCodeAgent: A Multi-agent Workflow for Language-Agnostic Translation and Validation of Large-Scale Repositories

Most repository-level code translation and validation techniques have been evaluated on a single source-target programming language (PL) pair, owing to the complex engineering effort required to adapt new PL pairs. Programming agents can enable PL-agnosticism in repository-level code translation and validation: they can synthesize code across many PLs and autonomously use existing tools specific to each PL's analysis. However, state-of-the-art has yet to offer a fully autonomous agentic approach for repository-level code translation and validation of large-scale programs. This paper proposes ReCodeAgent, an autonomous multi-agent approach for language-agnostic repository-level code translation and validation. Users only need to provide the project in the source PL and specify the target PL for ReCodeAgent to automatically translate and validate the entire repository. ReCodeAgent is the first technique to achieve high translation success rates across many PLs. We compare the effectiveness of ReCodeAgent with four alternative neuro-symbolic and agentic approaches to translate 118 real-world projects, with 1,975 LoC and 43 translation units for each project, on average. The projects cover 6 PLs and 4 PL pairs. Our results demonstrate that ReCodeAgent consistently outperforms prior techniques on translation correctness, improving test pass rate by 60.8% on ground-truth tests, with an average cost of $15.3. We also perform process-centric analysis of ReCodeAgent trajectories to confirm its procedural efficiency. Finally, we investigate how the design choices (a multi-agent vs. single-agent architecture) influence ReCodeAgent performance: on average, the test pass rate drops by 40.4%, and trajectories become 28% longer and persistently inefficient.

Ali Reza Ibrahimzada, Brandon Paulsen, Daniel Kroening +1

University of Illinois Urbana-Champaign Urbana, IL, USA · Amazon Arlington, VA, USA · Amazon Seattle, WA, USA

Code TranslationSoftware Engineering AgentsMulti-Agent Coding
AskPDF
Aug 10, 2026

Entropy-based Code Adversarial Translation for Real-world Repository Migration

LLMs have demonstrated strong capabilities in code generation and automated program repair, but migrating an entire repository rarely produces a runnable application because long-horizon translation challenges LLM-based agents' ability to maintain repository-level migration objectives. In this work, we propose Entropy-based Code Adversarial Translation (ECAT), a multi-agent framework for automated Android-to-HarmonyOS repository migration. ECAT formulates repository migration as adversarial entropy minimization through a generator-discriminator architecture. The discriminator measures migration quality using a unified metric called Code Entropy and produces text gradients that specify both file-level generation directives and the skills needed to execute them. Guided by these optimization signals, the generator iteratively updates the repository, and each update is accepted only if it reduces Code Entropy. Repeated generator--discriminator interactions progressively drive the migration from an initial template toward a functionally complete HarmonyOS repository. Successful low-entropy trajectories are further distilled into a self-evolving memory tree, enabling transferable migration knowledge across repositories. We also introduce A2H-RepoBench, the first real-world benchmark for Android-to-HarmonyOS repository migration, covering applications from tens of thousands to hundreds of thousands of lines of code. Evaluated by node alignment and an agent-based functional judge, ECAT achieves 74.7% overall migration quality and consistently outperforms existing agent-based methods across repositories of different scales.

Yushun Tang, Yisen Cao, Zhicheng Chen +4

Huawei Technologies Co., Ltd. · The Chinese University of Hong Kong

Code TranslationSoftware Engineering AgentsAgentic Code Generation
AskPDF