🤖 AI

TransAgent: Enhancing LLM-Based Code Translation via Fine-Grained Execution Alignment

TransAgent is a novel multi-agent system that enhances LLM-based code translation by utilizing fine-grained execution alignment to localize and eliminate errors, achieving significant performance improvements over existing methods on a newly constructed benchmark designed to mitigate data leakage.

Original authors: Zhiqiang Yuan, Weitong Chen, Hanlin Wang, Xin Peng, Zhenpeng Chen, Yiling Lou

Published 2026-04-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhiqiang Yuan, Weitong Chen, Hanlin Wang, Xin Peng, Zhenpeng Chen, Yiling Lou

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to translate a complex novel from English into Japanese. You hire a brilliant but slightly overconfident AI translator. The AI does a great job with the vocabulary and grammar, but it makes a few subtle mistakes: it changes the tense of a verb in a way that alters the meaning, or it forgets to include a crucial plot twist.

If you ask the AI to "fix it," it often just guesses, sometimes making things worse because it doesn't know exactly where the story went off the rails. It's like trying to fix a car engine by randomly tightening bolts without a mechanic's manual or a diagnostic tool.

TransAgent is a new, smarter system designed to solve this exact problem. Instead of just asking the AI to "translate and hope," TransAgent acts like a team of expert editors and mechanics working together to ensure the translation is perfect.

Here is how it works, broken down into simple steps:

1. The Team of Four Specialists

TransAgent isn't just one AI; it's a multi-agent system, meaning it uses four different "characters" (or AI agents) that pass the work along like a relay race:

The Translator (Initial Code Translator): This is the first runner. It takes the original code (the source) and tries to translate it into the new language (the target). It also creates a set of "test questions" to check if the translation works.
The Grammar Police (Syntax Error Fixer): If the translated code has basic spelling or grammar mistakes (like missing a semicolon or a bracket), this agent catches them. It reads the computer's error messages, translates those confusing technical errors into plain English instructions, and tells the AI exactly how to fix the grammar.
The Mapmaker (Code Aligner): This is the secret sauce. When you translate code, the structure often changes. A single line in the original might become three lines in the new version, or the order might get shuffled. The Mapmaker breaks the original code into logical "chunks" (like chapters in a book) and creates a precise map showing which chunk in the original matches which chunk in the translation. This prevents the team from getting lost.
The Detective (Semantic Error Fixer): This is the most important role. Sometimes the code runs without crashing, but it gives the wrong answer (e.g., calculating a tax rate incorrectly). The Detective doesn't just look at the code; it runs both the original and the translation side-by-side. It watches the "inner thoughts" of the programs (the values of variables as they change) to find exactly where the two stories diverge. Once it finds the exact line where the logic broke, it tells the AI, "Fix this specific part using these specific numbers."

2. The "Side-by-Side" Superpower

The biggest problem with previous methods was that they tried to fix errors by looking at the final result only. It's like a teacher grading a math test and seeing the wrong answer, but not knowing which step the student messed up.

TransAgent is different. It uses Fine-Grained Execution Alignment.

Analogy: Imagine two runners running a race. One is running on a track in London (the original code), and the other is running on a track in Tokyo (the translated code).
Old Way: You only check who crossed the finish line first. If the Tokyo runner is slower, you tell them to "run faster," but you don't know if they tripped at the start or got tired at the end.
TransAgent Way: You put cameras on both runners at every single mile marker. You compare their speeds, heart rates, and steps at every moment. If the Tokyo runner slows down exactly when the London runner turns a corner, you know, "Ah, the turn was translated poorly!" You can then give the Tokyo runner specific instructions to fix just that turn.

3. Why It Matters

The paper shows that this "team approach" is a game-changer:

It's Smarter: It fixes errors that other AI translators miss, especially when translating between very different languages (like Python to Java).
It's Faster: Because it knows exactly where to look, it doesn't waste time guessing. It fixes the problem in fewer attempts.
It's Reliable: The researchers tested it on brand-new coding tasks that the AI had never seen before (to ensure the AI wasn't just memorizing answers), and TransAgent still crushed the competition.

The Bottom Line

TransAgent turns code translation from a "black box" guessing game into a transparent, step-by-step engineering process. By breaking the code into manageable chunks, mapping them precisely, and comparing how they actually behave while running, it ensures that the translated code isn't just grammatically correct, but actually works exactly like the original.

It's the difference between a machine that just swaps words and a master craftsman who rebuilds the engine to run perfectly in a new car.

1. Problem Statement

Code translation is critical for software modernization, performance optimization, and technology transitions. While Large Language Models (LLMs) have advanced this field, they still suffer from significant quality issues, including:

Syntax Errors: Violations of the target language's grammar.
Semantic Errors: The translated code compiles but produces incorrect outputs compared to the source code.

Limitations of Existing Approaches:

Traditional Learning-Based Methods: Require massive parallel training data (which is scarce) and suffer from data leakage issues when evaluated on recent benchmarks.
Current LLM-Based Methods (e.g., UniTrans): Rely on "translate-then-fix" paradigms. However, they lack fine-grained fault localization. They attempt to fix errors using only end-to-end reasoning based on whole-program input/output test cases. This makes it difficult for LLMs to pinpoint the exact location of semantic errors (e.g., a specific line causing a logic flaw) or to understand complex runtime discrepancies, leading to marginal improvements in repair accuracy.

2. Methodology: TransAgent

TransAgent is a novel multi-agent system designed to eliminate translation errors by localizing error-prone code blocks via fine-grained execution alignment. It consists of four collaborative agents:

A. Initial Code Translator

Function: Generates test inputs for the source program and produces an initial target program using the LLM.
Strategy: Leverages test cases in the prompt to guide the initial translation, following the "translate-then-fix" paradigm.

B. Syntax Error Fixer

Function: Iteratively fixes syntax errors in the target program.
Process:
1. Validation: Uses compilers/interpreters to detect syntax errors.
2. Planning: Converts vague compiler error messages into specific fix suggestions via an LLM.
3. Patch Generation: The LLM generates patches based on these refined suggestions.
4. Iteration: Repeats until the code compiles or a loop is detected.

C. Code Aligner (Core Innovation)

Problem Addressed: Statement-level alignment (used by prior work like TransMap) is fragile when source lines map to multiple target lines or when code order shifts.
Solution: A Block-Level Alignment strategy combining Control Flow Graph (CFG) analysis and LLMs.
1. Block Extraction: The source program is decomposed into atomic blocks based on CFG (e.g., continuous sequences of statements or control flow statements like if/for).
2. Block Mapping: The LLM maps these source blocks to corresponding blocks in the target program.
Benefit: This coarse-grained, structural alignment is more robust than line-by-line mapping, handling line shifts and structural reordering effectively.

D. Semantic Error Fixer

Function: Detects and repairs semantic errors by comparing runtime behaviors.
Process:
1. Execution & Logging: Both source and target programs are instrumented to log runtime variable values at the entry/exit of each aligned block.
2. Error Localization: The system compares the runtime values of aligned blocks. If a target block's values diverge from its aligned source block, it is flagged as the Error Block.
3. Patch Generation: Two strategies are used to fix the identified block:
  - Vanilla Strategy: Uses static code context.
  - Value-Aware Strategy: Includes the specific runtime values (e.g., data overflow values) in the prompt to guide the LLM.
4. Verification: The patched code is re-executed to verify if the runtime divergence is resolved.

3. Key Contributions

Novel Multi-Agent System: Proposes TransAgent, which integrates syntax fixing, CFG-based block alignment, and runtime-guided semantic fixing to outperform existing LLM-based translators.
Hybrid Code Mapping Strategy: Introduces a Code Aligner that synergizes static program analysis (CFG) with LLMs to achieve robust block-level alignment, solving the fragility of statement-level mapping.
Fine-Grained Execution Alignment: Pioneers a method for semantic error repair that localizes faults by comparing intermediate runtime states of source and target programs, rather than relying solely on end-to-end test case results.
New Benchmark: Constructs a new code translation benchmark using programming tasks released after August 2023 (post-dating most LLM training data) to mitigate data leakage and ensure fair evaluation.

4. Experimental Results

The authors evaluated TransAgent on their new benchmark (Java, Python, C++ pairs) and compared it against state-of-the-art baselines (TransCoder, UniTrans, Agentless).

Overall Effectiveness (RQ1):
- TransAgent achieved 87.1% higher accuracy than the learning-based TransCoder.
- It outperformed the LLM-based UniTrans by 33.3% in translation accuracy (e.g., Python-to-Java CA improved from 56.2% to 89.5%).
- Statistical significance was confirmed ( $p \ll 0.001$ ).
Ablation Study (RQ2):
- Both the Syntax Error Fixer and Semantic Error Fixer provided substantial gains.
- The Semantic Error Fixer was particularly effective in dynamic-to-static language translations (e.g., Python to Java), improving performance by up to 7.1%.
- The combination of "Value-Aware" and "Vanilla" fixing strategies proved complementary.
Repair Accuracy (RQ3):
- TransAgent achieved an average 56.7% improvement in repair accuracy over Agentless (a leading LLM-based repair tool).
- It outperformed a variant using TransMap (TransAgentTM) by 14.5%, validating the superiority of the CFG-based block alignment.
Generalization (RQ4):
- The system demonstrated strong generalizability across different backbone LLMs (including Llama-3-8B, ChatGLM2-6b, and Deepseek-Coder-33B), consistently improving their translation performance.
Efficiency:
- TransAgent completed repairs in fewer iterations (92% within 2 iterations) and had lower average time costs (19s vs. 24s for UniTrans).

5. Significance

Paradigm Shift: Moves code translation from "black-box" end-to-end fixing to a white-box, execution-guided approach that explicitly localizes faults before repair.
Scalability: The block-level alignment and runtime comparison approach offers a scalable solution for translating complex code where structural differences between languages are significant.
Reliability: By constructing a leakage-free benchmark, the paper provides a more rigorous standard for evaluating future code translation models.
Practical Impact: The ability to handle semantic errors (like data overflow or logic mismatches) with high precision makes TransAgent a viable tool for real-world software modernization and cross-language migration tasks.