Pith. sign in

REVIEW 4 major objections 5 minor 3 cited by

Code Graph Model (CGM): A Graph-Integrated Large Language Model for Repository-Level Software Engineering Tasks

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read The paper claims that a 43.00% resolution rate on SWE-bench Lite can be achieved with an open-weight, agentless system by integrating repository dependency structure directly into the LLM's attention, beating the prior best open-weight…

desk verdict Real architectural contribution and broad evaluation, but the 43% headline rests on a non-standard 'resolved' definition that must be clarified before the leaderboard claim is credible. read the letter →

arxiv 2505.16901 v4 pith:NNREA2JD submitted 2025-05-22 cs.SE cs.LG

Hongyuan Tao , Ying Zhang , Zhenhao Tang , Hongen Peng , Xukun Zhu , Bingchang Liu , Yingguang Yang , Ziyin Zhang
show 7 more authors
Zhaogui Xu Haipeng Zhang Linchao Zhu Rui Wang Hang Yu Jianguo Li Peng Di
This is my paper
classification cs.SEcs.LG
keywords codegraphmodelgraph-awareattentionrepository-levelsoftwareengineeringSWE-benchLiteagentlessissuefixingretrieval-augmentedgenerationopen-sourceLLMcompletion
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 asks whether open-source language models can resolve real-world repository-level issues without agent loops or closed-source models, and claims the answer is yes. The proposed Code Graph Model (CGM) builds a graph of code entities and their dependencies, feeds each node's text through an encoder and adapter, and lets the LLM attend only along graph edges via a modified attention mask. Wrapped in a four-module, agentless RAG pipeline and trained with LoRA, CGM-SWE-PY reaches a 43.00% resolution rate on SWE-bench Lite with Qwen2.5-72B. That result would place an open-weight, agentless system ahead of several agent-based systems that rely on Claude-3.5-Sonnet, narrowing the gap to closed-source approaches.

What carries the argument

The carrying mechanism is the graph-aware attention mask combined with compressed node tokens. The code graph itself, built from AST parsing plus lightweight symbol resolution with CHA for inheritance and over-approximation for dynamic calls, defines which nodes exchange messages: each 512-token chunk of node text is encoded and compressed to one token, and attention among these node tokens is restricted to adjacent nodes in the graph, mimicking spatial GNN message passing while the text tokens keep causal attention. The encoder-adapter pair (CodeT5+ with LoRA, plus a two-layer GELU MLP) maps semantic content into the LLM's input space, and the whole encoder-adapter-decoder is trained with LoRA in two phases.

What would settle it

Replace the code graph in the pipeline with a random graph matched in node count and degree distribution and rerun SWE-bench Lite under identical training; if the resolution rate does not drop materially, the paper's structural-integration claim is not doing the work. A simpler check: measure oracle-file recall of the Retriever on the 300 Lite issues and compare against the reported 94% recall; if recall collapses on issues where the fix touches a file the static graph lacks edges for, that is where the method would fail.

Watch

Extended reading notes

Core claim

The central claim is that an open-weight LLM can compete with closed-source agent systems on repository-level issue resolution if the repository's structure is made explicit to the model. CGM encodes each repository as a directed graph with seven node types and five edge types (contains, calls, imports, extends, implements), then integrates it into the LLM in two ways: semantically, node text is encoded by CodeT5+ and projected into the LLM's embedding space by a two-layer MLP adapter, compressing each 512-token chunk into a single node token; structurally, the causal attention mask is replaced between node tokens by the graph's adjacency matrix, so message passing follows code dependencies. After subgraph-reconstruction pre-training and noisy fine-tuning on issue-patch pairs, the model plus a Rewriter-Retriever-Reranker pipeline reaches 43.00% on SWE-bench Lite, ranking first among open-weight methods and second among open-source-systems, surpassing the previous best open-source model-based method by 12.33%.

Load-bearing premise

The graph built from static analysis must contain the dependency edges that matter for an issue; if key call edges are missed or the over-approximation adds enough wrong edges, the structural signal that the ablation credits could be noise.

Editorial extensions

If this is right

  • Open-weight, agentless systems become a viable default for repository-level bug fixing, removing the need for closed APIs and reducing privacy exposure when handling proprietary code.
  • The four-module RAG replaces the ten-step agentless pipeline (e.g., Agentless) with fewer moving parts while slightly improving resolution on the same benchmark, so pipeline complexity is not a prerequisite for strong results.
  • Graph-integrated fine-tuning transfers across backbone sizes (7B, 32B, 70B, 72B), so the approach can be run in resource-constrained settings and improved by swapping in a better base model.
  • On code-completion benchmarks (CrossCodeEval, ComplexCodeEval), CGM-Multi-72B outperforms larger baselines such as Mistral-Large-123B and DeepSeek-V2.5-236B, suggesting structural context matters more than raw parameter count for repository-level understanding.

Reading between the lines

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

  • The method does not test whether the static graph itself, rather than the retrieval pipeline, carries the gain; a likely extension is to compare CGM against a flat-text reader given identical retrieved files, which would isolate the value of structural attention from file selection.
  • Because graph-aware attention is limited to one-hop neighbors per layer, deeper dependency chains must be composed across layers; whether the architecture actually does this is untested, and a layer-wise probe on multi-hop issues would clarify the limit.
  • The 512-token-to-one-node-token compression implies a strong assumption about information retention; a practical test is to increase chunk size or add per-chunk residual tokens and see if hard cases that depend on local variables benefit.
  • If the backbone-generalization trend holds, the architecture is a recipe rather than a single model: releasing stronger open-weight base models or better static analyzers should push the 43% upward without redesigning the graph integration.
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

4 major / 5 minor

Summary. The paper proposes Code Graph Models (CGMs), which inject repository-level code graphs into decoder-only LLMs through two mechanisms: semantic integration (a CodeT5+ encoder and an MLP adapter map node text into 'node tokens') and structural integration (a graph-aware attention mask over node tokens). Training uses subgraph reconstruction pre-training followed by noisy fine-tuning on issue-patch pairs. The authors also build an agentless Graph RAG framework with Rewriter, Retriever, Reranker, and Reader, and report a 43.00% resolution rate on SWE-bench Lite with Qwen2.5-72B, claiming first place among open-weight models, plus results on SWE-bench Verified, SWE-bench-java Verified, and code completion benchmarks (CrossCodeEval, ComplexCodeEval). The paper includes ablations of RAG modules, semantic/structural integration, and pretraining, as well as cost and backbone generalization experiments.

Significance. If the 43.00% SWE-bench Lite result is validated under the official SWE-bench harness, this is a notable result: it would show that an agentless, open-weight system can compete with closed-source agent-based systems, and the graph-aware attention design is a plausible architectural contribution for repository-level code understanding. The paper is transparent in several ways: code and model weights are released, the RAG modules are described with prompts in appendices, and ablations isolate the graph mask, reconstruction pretraining, and each RAG component. The significance is conditional, however, because the central number and the ranking claims depend on an evaluation-protocol clarification and on statistical robustness that the current text does not provide.

major comments (4)
  1. [Appendix C.5.3 (and Section 5.1, Table 1)] The definition of Resolve Rate in Appendix C.5.3 ('a patch is considered resolved if it correctly addresses the issue and is a superset of the ground-truth edits') is not the official SWE-bench evaluation criterion. The official harness applies the model-generated patch and requires the FAIL_TO_PASS tests to pass and the PASS_TO_PASS tests to remain passing; the gold patch is not part of the evaluation condition. If the C.5.3 sentence is literal, the 43.00% headline in the abstract and Table 1 is computed under a different metric and is not comparable with the official leaderboard scores listed in the same table, so the ranking claims (first among open-weight models, +12.33% over Moatless+DeepSeek-V3) are not supported. The paper never states explicitly that the official SWE-bench harness was used; the statements in Section 5.1 and C.5.2 about 'developer-written unit tests' and 'Docker executable environment' do not establish this. Please clarify whether the official harness was used, report the exact evaluation command and version, or rerun the evaluation under the official protocol.
  2. [Table 1 and Appendix C.3] All reported resolution rates in Table 1 are single point estimates from a stochastic pipeline, since Appendix C.3 sets temperature=0.7, top_p=0.8, and repetition_penalty=1.1. The central comparative claims, such as the 12.33% margin over Moatless+DeepSeek-V3 and the 2.33% margin over Agentless+Claude-3.5-Sonnet, are presented without variance, repeated runs, or confidence intervals. Given that the differences are small relative to typical run-to-run variation in LLM sampling, please report at least 3-5 independent runs with means and standard deviations (or bootstrap intervals) for the main benchmark results, and state whether the same seeds were used across compared systems.
  3. [Appendix C.6.2 and Table 3] The ComplexCodeEval results in Table 3 are based on only 100 randomly selected samples per language, but the paper does not report the sampling seed, the selection procedure, or any confidence intervals. With n=100, the reported improvements (for example, CGM-Multi Python EM 43.00 vs. Qwen2.5-72B 28.00) are not statistically grounded as presented. Please provide the exact selection protocol, run-to-run variance, and ideally evaluate on the full benchmark or a substantially larger stratified sample before claiming that CGM 'greatly outperforms' baselines on ComplexCodeEval.
  4. [Table 3 and Appendix C.6.4] The comparison in Table 3 is confounded by fine-tuning: CGM-Multi-72B has been pre-trained and fine-tuned on code completion data, while the baseline models (Mistral-Large-123B, DeepSeek-V2.5-236B, Qwen2.5-72B) are used off-the-shelf with FIM prompting and one-hop expansion. The reported gains on CrossCodeEval and ComplexCodeEval may therefore reflect the additional fine-tuning rather than the graph integration. A cleaner baseline, such as Qwen2.5-72B fine-tuned on the same data with flattened graph text but no graph-aware mask, should be reported for the 72B-scale completion results; the 7B-scale ablation in Table 11 partially addresses this, but Table 3 does not.
minor comments (5)
  1. [Appendix C.7.2] There are typos in this section: 'esults in further enhancements' should be 'results in further enhancements', and 'GGM-Freeze' should be 'CGM-Freeze'.
  2. [Table 13] The table title contains a typo: 'funcitons' should be 'functions'.
  3. [Table 10] The abbreviation 'R3' is used in the table before being defined; please define it explicitly as Rewriter, Retriever, and Reranker.
  4. [Section 5.1 and Appendix C.5.3] The sentence in Section 5.1 that 'All benchmarks utilize developer-written unit tests to verify the correctness of model-generated patches' is difficult to reconcile with the ground-truth-superset definition in C.5.3; these two statements should be aligned.
  5. [Table 1(b)] In Table 1(b), the SWE-Agent row using Qwen2.5-Coder-32B is marked 'No' in the Agent column even though SWE-Agent is an agent-based method; please check the annotation and correct it.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: the 43% result is externally measured on held-out SWE-bench instances; self-citations are not load-bearing, and the Appendix C.5.3 metric wording is an evaluation-validity concern rather than a circular step.

full rationale

The paper's central claim is an empirical benchmark outcome, not a derived quantity. CGM-SWE-PY is fine-tuned on the SWE-bench training split and evaluated on held-out SWE-bench Lite/Verified instances, with the usual filtering for test-set leakage described in Appendix C.1.1. The ablation tables (Tables 10-12) show that removing RAG components, the graph-aware mask, or the reconstruction objective degrades measured performance, so the headline number is not forced by construction. The only notable flag is Appendix C.5.3, which defines a resolved patch as 'a superset of the ground-truth edits,' in tension with Section 5.1's statement that 'all benchmarks utilize developer-written unit tests to verify the correctness of model-generated patches.' This is an evaluation-protocol inconsistency that affects comparability with Table 1, and it should be resolved by reporting official SWE-bench harness results; however, it is not circular, because the model does not receive gold edits at inference and success under this metric is not a tautology. Self-citations (the Galla taxonomy in Section 2.2, E2LLM soft-prompt-compression in Section 4.1, and CodeFuse-CGE as a Retriever component) are related-work or component citations and are not load-bearing for the headline result.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

No new physical or ontological entities are introduced. The 'node token' is an implementation detail, not a postulated entity with independent evidence requirements.

free parameters (4)
  • node token chunk size = 512 tokens
    Each node's text is split into 512-token chunks, each compressed into one node token; this hand-set constant determines context compression and is not derived from the benchmarks.
  • subgraph expansion hop count = 1-hop
    Anchors from Retriever are expanded to one-hop neighbors and connected to the root; the reach of the graph context is a design choice, not an optimized parameter.
  • Reranker top-K = Stage 1: K=10, Stage 2: K=5
    The reranker narrows candidate files to fixed K values; these thresholds directly shape the files the Reader sees and are chosen heuristically.
  • sampling parameters = top_k=20, top_p=0.8, temperature=0.7
    Fixed decoding settings for all LLM inference; single-run results mean the reported resolution rates are point estimates under this stochastic regime.
assumptions (4)
  • domain assumption Static analysis (AST parsing plus lightweight semantic analysis) constructs a code graph that captures dependencies relevant to issue fixing.
    Section 3 and Appendix B.2 describe graph construction; the utility of graph-aware attention depends on the graph's edges being meaningful.
  • domain assumption The over-approximation principle for dynamic calls includes all possible overriding implementations, avoiding missing edges at the cost of spurious ones.
    Appendix B.2 states this explicitly; if spurious edges dominate, the attention mask could spread attention too widely.
  • domain assumption A pretrained CodeT5+ encoder plus a two-layer MLP adapter can align node text with the LLM's embedding space without losing essential semantics.
    Section 4.1 relies on this alignment; the whole node-token mechanism depends on it.
  • domain assumption SWE-bench style resolution rate, measured by held-out unit tests, is a valid proxy for repository-level software engineering ability.
    The paper's central claim is stated in terms of these benchmarks; they are standard in the field but are not a direct measure of real-world deployment.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Code Graph Model (CGM): A Graph-Integrated Large Language Model for Repository-Level Software Engineering Tasks." pith.science (2026). https://pith.science/paper/NNREA2JD

@misc{pith2026250516901,
  author       = {Pith},
  title        = {Pith review of: Code Graph Model (CGM): A Graph-Integrated Large Language Model for Repository-Level Software Engineering Tasks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NNREA2JD}},
  note         = {Machine review of arXiv:2505.16901}
}
read the original abstract

Recent advances in Large Language Models (LLMs) have shown promise in function-level code generation, yet repository-level software engineering tasks remain challenging. Current solutions predominantly rely on proprietary LLM agents, which introduce unpredictability and limit accessibility, raising concerns about data privacy and model customization. This paper investigates whether open-source LLMs can effectively address repository-level tasks without requiring agent-based approaches. We demonstrate this is possible by enabling LLMs to comprehend functions and files within codebases through their semantic information and structural dependencies. To this end, we introduce Code Graph Models (CGMs), which integrate repository code graph structures into the LLM's attention mechanism and map node attributes to the LLM's input space using a specialized adapter. When combined with an agentless graph RAG framework, our approach achieves a 43.00% resolution rate on the SWE-bench Lite benchmark using the open-source Qwen2.5-72B model. This performance ranks first among open weight models, second among methods with open-source systems, and eighth overall, surpassing the previous best open-source model-based method by 12.33%.

Figures

Figures reproduced from arXiv: 2505.16901 by the authors.

Figure 1
Figure 1. Results on SWE-bench Lite. CGM-SWE-PY ranks first among open-weight models. CS-3.5 [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. An example of our repository-level code graph, where “PKG”, “FUNC”, and “T-FILE” [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 4
Figure 4. Illustration of a real-world issue from pytorch-lightning codebase, where a user wants to [PITH_FULL_IMAGE:figures/full_fig_p017_4.png] view at source ↗
Figures from the paper (6 more)
Figure 5
Figure 5. Figure 5: The given issue and the intermediate outputs produced by Rewriter, Retriever, and [PITH_FULL_IMAGE:figures/full_fig_p030_5.png]
Figure 6
Figure 6. Figure 6: Patches generated by CGM (with or without code graph), along with the gold patch. Green [PITH_FULL_IMAGE:figures/full_fig_p031_6.png]
Figure 7
Figure 7. Figure 7: Prompt for Extractor in Rewriter. 32 [PITH_FULL_IMAGE:figures/full_fig_p032_7.png]
Figure 8
Figure 8. Figure 8: Prompt for Inferer in Rewriter. 33 [PITH_FULL_IMAGE:figures/full_fig_p033_8.png]
Figure 9
Figure 9. Figure 9: Prompt for Reranker in Stage 1. 34 [PITH_FULL_IMAGE:figures/full_fig_p034_9.png]
Figure 10
Figure 10. Figure 10: Prompt for Reranker in Stage 2. 35 [PITH_FULL_IMAGE:figures/full_fig_p035_10.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 3 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. WebDesignIter: Co-Evolving Design Knowledge for Repository-Level Front-End Code Generation

    cs.SE 2026-07 conditional novelty 6.0 of 10

    A co-evolving design-and-code knowledge graph improves multi-iteration front-end repository generation by ~9.5 Pass@2 points and cuts input tokens 25–30× versus agent baselines.

  2. GRACE: Graph-Guided Repository-Aware Code Completion through Hierarchical Code Fusion

    cs.SE 2025-09 conditional novelty 5.0 of 10

    GRACE combines a multi-level code graph, hybrid text-structure retrieval, and graph fusion to improve repository-level code completion over vanilla and graph-based RAG baselines.

  3. Enhancing SLMs for Sustainable Code Optimization in Radio-Astronomy

    cs.SE 2026-07 conditional novelty 4.0 of 10

    A 7-billion-parameter coding model with multi-sampling matches a 32-billion-parameter model on repository-level completion under the same time budget, and compiler-error feedback improves pass rates across all models tested.

Reference graph

Works this paper leans on

36 extracted references · 8 canonical work pages · cited by 3 Pith papers

  1. [4]

    Cocomic: Code completion by jointly modeling in-file and cross-file context

    12 Code Graph Model Yangruibo Ding, Zijian Wang, Wasi Uddin Ahmad, Murali Krishna Ramanathan, Ramesh Nallapati, Parminder Bhatia, Dan Roth, and Bing Xiang. Cocomic: Code completion by jointly modeling in-file and cross-file context. arXiv preprint arXiv:2212.10007,

    arXiv

  2. [5]

    The llama 3 herd of models

    Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783,

    arXiv

  3. [6]

    Complexcodeeval: A benchmark for evaluating large code models on more complex code

    Jia Feng, Jiachen Liu, Cuiyun Gao, Chun Yong Chong, Chaozheng Wang, Shan Gao, and Xin Xia. Complexcodeeval: A benchmark for evaluating large code models on more complex code. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, pp. 1895–1906,

    work page 1906

  4. [7]

    Graphcodebert: Pre-training code representations with data flow

    Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie Liu, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, et al. Graphcodebert: Pre-training code representations with data flow. arXiv preprint arXiv:2009.08366,

    arXiv 2009

  5. [9]

    Deepseek-coder: When the large language model meets programming–the rise of code intelligence

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, et al. Deepseek-coder: When the large language model meets programming–the rise of code intelligence. arXiv preprint arXiv:2401.14196,

    arXiv

  6. [10]

    Gaussian error linear units (gelus)

    Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415,

    arXiv

  7. [12]

    Lora: Low-rank adaptation of large language models

    Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685,

    arXiv

  8. [14]

    Contrastrepair: Enhancing conversation-based automated program repair via contrastive test case pairs

    Jiaolong Kong, Mingfei Cheng, Xiaofei Xie, Shangqing Liu, Xiaoning Du, and Qi Guo. Contrastrepair: Enhancing conversation-based automated program repair via contrastive test case pairs. arXiv preprint arXiv:2403.01971,

    arXiv

Show all 36 references
  1. [15]

    A unified debugging approach via llm-based multi-agent synergy

    13 Code Graph Model Cheryl Lee, Chunqiu Steven Xia, Longji Yang, Jen-tse Huang, Zhouruixin Zhu, Lingming Zhang, and Michael R Lyu. A unified debugging approach via llm-based multi-agent synergy. arXiv preprint arXiv:2404.17153,

  2. [16]

    Starcoder: may the source be with you! arXiv preprint arXiv:2305.06161, 2023a

    Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, et al. Starcoder: may the source be with you! arXiv preprint arXiv:2305.06161, 2023a. Wenhua Li, Quang Loc Le, Yahui Song, and Wei-N...

    arXiv

  3. [17]

    Repofuse: Repository-level code completion with fused dual context

    Ming Liang, Xiaoheng Xie, Gehao Zhang, Xunjin Zheng, Peng Di, Hongwei Chen, Chengpeng Wang, Gang Fan, et al. Repofuse: Repository-level code completion with fused dual context. arXiv preprint arXiv:2402.14323,

    arXiv

  4. [18]

    E2llm: Encoder elongated large language models for long-context understanding and reasoning

    Zihan Liao, Jun Wang, Hang Yu, Lingxiao Wei, Jianguo Li, and Wei Zhang. E2llm: Encoder elongated large language models for long-context understanding and reasoning. arXiv preprint arXiv:2409.06679,

    arXiv

  5. [19]

    Deepseek-v3 technical report

    Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437, 2024a. Haotian Liu, Chunyuan Li, Qingyang Wu, and Yong Jae Lee. Visual instruction...

    arXiv

  6. [20]

    Repoagent: An llm-powered open-source framework for repository-level code documentation generation

    Qinyu Luo, Yining Ye, Shihao Liang, Zhong Zhang, Yujia Qin, Yaxi Lu, Yesai Wu, Xin Cong, Yankai Lin, Yingli Zhang, et al. Repoagent: An llm-powered open-source framework for repository-level code documentation generation. arXiv preprint arXiv:2402.16667,

    arXiv

  7. [21]

    Lingma swe-gpt: An open development-process-centric language model for automated software improvement

    Yingwei Ma, Rongyu Cao, Yongchang Cao, Yue Zhang, Jue Chen, Yibo Liu, Yuchen Liu, Binhua Li, Fei Huang, and Yongbin Li. Lingma swe-gpt: An open development-process-centric language model for automated software improvement. arXiv preprint arXiv:2411.00622, 2024a. Yingwei Ma, Qi...

    arXiv

  8. [22]

    Hello gpt-4o

    14 Code Graph Model OpenAI. Hello gpt-4o. https://openai.com/index/hello-gpt-4o/ , 2024a. OpenAI. Introducing swe-bench verified. https://openai.com/index/introducing-swe-bench -verified/, 2024b. Siru Ouyang, Wenhao Yu, Kaixin Ma, Zilin Xiao, Zhihan Zhang, Mengzhao Jia, Jiawei...

    arXiv

  9. [23]

    Training software engineering agents and verifiers with swe-gym

    Jiayi Pan, Xingyao Wang, Graham Neubig, Navdeep Jaitly, Heng Ji, Alane Suhr, and Yizhe Zhang. Training software engineering agents and verifiers with swe-gym. arXiv preprint arXiv:2412.21139, 2024a. Zhiyuan Pan, Xing Hu, Xin Xia, and Xiaohu Yang. Enhancing repository-level cod...

    arXiv

  10. [24]

    Introducing gemini 2.0: our new ai model for the agentic era

    Sundar Pichai, Demis Hassabis, and Koray Kavukcuoglu. Introducing gemini 2.0: our new ai model for the agentic era. https://blog.google/technology/google-deepmind/google-gemini-a i-update-december-2024/ ,

    2024

  11. [27]

    Lloco: Learning long contexts offline

    Sijun Tan, Xiuyu Li, Shishir Patil, Ziyang Wu, Tianjun Zhang, Kurt Keutzer, Joseph E Gonzalez, and Raluca Ada Popa. Lloco: Learning long contexts offline. arXiv preprint arXiv:2404.07979,

    arXiv

  12. [29]

    Agentless: Demystifying llm-based software engineering agents

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. Agentless: Demystifying llm-based software engineering agents. arXiv preprint arXiv:2407.01489,

    arXiv

  13. [30]

    Swe-fixer: Training open-source llms for effective and efficient github issue resolution

    Chengxing Xie, Bowen Li, Chang Gao, He Du, Wai Lam, Difan Zou, and Kai Chen. Swe-fixer: Training open-source llms for effective and efficient github issue resolution. arXiv preprint arXiv:2501.05040,

    arXiv

  14. [31]

    Acwrecommender: A tool for validating actionable warnings with weak supervision

    Zhipeng Xue, Zhipeng Gao, Xing Hu, and Shanping Li. Acwrecommender: A tool for validating actionable warnings with weak supervision. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), pp. 1876–1880. IEEE,

    2023

  15. [32]

    An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayi- heng Liu, Fei Huang, Haoran Wei, et al. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115, 2024a. John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karth...

    arXiv

  16. [33]

    Repocoder: Repository-level code completion through iterative retrieval and generation

    Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. Repocoder: Repository-level code completion through iterative retrieval and generation. arXiv preprint arXiv:2303.12570, 2023a. Kechi Zhang, Jia Li, Ge Li, Xianjie S...

    arXiv

  17. [34]

    The recall of each component on SWE-bench-java Verified are lower than those on SWE-bench Lite. One possible reason may be that the issues in SWE-bench Lite usually requires modifying one file, while the issues on the SWE-bench-java Verified sometimes need to modify multiple f...

    2024

  18. [35]

    It includes 3,897 Java samples from 1,055 Java code repositories and 7,184 Python samples from 2,107 Python code repositories

    is a new benchmark for evaluating the performance of large code models in complex development scenarios. It includes 3,897 Java samples from 1,055 Java code repositories and 7,184 Python samples from 2,107 Python code repositories. Following the original setup of this benchmar...

    2024

  19. [36]

    combined

    is a solution for the Context-Latency Conundrum in repository-level code completion. It constructs Code Knowledge Graph by analyzing the code graph dependencies in the repository and uses the repository-level graphs for retrieval. It integrates the Rationale Context obtained b...

    2024

  20. [2009]

    Assumption hierarchy for a cha call graph construction algorithm

    Jason Sawin and Atanas Rountev. Assumption hierarchy for a cha call graph construction algorithm. In 2011 IEEE 11th International Working Conference on Source Code Analysis and Manipulation, pp. 35–44. IEEE,

    2011

  21. [2011]

    Graph transformers: A survey

    Ahsan Shehzad, Feng Xia, Shagufta Abid, Ciyuan Peng, Shuo Yu, Dongyu Zhang, and Karin Verspoor. Graph transformers: A survey. arXiv preprint arXiv:2407.09777,

  22. [2016]

    Metagpt: Meta programming for multi-agent collaborative framework

    Sirui Hong, Xiawu Zheng, Jonathan Chen, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, et al. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352,

    arXiv

  23. [2018]

    Qwen2-vl: Enhancing vision-language model’s perception of the world at any resolution

    Peng Wang, Shuai Bai, Sinan Tan, Shijie Wang, Zhihao Fan, Jinze Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, et al. Qwen2-vl: Enhancing vision-language model’s perception of the world at any resolution. arXiv preprint arXiv:2409.12191, 2024a. Xingyao Wang, Yangyi Chen...

    arXiv

  24. [2020]

    Unixcoder: Unified cross-modal pre-training for code representation

    Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. Unixcoder: Unified cross-modal pre-training for code representation. arXiv preprint arXiv:2203.03850,

    arXiv

  25. [2021]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, et al. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186,

    arXiv

  26. [2022]

    Evaluating large language models trained on code

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374,

    arXiv

  27. [2023]

    R2c2-coder: Enhancing and benchmarking real-world repository- level code completion abilities of code large language models

    Ken Deng, Jiaheng Liu, He Zhu, Congnan Liu, Jingxin Li, Jiakai Wang, Peng Zhao, Chenchen Zhang, Yanan Wu, Xueqiao Yin, et al. R2c2-coder: Enhancing and benchmarking real-world repository- level code completion abilities of code large language models. arXiv preprint arXiv:2406.01359,

    arXiv

  28. [2024]

    Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement

    Antonis Antoniades, Albert Örwall, Kexun Zhang, Yuxi Xie, Anirudh Goyal, and William Wang. Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement. arXiv preprint arXiv:2410.20285,

    arXiv

Pith tools

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