Pith. sign in

REVIEW 3 major objections 4 minor 58 references

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

T0 review · 3 major / 4 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read ECAT claims that whole-repository code migration can be driven by adversarial entropy minimization, reporting 74.7% average quality on 50K–300K-line Android-to-HarmonyOS benchmarks.

desk verdict A credible scale-up of adversarial generator-discriminator migration with a genuinely useful benchmark and meticulous protocol; the headline win is probably real, but the eval needs variance, calibration, and a wider test set before the numbers become canonical. read the letter →

arxiv 2608.09273 v2 pith:K7JAH3LW submitted 2026-08-10 cs.AI cs.SE

Yushun Tang , Yisen Cao , Zhicheng Chen , Lin Peng , Junkang Mao , Fengyi Song , Yantao Jia This is my paper · ORCID
classification cs.AIcs.SE
keywords repositorymigrationAndroid-to-HarmonyOSCodeEntropyminimizationmulti-agentLLMgenerator-discriminatortextgradientsA2H-RepoBench
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that moving a whole software repository from one platform to another can be turned into an optimization problem rather than a one-shot translation. An LLM generator and an independent LLM discriminator take turns: the discriminator scores the repository's Code Entropy and writes file-level text gradients, and the generator's edits are accepted only when entropy falls. On three real Android applications of 50K, 120K, and 300K lines, the resulting ECAT system reaches 74.7 percent average migration quality, measured by structural node alignment and an agent-based functional judge, compared with 46.4 percent for the strongest existing agentic baseline. The paper also introduces A2H-RepoBench, the first benchmark for Android-to-HarmonyOS repository migration at this scale, and argues that this makes large-scale repository translation a tractable, iteratively verifiable engineering task.

What carries the argument

The engine is Code Entropy, defined in Eq. (2) as $H(\mathcal{R}_t)=W^\top E/\mathbf{1}^\top W$, where $E\in[0,1]^{14}$ collects normalized defect scores across static and dynamic dimensions and $W$ holds fixed importance weights; the paper notes this is an analogy for repository disorder rather than a strict information-theoretic entropy. This single scalar serves as the optimization target that the whole adversarial loop obeys: the discriminator estimates it, the text gradient turns the gap into concrete repairs, Eq. (6) admits only entropy-decreasing updates, and Eq. (7) terminates the run. The second load-bearing mechanism is the self-evolving memory tree, a hierarchical store of coarse-to-fine migration patterns distilled from accepted trajectories that both agents retrieve so that proven repairs are reused instead of rediscovered.

What would settle it

Run ECAT on one benchmark repository while recording the discriminator's per-feature entropy judgments, then compare them with the held-out Agent-as-Judge labels on the same final state. If features judged Full do not systematically have lower entropy than those judged Partial or Missing, or if the stopping criterion fires with entropy near 0.01 while Agent-as-Judge is far below 0.7, then Code Entropy is not tracking correctness and the reported quality is an artifact of the proxy. A cheaper probe: delete a single compiled file from the final migrated repository and check whether the entropy estimate rises sharply; if it does not, the metric cannot be driving the claimed repairs.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that repository migration quality can be driven monotonically upward by minimizing a repository-level Code Entropy $H(\mathcal{R}_t)=W^\top E/\mathbf{1}^\top W$, a weighted average of fourteen generic defect dimensions covering compilation, placeholder stubs, permission parity, data-layer parity, navigation reachability, runtime liveness, and UI consistency, each estimated by deterministic rules or LLM judges. A discriminator agent exposes high-entropy regions and emits structured text gradients that localize defects and recommend skills; a generator agent repairs the repository; Eq. (6) accepts an update only if the estimated entropy strictly decreases; Eq. (7) stops the loop only when entropy remains below threshold over a sliding window. On A2H-RepoBench, the paper reports 74.7 percent average quality, beating every agentic baseline, and reports that removing the independent discriminator collapses average quality to 28.4 percent, with the failure worsening as repositories grow. It further claims that successful low-entropy trajectories distilled into a hierarchical memory tree transfer across repositories, roughly halving iterations and tokens on the smallest repository.

Load-bearing premise

The entire loop works only if the discriminator's Code Entropy estimate honestly tracks true migration correctness; if the estimate is systematically over-optimistic, useful repairs get rejected and the run terminates on a repository that is still broken.

Editorial extensions

If this is right

  • Migration quality can scale with the number of optimization rounds rather than with context window, so 100K–300K-line repositories become migratable by iterative agents instead of ending as thin shells.
  • Separating generation from evaluation is the core design choice: the paper's ablation drops average quality from 74.7% to 28.4% when one agent both edits and evaluates, with the gap widening at larger repository scale.
  • Cross-repository memory reuse should cut iteration count and token cost materially; on Gallery, ECAT converges in 38 iterations and about 65M tokens instead of 66 iterations and about 125M tokens without memory.
  • Weaker or cheaper base LLMs can still reach comparable functional quality because the entropy acceptance criterion converts extra rounds into extra repairs; on Gallery, a faster low-cost model reaches 87.1% Agent score with more iterations.
  • Artifact size scaling with source size indicates genuine repository coverage rather than thin shells; ECAT generates from 34K lines on Gallery to 173K lines on Meshtastic, while self-terminating baselines stop at 2K–6K lines.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The generator–discriminator recipe with monotone acceptance is not tied to Android or HarmonyOS: any long-horizon code transformation with a checkable proxy — tests, builds, or a judge — could be optimized the same way, so applying ECAT to unrelated language pairs such as Java-to-Kotlin or Python-to-Rust would be a direct stress test.
  • The paper shows memory transfer only across its three benchmark repositories; a stricter test would build the memory tree exclusively on one unrelated application domain and measure zero-shot transfer, separating generalizable patterns from repository-specific ones.
  • Code Entropy could double as an evaluation metric rather than just an optimization target if its fourteen dimensions were calibrated against the held-out feature checklist; the paper reports no such calibration, so a reader could test whether entropy thresholds predict Agent-as-Judge scores across repositories.
  • The small average gap between ECAT with and without dynamic entropy (74.7 vs 72.7) suggests static checks carry most of the quality signal, so for repositories where emulator time dominates, a static-only variant may be nearly as effective at much lower cost.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes ECAT, an entropy-based generator-discriminator framework for migrating Android repositories to HarmonyOS. It defines a Code Entropy score H(R) as a weighted sum of 14 static and dynamic quality dimensions, accepts a generator update only when the discriminator's estimated entropy decreases (Eq. 6), and terminates when the estimate remains below epsilon for a sliding window (Eq. 7). Successful trajectories are distilled into a shared hierarchical memory tree. The paper also introduces A2H-RepoBench, with three real-world Android repositories of roughly 50K, 120K, and 300K LOC, and reports that ECAT attains 74.7% average migration quality versus 46.4% for the strongest baseline (ReCodeAgent), with node-alignment and Agent-as-Judge metrics. The appendix contains an ablation without the independent discriminator, cost analysis, cross-repository memory transfer, and an unusually detailed reproducibility protocol with hashed and sealed evaluation inputs.

Significance. If the reported numbers hold up, the main contribution is substantial: decoupling generation from evaluation in a long-horizon repository-migration task, with an explicit demonstration that a self-evaluating agent collapses to 28.4% average quality while the independent-discriminator version reaches 74.7% (Table 2). The paper also ships reproducible evaluation machinery, including sealed source references, hashed inputs, deterministic greedy node matching with a frozen threshold, and packaged baseline prompts, which is a genuine strength. The cross-repository memory-transfer result (Fig. 5) is interesting and economically significant. However, the central concern is that the optimization target and the headline metric both rely on LLM per-feature completeness judgments with no independent calibration; until that is addressed, the magnitude of the claimed advantage over baselines is not fully established.

major comments (3)
  1. [§3.2, Table 5, §4.1, App. C.2] The discriminator's feature_check dimension (Table 5: "per-feature completeness against the Android counterpart", weight 0.30) is an LLM judgment conceptually identical to the Agent-as-Judge metric in Eq. (9), which is also an LLM judgment of per-feature completeness against the Android source (App. C.2). Equations (6) and (7) make the entire optimization and termination depend on the discriminator's Code Entropy estimate, so any systematic optimism in LLM completeness scoring would cause premature termination and inflate the reported quality. The paper separates the two by withholding the checklist, but both judgments share the same failure mode: an LLM must agree that a behavior is substantively implemented. No human or executable validation of either LLM completeness judgment is reported. The w/o Discriminator ablation (Table 2) demonstrates exactly the premature-stopping failure that an over-optimistic completeness criterion can produce, so the reader cannot currently distinguish between real functional completeness and a self-consistent LLM-completeness score. I ask for external validation on at least one repository (e.g., human-labeled feature scores), an agreement/correlation analysis between the discriminator's feature_check scores and the Agent-as-Judge judge, and a convergence check in which ECAT is run beyond the Eq. (7) criterion to see whether the external quality metric actually plateaus.
  2. [§4.2, Table 1, App. B.2] The claim that ECAT "consistently outperforms across repositories of different scales" rests on one repository per scale (Gallery 50K, AntennaPod 120K, Meshtastic 300K), and repository identity is confounded with scale because the three apps differ in domain, architecture, and dependency structure. In addition, all baseline numbers in Table 1 are single runs, whereas ECAT is averaged over three runs with standard deviations. Adding at least one more repository at a comparable scale, or reporting multiple baseline runs, is needed to support a general cross-scale conclusion; without it, the result is a three-point comparison rather than a scale study.
  3. [§4.3, App. A.3] The statement that "ECAT is insensitive to the exact weight values" is not fully supported by the reported sensitivity analysis. Setting all weights uniformly to 0.1 on Gallery changes Node Alignment from 84.9% to 73.3% (Agent-as-Judge changes from 85.6% to 83.4%). The Agent metric is largely preserved, and the appendix correctly notes that the stopping threshold should be calibrated jointly with the weights, but the 11.6-point drop in Align is material. The text should either qualify the insensitivity claim or extend the sensitivity analysis to include the stopping threshold and the alignment metric.
minor comments (4)
  1. [§3.1/§3.2] The term "entropy" is used as an analogy, as the authors state explicitly in §3.2, but the notation H(R) and stopping threshold epsilon could easily be read as information-theoretic quantities. A brief footnote clarifying that Code Entropy is a quality proxy and not a Shannon entropy would help avoid confusion.
  2. [§4.3, Fig. 5] Figure 5 shows memory transfer to Gallery from the other two repositories, which is a clean test. The experimental setup should state explicitly how the memory tree is initialized for AntennaPod and Meshtastic in the main results, and whether the transfer effect is evaluated symmetrically across all repositories.
  3. [App. C.3] Node Alignment depends on the platform-friction filtering list and the frozen matching threshold theta=0.30, both of which affect the denominator D_s directly. A sensitivity analysis for theta and a careful listing of the filtering decision process would strengthen the claim that the alignment metric is not affected by arbitrary filtering choices.
  4. [§4.2, App. A.2] Table 4 compares three base LLMs for ECAT but not for the baselines; a sentence clarifying whether the baselines were run only with DeepSeek-V4-Pro would improve comparability, since a stronger or weaker base model could change the baseline rankings.

Circularity Check

1 steps flagged · score 4.0 of 10

The discriminator's feature_check entropy dimension and the Agent-as-Judge metric are both LLM-based per-feature completeness judgments against the Android source, so the 74.7% headline is partially self-confirming; Node Alignment and emulator-based dynamic entropy keep the central claim from being fully circular.

  1. other [Sec. 3.2 Eq. (2), Eq. (6)-(7), Table 5; Sec. 4.1 Eq. (9)]
    "Table 5: 'feature_check | Per-feature completeness against the Android counterpart | LLM | 0.30'. Sec. 4.1: 'Agent-as-Judge evaluates functional preservation using a predefined feature checklist'; 'Agent = 1/N Σ s_i'; 'the discriminator in Sec. 3 evaluates only application-agnostic defect categories, with no access to the feature checklist used at evaluation.'"

    The acceptance rule in Eq. (6) accepts a candidate only when H(R_{t+1}) < H(R_t), and Eq. (7) stops when H ≤ 0.01. H is the weighted sum of Eq. (2), one of whose largest components (weight 0.30) is feature_check, an LLM estimate of 'per-feature completeness against the Android counterpart.' The headline value 74.7% is largely the Agent-as-Judge score of Eq. (9), also an LLM judgment scoring each feature Full/Partial/Missing against the Android source. Both share the same single point of failure: an LLM's assessment that a behavior is substantively implemented. Withholding the checklist from the discriminator removes the exact enumeration but not the shared LLM completeness judgment.

full rationale

The derivation is not wholly circular: no parameter is fitted to the benchmark, no load-bearing self-citation chain appears, and the memory-tree transfer experiment is supported by cross-repository entropy-reduction dynamics rather than by the final metric alone. The one substantive circular element is that the discriminator's feature_check entropy dimension and the Agent-as-Judge evaluator are the same kind of LLM judgment of per-feature completeness against the Android source, so the functional-quality half of the 74.7% headline is partly self-confirming. The paper attempts to isolate them by withholding the checklist from the discriminator, but the underlying estimation task remains shared. Node Alignment is deterministic and independent, and dynamic entropy uses emulator screenshots rather than code-completeness judgments, which limits the circularity to a score of 4 rather than a higher value.

Assumptions & free parameters 4 free parameters · 5 assumptions · 2 invented entities

The central claim rests less on mathematical axioms than on domain assumptions about the reliability of LLM-based judgments: the discriminator's Code Entropy must track true correctness, the Agent-as-Judge protocol must measure functional preservation, and the three chosen repositories must represent real migration workloads. The only hand-set numeric parameters that materially shape results are the entropy weights and stopping threshold, with the node-alignment threshold and platform-friction list affecting the reported scores. The framework invents Code Entropy and a memory tree; the former is the optimization target itself and is not independently validated.

free parameters (4)
  • Entropy dimension weights w_i = 0.3 for compile, entry_nav, feature_check, data_layer_parity, permission_parity; 0.1 for the other nine dimensions
    Coarse weights chosen by hand for repair prioritization (Sec. 3.2, Table 5). The paper claims insensitivity, but uniform-weight sensitivity on Gallery changes Align from 84.9 to 73.3 and Agent from 85.6 to 83.4 (A.3), so the structural metric is moderately sensitive to this choice.
  • Entropy stopping threshold epsilon and window size l = epsilon=0.01, l=2
    Fixed for all experiments (Sec. 4.2). The supplementary admits epsilon should be calibrated jointly with the weights (A.3), so the stopping rule is a hand-set parameter affecting iteration count and final quality.
  • Node alignment matching threshold theta = 0.30
    Frozen threshold for PASG node matching in the evaluation protocol (C.3). It affects the reported Align scores, though it is an evaluation parameter rather than a method parameter.
  • Platform-friction filtering list = view-binding glue, BroadcastReceiver, AsyncTask, RecyclerView view holders, app-widget providers, platform-specific…
    Hand-curated removal of Android entities from the alignment denominator (C.3). This inflates Align by reducing the denominator, and the list is an evaluation choice.
assumptions (5)
  • domain assumption Code Entropy estimates by the discriminator (LLM and rule-based verifiers) are unbiased proxies for real migration correctness and functional completeness.
    The acceptance rule (Eq. 6) and stopping rule (Eq. 7) rely entirely on the discriminator's own estimate; no calibration of the estimate against final metrics is reported (Sec. 3.3).
  • domain assumption The Agent-as-Judge feature checklist and the a2h-evaluate protocol validly measure functional preservation at the repository level.
    The central 74.7% figure is computed from this LLM-judged protocol; its reliability is not independently established beyond the paper's own rubric (Sec. 4.1, C.2).
  • domain assumption The three selected repositories (Gallery, AntennaPod, Meshtastic) are representative of real-world Android-to-HarmonyOS migration workloads.
    Benchmark claims generality across scales but contains one application per scale, all open-source apps (Sec. 4.1).
  • domain assumption CodeGraph and the platform-agnostic semantic graph abstraction preserve the architectural entities needed for a fair structural comparison.
    Node Alignment depends on this tool and on the hand-defined PASG node classes and edge conversions (C.3).
  • domain assumption The 'generic defect' entropy dimensions do not encode application-specific functional requirements from the evaluation checklist.
    The paper asserts this isolation in Sec. 3.2 and 4.1, but the feature_check dimension is an LLM judgment of per-feature completeness, which is conceptually the same task as Agent-as-Judge (Table 5).
invented entities (2)
  • Code Entropy H(R)
    purpose: Unified repository-level quality objective that the generator optimizes and the discriminator estimates; it appears in Eq. (2), the acceptance rule Eq. (6), and the stopping rule Eq. (7).
    It is a hand-weighted sum of rule-based and LLM-judged scores, explicitly an analogy rather than information-theoretic entropy (Sec. 3.2). No independent validation shows it tracks functional correctness outside the paper's own evaluation, and its feature_check component overlaps with the test metric.
  • Self-evolving memory tree M_t
    purpose: Shared hierarchical memory that stores distilled low-entropy trajectories and transfers skills across repositories (Fig. 3).
    This is a novel data structure in the framework, but its contents are distilled from the same discriminator estimates, so its benefit is measured only through the paper's own pipeline and not verified independently.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Entropy-based Code Adversarial Translation for Real-world Repository Migration." pith.science (2026). https://pith.science/paper/K7JAH3LW

@misc{pith2026260809273,
  author       = {Pith},
  title        = {Pith review of: Entropy-based Code Adversarial Translation for Real-world Repository Migration},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/K7JAH3LW}},
  note         = {Machine review of arXiv:2608.09273}
}
read the original abstract

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.

Figures

Figures reproduced from arXiv: 2608.09273 by the authors.

Figure 1
Figure 1. Overview of ECAT. ECAT performs repository migration through an entropy-based adversarial optimization loop between a Generator agent G and an independent Discriminator agent D. Starting from a source Android repository, the Generator iteratively updates the target HarmonyOS repository, while the Discriminator estimates Code Entropy and produces text gradients to guide repository optimization. The optimization termi… view at source ↗
Figure 2
Figure 2. An example of the structured text gradient gener [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. The hierarchical self-evolving memory tree. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Qualitative comparison of the migrated AntennaPod home page. ECAT preserves the original Android layout, [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Optimization dynamics of ECAT on the Gallery repository. (a) Evolution of Code Entropy during adversarial optimization. A memory tree (MT) built from successful migration trajectories of the other repositories enables faster entropy reduction and earlier convergence. (…
Figure 6
Figure 6. Figure 6: Qualitative UI comparisons. Top: Gallery in the same empty-media state. Bottom: Meshtastic in the disconnected [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

58 extracted references · 8 linked inside Pith

  1. [1]

    2024 , eprint =

    TextGrad: Automatic ``Differentiation'' via Text , author =. 2024 , eprint =

    2024

  2. [2]

    2023 , eprint =

    ExpeL: LLM Agents Are Experiential Learners , author =. 2023 , eprint =

    2023

  3. [3]

    Advances in Neural Information Processing Systems (NIPS) , year =

    Generative Adversarial Nets , author =. Advances in Neural Information Processing Systems (NIPS) , year =. 1406.2661 , archivePrefix =

    arXiv

  4. [4]

    Advances in Neural Information Processing Systems 17 (NIPS) , pages =

    Semi-supervised Learning by Entropy Minimization , author =. Advances in Neural Information Processing Systems 17 (NIPS) , pages =

  5. [5]

    Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , year =

    ADVENT: Adversarial Entropy Minimization for Domain Adaptation in Semantic Segmentation , author =. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , year =. 1811.12833 , archivePrefix =

    arXiv

  6. [6]

    Advances in Neural Information Processing Systems (NeurIPS) , year =

    Unsupervised Translation of Programming Languages , author =. Advances in Neural Information Processing Systems (NeurIPS) , year =. 2006.03511 , archivePrefix =

    arXiv 2006

  7. [7]

    Advances in neural information processing systems , volume=

    Judging llm-as-a-judge with mt-bench and chatbot arena , author=. Advances in neural information processing systems , volume=

  8. [8]

    International conference on learning representations , volume=

    Large language models cannot self-correct reasoning yet , author=. International conference on learning representations , volume=

Show all 58 references
  1. [9]

    International Conference on Learning Representations , volume=

    Teaching large language models to self-debug , author=. International Conference on Learning Representations , volume=

  2. [10]

    2021 , eprint =

    Evaluating Large Language Models Trained on Code , author =. 2021 , eprint =

    2021

  3. [11]

    Proceedings of the 45th International Conference on Software Engineering (ICSE) , pages =

    Automated Program Repair in the Era of Large Pre-trained Language Models , author =. Proceedings of the 45th International Conference on Software Engineering (ICSE) , pages =. 2023 , doi =

    2023

  4. [12]

    2020 , eprint =

    CodeBLEU: a Method for Automatic Evaluation of Code Synthesis , author =. 2020 , eprint =

    2020

  5. [13]

    2024 , eprint =

    Large Language Models for Software Engineering: A Systematic Literature Review , author =. 2024 , eprint =

    2024

  6. [14]

    2023 , eprint =

    Code Llama: Open Foundation Models for Code , author =. 2023 , eprint =

    2023

  7. [15]

    ACM Transactions on Software Engineering and Methodology , year =

    A Survey of Learning-based Automated Program Repair , author =. ACM Transactions on Software Engineering and Methodology , year =

  8. [16]

    2024 , url=

    John Yang and Carlos E Jimenez and Alexander Wettig and Kilian Lieret and Shunyu Yao and Karthik R Narasimhan and Ofir Press , booktitle=. 2024 , url=

    2024

  9. [17]

    Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis , pages=

    Autocoderover: Autonomous program improvement , author=. Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis , pages=

  10. [18]

    International Conference on Learning Representations , volume=

    MetaGPT: Meta programming for a multi-agent collaborative framework , author=. International Conference on Learning Representations , volume=

  11. [19]

    Chen Qian and Wei Liu and Hongzhang Liu and Nuo Chen and Yufan Dang and Jiahao Li and Cheng Yang and Weize Chen and Yusheng Su and Xin Cong and Juyuan Xu and Dahai Li and Zhiyuan Liu and Maosong Sun , booktitle =

  12. [20]

    Zhang and Michael Luck and Qingwen Bu and Yuhao Qing and Heming Cui , year =

    Dong Huang and Jie M. Zhang and Michael Luck and Qingwen Bu and Yuhao Qing and Heming Cui , year =. 2312.13010 , archivePrefix =

    arXiv

  13. [21]

    Code Generation with

    Tal Ridnik and Dedy Kredo and Itamar Friedman , year =. Code Generation with. 2401.08500 , archivePrefix =

    arXiv

  14. [22]

    2024 , eprint =

    Agentless: Demystifying LLM-based Software Engineering Agents , author =. 2024 , eprint =

    2024

  15. [23]

    2024 , eprint =

    HyperAgent: Generalist Software Engineering Agents to Solve Coding Tasks at Scale , author =. 2024 , eprint =

    2024

  16. [24]

    2024 , eprint =

    MAGIS: LLM-Based Multi-Agent Framework for GitHub Issue Resolution , author =. 2024 , eprint =

    2024

  17. [25]

    International Conference on Learning Representations , year =

    OpenHands: An Open Platform for AI Software Developers as Generalist Agents , author =. International Conference on Learning Representations , year =

  18. [26]

    2023 , eprint =

    Toolformer: Language Models Can Teach Themselves to Use Tools , author =. 2023 , eprint =

    2023

  19. [27]

    2025 , eprint =

    DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning , author =. 2025 , eprint =

    2025

  20. [28]

    2606.00001 , archivePrefix =

    Loop Engineering: The Anthropic Playbook for Designing Systems That Prompt Your Agents , year =. 2606.00001 , archivePrefix =

    arXiv

  21. [29]

    HarmonyOS NEXT Developer Documentation , year =

  22. [30]

    Transactions of the association for computational linguistics , volume=

    Lost in the middle: How language models use long contexts , author=. Transactions of the association for computational linguistics , volume=

  23. [31]

    arXiv preprint arXiv:2310.08560 , year=

    MemGPT: Towards LLMs as Operating Systems , author=. arXiv preprint arXiv:2310.08560 , year=

    arXiv

  24. [32]

    International Conference on Machine Learning , pages=

    Agent-as-a-Judge: Evaluate Agents with Agents , author=. International Conference on Machine Learning , pages=. 2025 , organization=

    2025

  25. [33]

    Advances in Neural Information Processing Systems , volume=

    Llm evaluators recognize and favor their own generations , author=. Advances in Neural Information Processing Systems , volume=

  26. [34]

    Simple Gallery , year =

  27. [35]

    Meshtastic Android , year =

  28. [36]

    Advances in Neural Information Processing Systems , volume=

    The unreasonable effectiveness of entropy minimization in llm reasoning , author=. Advances in Neural Information Processing Systems , volume=

  29. [37]

    International Conference on Learning Representations , year=

    Tent: Fully Test-Time Adaptation by Entropy Minimization , author=. International Conference on Learning Representations , year=

  30. [38]

    International Conference on Learning Representations (ICLR) , year=

    SWE-bench: Can Language Models Resolve Real-World GitHub Issues? , author=. International Conference on Learning Representations (ICLR) , year=

  31. [39]

    IEEE Transactions on Software Engineering , volume=

    RepoTransBench: A Real-World Multilingual Benchmark for Repository-Level Code Translation , author=. IEEE Transactions on Software Engineering , volume=. 2026 , doi=

    2026

  32. [40]

    2026 , howpublished =

    Colby McHenry , title =. 2026 , howpublished =

    2026

  33. [41]

    2025 IEEE/ACM 47th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP) , pages=

    Arkanalyzer: The static analysis framework for openharmony , author=. 2025 IEEE/ACM 47th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP) , pages=. 2025 , organization=

    2025

  34. [42]

    Proceedings of the 16th International Conference on Internetware , pages =

    Lina Gong and Chen Wang and Di Cui and Yujun Huang and Mingqiang Wei , title =. Proceedings of the 16th International Conference on Internetware , pages =. 2025 , doi =

    2025

  35. [43]

    2026 , eprint =

    Kunwu Zheng and Pengyu Xue and Zhen Yang and Xiran Lyu and Peishi Lai and Mengying Zhao and Yutian Tang and Huizhi Zhang and Xianhang Li and Linhao Wu and Chengyi Wang , title =. 2026 , eprint =

    2026

  36. [44]

    Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering , pages =

    Runlin Liu and Yuhang Lin and Yunge Hu and Zhe Zhang and Xiang Gao , title =. Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering , pages =. 2024 , doi =

    2024

  37. [45]

    2026 , eprint =

    Bang Xie and Senjian Zhang and Zhiyuan Peng and Wei Chen and Chenhao Ying and Yuan Luo , title =. 2026 , eprint =

    2026

  38. [46]

    Proceedings of the ACM on Software Engineering , volume =

    Ali Reza Ibrahimzada and Kaiyao Ke and Mrigank Pawagi and Muhammad Salman Abid and Rangeet Pan and Saurabh Sinha and Reyhaneh Jabbarvand , title =. Proceedings of the ACM on Software Engineering , volume =. 2025 , doi =

    2025

  39. [47]

    Findings of the Association for Computational Linguistics: EMNLP 2025 , pages =

    Xing Zhang and Jiaheng Wen and Fangkai Yang and Yu Kang and Pu Zhao and Junhao Wang and Maoquan Wang and Yufan Huang and Shengyu Fu and Elsie Nallipogu and Qingwei Lin and Yingnong Dang and Saravan Rajmohan and Dongmei Zhang , title =. Findings of the Association for Computati...

    2025 doi

  40. [48]

    2026 , eprint =

    Ali Reza Ibrahimzada and Brandon Paulsen and Daniel Kroening and Reyhaneh Jabbarvand , title =. 2026 , eprint =

    2026

  41. [49]

    2026 , eprint =

    Xuefeng Li and Nir Ben-Israel and Yotam Raz and Belal Ahmed and Doron Serebro and Antoine Raux , title =. 2026 , eprint =

    2026

  42. [50]

    doi:10.20944/preprints202607.1328.v1 , url =

    Guanting Dong and Xiaoshuai Song and Yuyang Hu and Jiajie Jin and Chenghao Zhang and Yifei Chen and Xiaoxi Li and Huaying Yuan and Xinyu Yang and Tongyu Wen and Jiejun Tan and Hongjin Qian and Shijue Huang and Junting Lu and Zhenyu Li and Wanjun Zhong and Yutao Zhu and Tat-Sen...

  43. [51]

    OpenReview Archive , year=

    Self-Improving Agents in the Era of Experience: A Survey of Self- to Meta-Evolution , author=. OpenReview Archive , year=

  44. [52]

    The Eleventh International Conference on Learning Representations , year =

    Shunyu Yao and Jeffrey Zhao and Dian Yu and Nan Du and Izhak Shafran and Karthik Narasimhan and Yuan Cao , title =. The Eleventh International Conference on Learning Representations , year =

  45. [53]

    arXiv preprint arXiv:2603.22455 , year=

    Skillrouter: Skill routing for llm agents at scale , author=. arXiv preprint arXiv:2603.22455 , year=

    arXiv

  46. [54]

    Raymond Li and Loubna Ben Allal and Yangtian Zi and Niklas Muennighoff and Denis Kocetkov and Chenghao Mou and Marc Marone and Christopher Akiki and Jia Li and Jenny Chim and others , title =. Trans. Mach. Learn. Res. , year =

  47. [55]

    Advances in neural information processing systems , volume=

    Self-refine: Iterative refinement with self-feedback , author=. Advances in neural information processing systems , volume=

  48. [56]

    Proceedings of the 36th annual acm symposium on user interface software and technology , pages=

    Generative agents: Interactive simulacra of human behavior , author=. Proceedings of the 36th annual acm symposium on user interface software and technology , pages=

  49. [57]

    Advances in neural information processing systems , volume=

    Reflexion: Language agents with verbal reinforcement learning , author=. Advances in neural information processing systems , volume=

  50. [58]

    Intrinsically-Motivated and Open-Ended Learning Workshop @NeurIPS2023 , year=

    Voyager: An Open-Ended Embodied Agent with Large Language Models , author=. Intrinsically-Motivated and Open-Ended Learning Workshop @NeurIPS2023 , year=

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.