Pith. sign in

REVIEW 2 major objections 5 minor 83 references

Coding-agent repository context can be served from reusable multi-view indexes that are incrementally maintained orders of magnitude faster than rebuilds, with latency and token savings tied to explicit output-match checks.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-01 02:28 UTC pith:WZDQXQL3

load-bearing objection CodeNib is one of the more honest systems papers around, but the headline 8.7x graph speedup rests on an exact-match gate against a rebuild oracle that the paper itself shows is noisy for Rust/TS — that is the thing to fix before taking the number at face value. the 2 major comments →

arxiv 2607.25431 v1 pith:WZDQXQL3 submitted 2026-07-28 cs.SE

CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents

Zhongming Yu , Hengjia Yu , Boqin Yuan , Shuting Zhao , Yizhao Chen , Aryan Dokania , Mihir Jagtap , Jiayu Chang
show 7 more authors
Yitong Ma Yash Jayswal Wentao Ni Hejia Zhang Zhaoling Chen Gangda Deng Jishen Zhao
This is my paper
classification cs.SE
keywords repository context servingcoding agentsmaterialized viewsincremental maintenancesymbol graph repairvector reusestatic and live navigationcontext policies
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

This paper argues that repository context for coding agents should be treated as a data-lifecycle problem: build reusable lexical, dense, and structural views once per commit, map every result to repository-relative source ranges, maintain each view through its own incremental path, and serve them through one runtime with a manifest recording what is available. The central evidence is that when incremental updates reproduce the output of an independent fresh rebuild, graph repair is 8.7x and vector reuse 25.4x faster at the median; static navigation matches live language-server results on 63% of requests and is 4.7x faster on that subset; and context policies deliver 50-87% token reductions while preserving localization across five models. The paper's distinctive move is to report these gains only under explicit validity boundaries — conditional on output matches — rather than as unconditional speedups.

Core claim

CodeNib's claim is that a multi-view repository serving system can make coding-agent context reuse measurable and economical. The key mechanism is the repository manifest M_c, which binds lexical (BM25/trigram), dense (embedding), and structural (symbol graph) views to a commit and to repository-relative source addresses, while leaving each view its own physical layout and update path. On the maintenance side, LSP-assisted graph repair and content-addressed vector reuse are compared offline against independent rebuilds, and speedups are reported only when the outputs match (Eqs. 1-2). On the serving side, static navigation is compared against live language servers on normalized path/start-li

What carries the argument

The central object is the repository manifest M_c and the multi-view materialization it controls: a lexical view (BM25/trigram), a dense view (FAISS embeddings), and a structural view (typed symbol graph with occurrence records), all aligned to repository-relative source ranges. The manifest records per-artifact status, commit, configuration, and capabilities, making stored state discoverable without a shared storage engine. The argument's load-bearing mechanism is the conditional output-match gate: incremental maintenance results (Eqs. 1-2) and static/live navigation equality (projection N) are verified offline against independent rebuilds or live servers, so reported speedups and latency s

Load-bearing premise

The whole maintenance-speedup argument rests on treating an independent fresh rebuild as the deterministic ground truth for what incremental output should be; the paper's own audit shows fresh rebuilds are not exactly reproducible for Rust and TypeScript/JavaScript, so speedups are measured against a reference that is itself noisy for 2 of the 4 language groups.

What would settle it

Rebuild the same eight repositories with a pinned compiler/language-server toolchain and run the incremental maintenance; if the Rust and TypeScript/JavaScript fresh-rebuild outputs are not bitwise reproducible across identical runs (as Appendix F's 3/4 changed-scope exactness suggests), then the 8.7x/25.4x conditional speedups cannot be attributed to the maintenance path alone. Conversely, if the match rate on a new, larger request sample for Q3 stays around 63% with the same per-language definition/reference split, the static provider's conditional latency advantage would be confirmed as a s

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Incremental graph repair and vector reuse can make repository-context maintenance an order of magnitude cheaper than full rebuilds on transitions where outputs match (8.7x/25.4x median).
  • Static symbol navigation can absorb a majority of definition requests (80-99% match per language) and some references at 4.7x lower median latency, but references match only 22-73%, so live servers remain necessary.
  • Context policies with eager top-10 candidate injection plus one-time compaction preserve the localization margin at 50-87% fewer provider-reported trajectory tokens across five models.
  • The manifest's capability-driven loading lets one failed view (e.g., vector build) not invalidate successful siblings, so partial availability is explicit.
  • Operation-specific validity boundaries prevent conflating exact maintenance with projection-compatible navigation with policy-dependent delivery.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the conditional speedups hold in production, a practical recipe is to run incremental maintenance and fall back to rebuild when the offline match gate fails, combining 25x typical speedups with guaranteed exactness.
  • The 63% static/live match rate suggests a hybrid navigation service: route requests whose normalized location sets are predictable (e.g., definitions) to the static provider and keep live LSP for references; the workload-level latency saving would then depend on the request mix, not the conditional 4.7x.
  • The one-time compaction policy's model-dependent effect (123% tokens on Haiku vs 28% on Gemma) hints that context delivery should be per-model tuned rather than globally optimized — a claim the paper leaves open.
  • The same-commit rebuild audit (99.75% edge F1, but Rust/TS failures) suggests that the incremental-maintenance speedup numbers could shift if ground truth were measured against a more deterministic oracle; an editor would like to see the speedups re-reported on the subset of repositories where fresh rebuilds are exactly reproducible.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

2 major / 5 minor

Summary. CodeNib is a multi-view repository-context data system that materializes lexical, dense, and structural views per commit, maintains selected views incrementally, and serves ranked retrieval, symbol navigation, and bounded context to coding agents through a manifest-mediated runtime. The paper's main contributions are: (C1) a view compiler that links heterogeneous artifacts to repository-relative source ranges; (C2) view-specific incremental maintenance whose speedups are reported only when the updated artifact exactly matches an independently rebuilt target; and (C3) a cost-visible agent runtime with evaluated context-delivery policies. Across 100 snapshots and five evaluation questions, the headline results are: 8.7x/25.4x median graph/vector update speedups on matching transitions, a 4.72x median live/static latency ratio on the 63% of navigation requests whose normalized locations match, and 50–87% token reductions with localization preserved for selected policies across five agent models. The paper is notable for reporting null results (graph expansion), conditional claims (static/live compatibility), and explicit validity boundaries throughout.

Significance. If the results hold, CodeNib provides a principled data-systems blueprint for repository-context serving that separates ranked candidates, source locations, and prompt history instead of collapsing them into one abstraction. The paper is unusually careful in distinguishing quality, compatibility, update fidelity, latency, and token usage, and it reports conditional speedups only where output equality is verified offline. It also ships code/data with frozen dataset IDs and includes a same-commit rebuild audit, which strengthens reproducibility. The main quantitative claim—exact-output incremental maintenance with large speedups—is defensible in principle, but its central Q4 evidence depends on the stability of an independent-rebuild oracle that the paper itself shows to be nondeterministic for Rust and TS/JS. The Q5 'preserve localization' claim similarly rests on an operational margin that is a reporting threshold rather than an externally justified equivalence bound. These two points are the key risk to the paper's headline contributions.

major comments (2)
  1. [§4.2, §9.5, Appendix F, Table 8] The conditional graph speedup claim (8.67x median, 15/33 transitions) depends on the independent rebuild in Eqs. (1)–(2) being a deterministic oracle. Appendix F's same-commit audit reports fresh-vs-fresh edge F1 of 99.75% and serving agreement of 99.35%, with changed-scope exactness on only 3/4 cases, and all 18 Rust and TS/JS graph transitions fail the exact checks. Thus the 15/33 match count and the median are measured against a single draw of a nondeterministic reference; a different fresh rebuild could yield different matches and a different median. The paper honestly reports this limitation, but the abstract still presents the conditional speedup as the headline without noting that, for graph maintenance, the matched transitions are entirely Go/Python. Please (i) run multiple independent rebuilds and require equality with all (or report the distribution across rebuild draws), or (i
  2. [§4.3, §9.7] The Q5 claim that selected context policies 'preserve localization' with 50–87% fewer tokens rests on the operational margin ε=0.05 applied to the lower bound of a paired 95% CI. This is a reporting threshold, not a pre-registered equivalence margin, as the paper acknowledges. However, the selection is margin-sensitive: for Haiku, the selected Eager arm has ΔAR@5 = −0.009 with lower bound −0.043, so a slightly stricter margin (e.g., ε=0.04) would change the selection. The headline token reduction is therefore contingent on a non-justified threshold. I recommend either justifying ε from an external operational requirement or presenting the results as a token–quality frontier and softening the 'preserve localization' wording in the abstract and conclusion.
minor comments (5)
  1. [Figure 10(c)] The panel appears twice in the submitted text (duplicate caption and identical plot). Please check the figure assembly.
  2. [Appendix F] The phrase 'Reported protocols are 21/4' is ambiguous. Please spell out which protocol numbers are pooled and which are excluded, and why.
  3. [§9.1] The sentence 'Qwen-4B/8B score means use n=99/98 at k′=30/50' could be clarified: state why the sample sizes differ for those operating points.
  4. [§9.1] The description of the lifecycle trace (20 sessions, 42 requests) is clear, but the initial paragraph says 'Materialize/load/mixed trace; isolated/resident' in Table 2; consider adding a cross-reference to §9.6 for the derived request count.
  5. [§7.4] The transition in Eq. (4) is well defined, but the claim that 'invocation j+1 consumes Ĥ_j' should be stated even more explicitly to avoid implying the rewrite is visible to the model before the next call; the surrounding text does clarify this, but a one-sentence restatement would help.

Circularity Check

0 steps flagged

No significant circularity: headline results are measured against external references or explicit conditional gates, and self-citations are background-only.

full rationale

CodeNib's central quantitative claims are all anchored to external references rather than to the paper's own outputs. Q1 targets come from developer patches in SWE-Bench Verified/Multilingual; Q2 compares approximate ANN indexes against exact Flat search; Q3 compares static serving against live LSP providers on a normalized-location equality predicate; Q4 compares incremental updates against independently rebuilt targets; Q5 compares against paired grep/read trajectories under a pre-specified localization margin. In each case the reference is an independent measurement, not a parameter fitted from the result being claimed. The Q4 speedups are explicitly conditional on Eqs. (1)-(2) matching an independent rebuild, and the paper reports non-matching transitions openly, excluding them from the conditional summary but retaining raw ratios. The Appendix F audit showing that fresh rebuilds are not fully deterministic for Rust/TS is a genuine validity caveat, but it does not make the claim circular: an incremental output is not defined as 'whatever the rebuild returns,' and the comparison is performed after timing on a separate path. The same applies to Q3, where the matched subset is a compatibility gate, not a construct that defines the latency advantage into existence. The only self-citations ([7] LocAgent and [72] OrcaLoca) appear in related-work positioning and are not load-bearing; no uniqueness theorem, ansatz, or design choice is imported from them. Accordingly, no derivation step reduces by construction to its own inputs, and the paper's explicit limitation statements are properly treated as threats to validity rather than circularity.

Axiom & Free-Parameter Ledger

6 free parameters · 6 axioms · 0 invented entities

The load-bearing premises are the evaluation's reference agreements, not new domain entities; no invented entities (new forces, dimensions, mediators) appear, and the manifest M_c is a design artifact rather than a postulated entity. Free parameters are almost all disclosed reporting thresholds and protocol choices; the only fitted number with a proper held-out split is w_g=0.5. The epsilon margin and @5 cutoff gate the Q5 headline and are explicitly non-pre-registered, so they belong in the ledger as hand-chosen.

free parameters (6)
  • graph fusion weight w_g = 0.5
    Q1 dense-graph fusion (Sec. 7.2). Swept over {0.25,0.5,...,2} on a 58-snapshot/15-repo tuning partition, selected lexicographically by File Success@10, frozen before the 42 held-out snapshots. Properly held out, but directly defines the graph-expansion ablation.
  • operational margin epsilon = 0.05 = 0.05
    Q5/Sec. 4.3: a policy 'preserves quality when LB.95[DeltaAR@5] >= -0.05'. Hand-chosen and non-pre-registered; it selects which arms produce the headline 50-87% token savings. Three of five models pass 0.001-0.013 above it (Table 9).
  • AnswerRecall@5 cutoff and zero-recall rule = k=5; zero for answers with no committed span
    Q5/Sec. 4.3: reporting choice stated as not an output cap; combined with the margin it defines the localization-preservation claim.
  • RRF constant kappa=60 with w_d=1 = kappa=60, w_d=1
    Q1 graph fusion (Sec. 7.2). kappa is the standard RRF constant from Cormack et al. [11] but is fixed rather than derived; w_d fixed at 1.
  • 0.95 Neighbor Recall bar for ANN selection = mean overlap >= 0.95
    Q2/Sec. 9.3: each approximate family contributes its fastest configuration meeting this bar, which determines the reported HNSW 33.9x/IVF 4.1x component-local search speedups. Disclosed, but paper-chosen.
  • Navigation and lifecycle probe selection = 5 evenly spaced positions/snapshot; 8 def/40 ref limits
    Q3 and lifecycle trace (Secs. 9.1, 9.4): probes are static-graph-anchored and the lifecycle calibrates only stable/matching probes while excluding references that drift. These choices bound the reported match rates.
axioms (6)
  • domain assumption A fresh, independent rebuild of a view is a deterministic, valid correctness oracle for incremental output (Eqs. 1-2, Sec. 4.2).
    Load-bearing for Q4: the 15/33 and 28/31 exact-match qualifications and the 8.67x/25.44x conditional speedups are defined against it. Appendix F's own audit shows fresh/fresh rebuilds differ (99.75% edge F1; changed-scope exactness 3/4), and all Rust/TS/JS graph rows fail the exact gate — so the oracle is noisy for 2 of 4 language groups.
  • domain assumption Pre-patch source units that overlap the developer patch are a valid localization ground truth (Sec. 4.2, Appendix A).
    Q1-Q2 targets and Q5 AnswerRecall@5 both derive from changed/deleted blocks. The paper calls this 'a localization proxy, not an assertion that every useful supporting block was changed'; useful context in unedited support files is systematically invisible to the metric.
  • domain assumption Normalized path/start-line set equality is a sufficient compatibility contract for navigation (Sec. 4.2, Sec. 9.4).
    Q3's match predicate N(.) projects away characters, end ranges, hover text, and diagnostics. The paper states equality 'does not prove interchangeability,' so the 63.2% match rate and 4.72x conditional latency must be read within this weaker-than-full-equivalence contract.
  • domain assumption Provider-reported prompt+completion token sums, charged on every re-appearance, are a faithful cross-model cost measure (Sec. 4.3, Eq. 5).
    Q5 token savings are computed under this accounting, which deliberately ignores prefix-cache reuse and KV/latency/billing effects. Defensible as a proxy but not an end-to-end cost; tokenizer differences across the five providers are not adjusted.
  • domain assumption Warm-host, single-trajectory, quiescent-checkout measurements represent agent and lifecycle costs (Sec. 9.1, Appendix G).
    Q5 uses one trajectory per query-policy-model cell with intervals over snapshot variation only; lifecycle projections assume warm caches and no concurrency/queueing. The paper says the serve-only term 'is not an end-to-end or hardware bound.'
  • standard math Clustered bootstrap percentile intervals are valid under the study's sampling design (Sec. 9.1).
    10k-20k bootstrap resamples clustered by repository snapshot are used for all intervals; this relies on standard exchangeability-within-cluster assumptions, unobjectionable but unstated in the main text.

pith-pipeline@v1.3.0-alltime-deepseek · 37672 in / 27637 out tokens · 280919 ms · 2026-08-01T02:28:53.207104+00:00 · methodology

0 comments
read the original abstract

Coding agents repeatedly search, navigate, and retain context from evolving repositories, but disconnected indexes, language servers, and task-local histories force repeated discovery and obscure lifecycle costs. CodeNib builds reusable lexical, dense, and structural views per repository commit, maps outputs to repository-relative source ranges, maintains selected views across edits, and serves ranked search, symbol navigation, and bounded context through one runtime. Across 100 snapshots, we map quality-cost frontiers across the repository-context lifecycle. When outputs match an independent rebuild, graph and vector updates are $8.7\times$ and $25.4\times$ faster at the median. On the static-navigation subset matching normalized live-server locations (63% of 1,000 requests), the median per-request live/static latency ratio is $4.7\times$. Across five models, selected context policies preserve localization with 50--87% fewer trajectory tokens than paired grep/read. Together, these results support multi-view repository-context serving with explicit, operation-specific validity boundaries.

Figures

Figures reproduced from arXiv: 2607.25431 by Aryan Dokania, Boqin Yuan, Gangda Deng, Hejia Zhang, Hengjia Yu, Jiayu Chang, Jishen Zhao, Mihir Jagtap, Shuting Zhao, Wentao Ni, Yash Jayswal, Yitong Ma, Yizhao Chen, Zhaoling Chen, Zhongming Yu.

Figure 1
Figure 1. Figure 1: CodeNib compiles and maintains heterogeneous [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: CodeNib’s repository-to-agent dataflow. The left column lists supported applications and dependencies, not a pipeline [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: LSP-assisted incremental graph maintenance. (a–b) Old and target graphs for diff (c). Full rebuild (d) recreates the [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Agent loop, view loading, and evaluated context poli [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Deterministic ranked-query compilation. (a) Sig [PITH_FULL_IMAGE:figures/full_fig_p009_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Embedding and pointwise-reranker operating points on the 100-snapshot corpus; Qwen-4B/8B score means use [PITH_FULL_IMAGE:figures/full_fig_p011_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Task-level graph and physical ANN ablations. (a) Paired graph-minus-dense [PITH_FULL_IMAGE:figures/full_fig_p012_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Dense-view construction and query profiles over 100 snapshots. (a) L0 file and (b) L2 callable construction time versus [PITH_FULL_IMAGE:figures/full_fig_p013_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Static-index versus live JSON-RPC replay over 100 [PITH_FULL_IMAGE:figures/full_fig_p013_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Incremental maintenance and lifecycle accounting. (a) Update speedup; fill denotes exact output match, labels [PITH_FULL_IMAGE:figures/full_fig_p014_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Agent context-policy effects. (a–b) Model-level token and [PITH_FULL_IMAGE:figures/full_fig_p015_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Pure-embedding Recall@𝑘 on the 100 CodeNib Base snapshots used by Q1, without graph expansion or reranking. Bar labels are macro means. (a) File results use path deduplication; (b) symbol results use 𝐿2 identities. Fig￾ure 6 shows the 𝑘 = 10 slice. F INCREMENTAL-MAINTENANCE PROTOCOL Update sequences and execution. The workload selects five first￾parent commit transitions from each of eight repositories, w… view at source ↗
Figure 14
Figure 14. Figure 14: Matched-request latency distribution for Q3. Each [PITH_FULL_IMAGE:figures/full_fig_p023_14.png] view at source ↗
Figure 15
Figure 15. Figure 15: Expanded workload-slice view underlying Fig [PITH_FULL_IMAGE:figures/full_fig_p023_15.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

83 extracted references · 7 canonical work pages

  1. [1]

    Anomaly. 2025. OpenCode: The open source coding agent. https://opencode.ai/ docs/tools. Accessed 2026-07-25; LSP integration is experimental

    2025

  2. [2]

    Anthropic. 2024. Model Context Protocol: Transport Specification. https:// modelcontextprotocol.io/specification/2024-11-05/basic/transports. Version 2024-11-05; accessed 2026-07-25

    2024

  3. [3]

    Anthropic. 2025. Introducing Claude Haiku 4.5. https://www.anthropic.com/ news/claude-haiku-4-5

    2025

  4. [4]

    Anthropic. 2026. Model IDs and Versioning. https://platform.claude.com/docs/ en/about-claude/models/model-ids-and-versions Accessed 2026-07-25

    2026

  5. [5]

    Ishaan Bhola, Adithyan Krishnan, Sravanth Kurmala, and Mukunda NS. 2026. Code Isn’t Memory: A Structural Codebase Index Inside a Coding Agent. arXiv:2606.22417. https://arxiv.org/abs/2606.22417

    Pith/arXiv arXiv 2026

  6. [6]

    Shravan Chaudhari, Rahul Thomas Jacob, Mononito Goswami, Jiajun Cao, Shihab Rashid, and Christian Bock. 2025. SpIDER: Spatially Informed Dense Embedding Retrieval for Software Issue Localization. arXiv:2512.16956. https://arxiv.org/ abs/2512.16956

    arXiv 2025

  7. [7]

    Zhaoling Chen, Robert Tang, Gangda Deng, Fang Wu, Jialong Wu, Zhiwei Jiang, Viktor Prasanna, Arman Cohan, and Xingyao Wang. 2025. LocAgent: Graph- Guided LLM Agents for Code Localization. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, Vienna, Aus...

    doi:10.18653/v1/2025.acl-long.426 2025

  8. [8]

    Tsvi Cherny-Shahar and Amiram Yehudai. 2026. Repository Intelligence Graph: Deterministic Architectural Map for LLM Code Assistants. arXiv:2601.10112. https://arxiv.org/abs/2601.10112

    arXiv 2026

  9. [9]

    CocoIndex contributors. 2025. CocoIndex. Incremental data-transformation framework. https://cocoindex.io/docs-v0/ Accessed 2026-07-25

    2025

  10. [10]

    Gheorghe Comanici, Eric Bieber, Mike Schaekermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, et al. 2025. Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities. arXiv:2507.06261. https://arxiv.org/abs/2507.06261

    Pith/arXiv arXiv 2025

  11. [11]

    Cormack, Charles L

    Gordon V. Cormack, Charles L. A. Clarke, and Stefan Büttcher. 2009. Reciprocal rank fusion outperforms condorcet and individual rank learning methods. In Proceedings of the 32nd International ACM SIGIR Conference on Research and Devel- opment in Information Retrieval (SIGIR). Association for Computing Machinery, New York, NY, USA, 758–759. https://doi.org...

    arXiv 2009

  12. [12]

    Creager and Hendrik van Antwerpen

    Douglas A. Creager and Hendrik van Antwerpen. 2023. Stack Graphs: Name Resolution at Scale. InEvolution, Originality, and Community in Computer Science (EVCS) (OpenAccess Series in Informatics (OASIcs)), Vol. 109. 8:1–8:12. https: //doi.org/10.4230/OASIcs.EVCS.2023.8

    work page doi:10.4230/oasics.evcs.2023.8 2023

  13. [13]

    Elmore, Michael Stonebraker, Magdalena Balazinska, Bill Howe, Jeremy Kepner, Samuel Madden, David Maier, Tim Mattson, and Stanley B

    Jennie Duggan, Aaron J. Elmore, Michael Stonebraker, Magdalena Balazinska, Bill Howe, Jeremy Kepner, Samuel Madden, David Maier, Tim Mattson, and Stanley B. Zdonik. 2015. The BigDAWG Polystore System.ACM SIGMOD Record 44, 2 (2015), 11–16. https://doi.org/10.1145/2814710.2814713

    arXiv 2015

  14. [14]

    Fabio James Fehr, Prabhu Teja S, Luca Franceschi, and Giovanni Zappella. 2025. CoRet: Improved Retriever for Code Editing. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers). Association for Computational Linguistics, Vienna, Austria, 775–789. https: //doi.org/10.18653/v1/2025.acl-short.62

    work page doi:10.18653/v1/2025.acl-short.62 2025

  15. [15]

    Jia Feng, Zhanyue Qin, Cuiyun Gao, Ruiqi Wang, Chaozheng Wang, Yingwei Ma, and Xiaoyuan Xie. 2026. On the Effectiveness of Context Compression for Repository-Level Tasks: An Empirical Investigation. arXiv:2604.13725. https: //arxiv.org/abs/2604.13725 Work in progress

    Pith/arXiv arXiv 2026

  16. [16]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. CodeBERT: A pre-trained model for programming and natural languages. InFindings of the Association for Computational Linguistics: EMNLP 2020. Association for Computa- tional Linguistics, Online, 1536–1547. https://doi...

    doi:10.18653/v1/2020.findings- 2020

  17. [17]

    Paul Gauthier and Aider contributors. 2024. Aider: Repository map. https: //aider.chat/docs/repomap.html. Accessed 2026-05-12

    2024

  18. [18]

    Gemma Team. 2026. Gemma 4 Technical Report. arXiv:2607.02770. https: //arxiv.org/abs/2607.02770

    Pith/arXiv arXiv 2026

  19. [19]

    Thibaud Gloaguen, Niels Mündler, Mark Müller, Veselin Raychev, and Martin Vechev. 2026. Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents? arXiv:2602.11988. https://arxiv.org/abs/2602.11988

    Pith/arXiv arXiv 2026

  20. [20]

    Goetz Graefe and William J. McKenna. 1993. The Volcano Optimizer Generator: Extensibility and Efficient Search. InProceedings of the 9th International Confer- ence on Data Engineering. IEEE Computer Society Press, Los Alamitos, CA, USA, 209–218. https://doi.org/10.1109/ICDE.1993.344061

    arXiv 1993

  21. [21]

    Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. 2022. UniXcoder: Unified cross-modal pre-training for code representation. InProceed- ings of the 60th Annual Meeting of the Association for Computational Linguistics (ACL). Association for Computational Linguistics, Dublin, Ireland, 7212–7225. https://doi.org/10.18653/v1/2022.acl-long.499

    doi:10.18653/v1/2022.acl-long.499 2022

  22. [22]

    Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou

    Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie Liu, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, Michele Tufano, Shao Kun Deng, Colin B. Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou. 2021. GraphCodeBERT: Pre-training Code Representations with Data Flow. InInternational Conference on Learning Represent...

    2021

  23. [23]

    Ashish Gupta, Inderpal Singh Mumick, and V. S. Subrahmanian. 1993. Maintain- ing Views Incrementally. InProceedings of the 1993 ACM SIGMOD International Conference on Management of Data. Association for Computing Machinery, New York, NY, USA, 157–166. https://doi.org/10.1145/170035.170066

    arXiv 1993

  24. [24]

    Gwihwan Go, Quan Zhang, Chijin Zhou, Zhao Wei, and Yu Jiang. 2026. LSPRAG: LSP-Guided RAG for Language-Agnostic Real-Time Unit Test Generation. InProceedings of the 48th International Conference on Software Engineering (Rio de Janeiro, Brazil)(ICSE ’26). Association for Computing Machinery, New York, NY, USA. https://conf.researchr.org/details/icse-2026/i...

    arXiv 2026

  25. [25]

    Yu Huo, Kun Zeng, Siyu Zhang, Yuquan Lu, Cheng Yang, Yifu Guo, and Xiaoying Tang. 2026. RepoShapley: Shapley-Enhanced Context Filtering for Repository- Level Code Completion. InFindings of the Association for Computational Linguis- tics: ACL 2026. Association for Computational Linguistics, San Diego, California, United States, 10390–10412. https://doi.org...

    work page doi:10.18653/v1/2026.findings-acl.505 2026

  26. [26]

    Zhonghao Jiang, Xiaoxue Ren, Meng Yan, Wei Jiang, Yong Li, and Zhongxin Liu

  27. [27]

    Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan

    Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2024. SWE-bench: Can language models resolve real-world GitHub issues?. InInternational Conference on Learning Representations (ICLR)

    2024

  28. [28]

    Jeff Johnson, Matthijs Douze, and Hervé Jégou. 2021. Billion-Scale Similarity Search with GPUs.IEEE Transactions on Big Data7, 3 (July 2021), 535–547. https://doi.org/10.1109/TBDATA.2019.2921572

    arXiv 2021

  29. [29]

    Jimenez, Ofir Press, and John Yang

    Kabir Khandpur, Kilian Lieret, Carlos E. Jimenez, Ofir Press, and John Yang

  30. [30]

    Myeongsoo Kim, Chao-Chun Hsu, Dingmin Wang, Shweta Garg, Varun Ku- mar, and Murali Krishna Ramanathan. 2026. CODESTRUCT: Code Agents over Structured Action Spaces. InProceedings of the 64th Annual Meeting of the As- sociation for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, San Diego, California, United Sta...

    work page doi:10.18653/v1/2026.acl-long.607 2026

  31. [31]

    SWE-bench benchmark release

    SWE-bench Multilingual. SWE-bench benchmark release. https://www. swebench.com/multilingual.html Accessed 2026-07-25

    2026

  32. [32]

    Barr, Federica Sarro, Zhaoyang Chu, and He Ye

    Han Li, Letian Zhu, Bohan Zhang, Rili Feng, Jiaming Wang, Yue Pan, Earl T. Barr, Federica Sarro, Zhaoyang Chu, and He Ye. 2026. ContextBench: A Benchmark for Context Retrieval in Coding Agents. arXiv:2602.05892. https://arxiv.org/abs/ 2602.05892

    arXiv 2026

  33. [33]

    Daria Kryvosheieva, Saba Sturua, Michael Günther, Scott Martens, and Han Xiao. 2025. Efficient Code Embeddings from Code Generation Models. InFourth Workshop on Deep Learning for Code (DL4Code), NeurIPS. https://openreview. net/forum?id=smR7RPdWZs arXiv:2508.21290

    Pith/arXiv arXiv 2025

  34. [34]

    Zhuofeng Li, Haoxiang Zhang, Cong Wei, Pan Lu, Ping Nie, Yi Lu, Yuyang Bai, Shangbin Feng, Hangxiao Zhu, Ming Zhong, Yuyu Zhang, Jianwen Xie, Yejin Choi, James Zou, Jiawei Han, Wenhu Chen, Jimmy Lin, Dongfu Jiang, and Yu Zhang. 2026. Beyond Semantic Similarity: Rethinking Retrieval for Agentic Search via Direct Corpus Interaction. arXiv:2605.05242. https:...

    Pith/arXiv arXiv 2026

  35. [35]

    Yichen Li, Qiye Lin, Yun Peng, Zhihan Jiang, Jinyang Liu, Chaozheng Wang, Yintong Huo, and Cuiyun Gao. 2026. One Size Does Not Fit All: Revisiting Code Context Engineering for Repository-Level Code Generation.Proceedings of the ACM on Software Engineering3, FSE (2026), 2952–2975. https://doi.org/10.1145/ 3808138

    2026

  36. [36]

    Tobias Lindenbauer, Igor Slinko, Ludwig Felder, Egor Bogomolov, and Yaroslav Zharov. 2025. The Complexity Trap: Simple Observation Masking Is as Efficient as LLM Summarization for Agent Context Management. InFourth Workshop on Deep Learning for Code (DL4Code), NeurIPS. https://openreview.net/forum?id= OHVzruJl5k arXiv:2508.21433

    arXiv 2025

  37. [37]

    Zhihao Lin, Mingyi Zhou, Yizhuo Yang, and Li Li. 2026. How Much Static Structure Do Code Agents Need? A Study of Deterministic Anchoring. To appear in the 35th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). https://arxiv.org/abs/2606.26979 arXiv:2606.26979

    Pith/arXiv arXiv 2026

  38. [38]

    Shukai Liu, Bo Jiang, Jian Yang, Yizhi Li, Jinyang Guo, Xianglong Liu, and Bryan Dai. 2026. Context as a Tool: Context Management for Long-Horizon SWE- Agents. InFindings of the Association for Computational Linguistics: ACL 2026. Association for Computational Linguistics, San Diego, California, United States, 16 CodeNib: A Multi-View Data System for Serv...

    work page doi:10.18653/v1/2026.findings-acl.1032 2026

  39. [39]

    Jinshi Liu, Hanying Zuo, Congyin Cao, Anran Zhang, Yixuan Liu, and Xinzhou Xie. 2026. AOCI: Symbolic–Semantic Indexing for Practical Repository-Scale Code Understanding with LLMs. arXiv:2605.02421. https://arxiv.org/abs/2605. 02421

    Pith/arXiv arXiv 2026

  40. [40]

    George Ma, Anurag Koul, Qi Chen, Yawen Wu, Sachit Kuhar, Yu Yu, Aritra Sen- gupta, Varun Kumar, and Murali Krishna Ramanathan. 2026. SpecAgent: A Spec- ulative Retrieval and Forecasting Agent for Code Completion. InProceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational...

    doi:10.18653/v1/2026.acl-long.786 2026

  41. [41]

    Xiangyan Liu, Bo Lan, Zhiyuan Hu, Yang Liu, Zhicheng Zhang, Fei Wang, Michael Qizhe Shieh, and Wenmeng Zhou. 2025. CodexGraph: Bridging Large Language Models and Code Repositories via Code Graph Databases. InPro- ceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technolo...

    work page doi:10.18653/v1/2025.naa 2025

  42. [42]

    Simon Marlow. 2022. Incremental indexing with Glean. Glean documentation, https://glean.software/blog/incremental/. Accessed 2026-07-15

    2022

  43. [43]

    Malkov and D

    Yu A. Malkov and D. A. Yashunin. 2020. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs.IEEE Transactions on Pattern Analysis and Machine Intelligence42, 4 (2020), 824–836. https://doi.org/10.1109/TPAMI.2018.2889473

    arXiv 2020

  44. [44]

    Microsoft. 2022. LSIF: Language Server Index Format specification, v0.6.0. https://microsoft.github.io/language-server-protocol/specifications/lsif/0. 6.0/specification/. Accessed 2026-05-12

    2022

  45. [45]

    Meta Engineering. 2024. Indexing code at scale with Glean. https://engineering.fb. com/2024/12/19/developer-tools/glean-open-source-code-indexing/. Accessed 2026-07-15

    2024

  46. [46]

    Han-Wen Nienhuys and Sourcegraph contributors. 2024. Zoekt: Fast trigram- based code search. https://github.com/sourcegraph/zoekt. Accessed 2026-05-12

    2024

  47. [47]

    Microsoft. 2024. Language Server Protocol Specification. https://microsoft.github. io/language-server-protocol/. Accessed 2026-05-12

    2024

  48. [48]

    Oraios AI. 2026. Serena: The IDE for Your Coding Agent. Software, version 1.6.1. https://github.com/oraios/serena/tree/v1.6.1 Accessed 2026-07-25; MIT License

    2026

  49. [49]

    OpenAI. 2024. Introducing SWE-bench Verified. https://openai.com/index/ introducing-swe-bench-verified/. Accessed 2026-05-12

    2024

  50. [50]

    Junsong Pu, Yichen Li, and Zhuangbin Chen. 2026. TypeScript Repository Indexing for Code Agent Retrieval. arXiv:2604.18413. https://arxiv.org/abs/2604. 18413 Tool demonstration; unrefereed preprint

    Pith/arXiv arXiv 2026

  51. [51]

    Siru Ouyang, Wenhao Yu, Kaixin Ma, Zilin Xiao, Zhihan Zhang, Mengzhao Jia, Jiawei Han, Hongming Zhang, and Dong Yu. 2025. RepoGraph: Enhancing AI Software Engineering with Repository-level Code Graph. InInternational Conference on Learning Representations (ICLR). https://openreview.net/forum? id=dw9VUsSHGB

    2025

  52. [52]

    Revanth Gangi Reddy, Tarun Suresh, JaeHyeok Doo, Ye Liu, Xuan Phi Nguyen, Yingbo Zhou, Semih Yavuz, Caiming Xiong, Heng Ji, and Shafiq Joty. 2026. SweRank: Software issue localization with code ranking. InInternational Con- ference on Learning Representations (ICLR). https://arxiv.org/abs/2505.07849 arXiv:2505.07849

    Pith/arXiv arXiv 2026

  53. [53]

    Qwen Team. 2026. Qwen3.5-9B and Qwen3.5-27B. Official model cards at https://huggingface.co/Qwen/Qwen3.5-9B and https://huggingface.co/Qwen/ Qwen3.5-27B. Accessed 2026-07-25

    2026

  54. [54]

    Brian Sam-Bodden. 2026. What Context Does a Coding Agent Actually Need to Act? arXiv:2607.09691. https://arxiv.org/abs/2607.09691

    Pith/arXiv arXiv 2026

  55. [55]

    Stephen Robertson and Hugo Zaragoza. 2009. The probabilistic relevance frame- work: BM25 and beyond.Foundations and Trends in Information Retrieval3, 4 (2009), 333–389. https://doi.org/10.1561/1500000019

    doi:10.1561/1500000019 2009

  56. [56]

    Chuanqi Shi, Miao Gao, and Zhiqiang Gao. 2026. AIRCoder: Adaptive Integration of Multi-dimensional Retrieval for Repository-level Code Completion. InProceed- ings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, San Diego, California, United States, 25458–25470....

    doi:10.18653/v1/2026.acl- 2026

  57. [57]

    SCIP contributors. 2026. SCIP: A Language-Agnostic Protocol for Indexing Source Code. Protocol specification and software, version 0.9.0. https://github.com/scip- code/scip/tree/v0.9.0 Accessed 2026-07-25

    2026

  58. [58]

    Weiwei Sun, Lingyong Yan, Xinyu Ma, Shuaiqiang Wang, Pengjie Ren, Zhumin Chen, Dawei Yin, and Zhaochun Ren. 2023. Is ChatGPT good at search? In- vestigating large language models as re-ranking agents. InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, Singapore, 1491...

    doi:10.18653/v1/2023.emnlp-main.923 2023

  59. [59]

    Sourcegraph. 2024. Sourcegraph: Code search and intelligence. https:// sourcegraph.com/. Accessed 2026-05-12

    2024

  60. [60]

    The Cognition Team. 2025. DeepWiki: AI docs for any repo. https://cognition. com/blog/deepwiki. Accessed 2026-05-13; public, no-login wiki for any GitHub repository, powered by Devin

    2025

  61. [61]

    Tamás Szabó. 2023. Incrementalizing Production CodeQL Analyses. InProceed- ings of the 31st ACM Joint European Software Engineering Conference and Sympo- sium on the Foundations of Software Engineering (ESEC/FSE ’23). Association for Computing Machinery, 1716–1726. https://doi.org/10.1145/3611643.3613860

    arXiv 2023

  62. [62]

    Martin Vogel, Falk Meyer-Eschenbach, Severin Kohler, Elias Grünewald, and Felix Balzer. 2026. Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP. arXiv:2603.27277. https://arxiv.org/abs/2603.27277

    arXiv 2026

  63. [63]

    Tree-sitter contributors. 2026. Tree-sitter Parser and Node Documentation. https: //tree-sitter.github.io/tree-sitter/using-parsers/1-getting-started.html. Accessed 2026-07-25

    2026

  64. [64]

    Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H

    Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig. 2025. OpenHands: An open platform for A...

    2025

  65. [65]

    Peiding Wang, Li Zhang, Fang Liu, Chongyang Tao, and Yinghao Zhu. 2026. CodeMEM: AST-Guided Adaptive Memory for Repository-Level Iterative Code Generation. InFindings of the Association for Computational Linguistics: ACL

    2026

  66. [66]

    Di Wu, Wasi Uddin Ahmad, Dejiao Zhang, Murali Krishna Ramanathan, and Xiaofei Ma. 2024. Repoformer: Selective Retrieval for Repository-Level Code Completion. InProceedings of the 41st International Conference on Machine Learn- ing (Proceedings of Machine Learning Research), Vol. 235. PMLR, 53270–53290. https://proceedings.mlr.press/v235/wu24a.html

    2024

  67. [67]

    Scott Wu and Cognition Labs. 2024. Introducing Devin, the first AI software engineer. https://cognition.com/blog/introducing-devin. Accessed 2026-05-12

    2024

  68. [68]

    Yuhang Wang, Yuling Shi, Mo Yang, Rongrui Zhang, Shilin He, Heng Lian, Yuting Chen, Siyu Ye, Kai Cai, and Xiaodong Gu. 2026. SWE-Pruner: Self-Adaptive Context Pruning for Coding Agents. arXiv:2601.16746. https://arxiv.org/abs/ 2601.16746

    Pith/arXiv arXiv 2026

  69. [69]

    Yuan-An Xiao, Pengfei Gao, Chao Peng, and Yingfei Xiong. 2026. Reducing Cost of LLM Agents with Trajectory Reduction.Proceedings of the ACM on Software Engineering3, FSE (June 2026), 1241–1263. https://doi.org/10.1145/3797084

    doi:10.1145/3797084 2026

  70. [70]

    Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press

    John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent–computer inter- faces enable automated software engineering. InAdvances in Neural Information Processing Systems (NeurIPS), Vol. 37. Neural Information Processing Systems Foundation, 50528–50652. https://doi.org/10.52202/07...

    doi:10.52202/079017-1601 2024

  71. [71]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2025. Demystifying LLM-Based Software Engineering Agents.Proceedings of the ACM on Software Engineering2, FSE (2025), 801–824. https://doi.org/10.1145/3715754

    doi:10.1145/3715754 2025

  72. [72]

    Zhongming Yu, Hejia Zhang, Yujie Zhao, Hanxian Huang, Matrix Yao, Ke Ding, and Jishen Zhao. 2025. OrcaLoca: An LLM Agent Framework for Software Issue Localization. InProceedings of the 42nd International Conference on Machine Learning (Proceedings of Machine Learning Research), Vol. 267. PMLR, 73416– 73436. https://proceedings.mlr.press/v267/yu25x.html

    2025

  73. [73]

    Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. RepoCoder: Repository-level code completion through iterative retrieval and generation. InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2471–2484....

    2023

  74. [74]

    Narasimhan, and Yuan Cao

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R. Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. InInternational Conference on Learning Representations (ICLR). https://openreview.net/forum?id=WE_vluYUL-X

    2023

  75. [75]

    Yanzhao Zhang, Mingxin Li, Dingkun Long, Xin Zhang, Huan Lin, Baosong Yang, Pengjun Xie, An Yang, Dayiheng Liu, Junyang Lin, Fei Huang, and Jingren Zhou

  76. [76]

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. 2024. AutoCodeRover: Autonomous Program Improvement. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). ACM, 1592–1604. https://doi.org/10.1145/3650212.3680384

    arXiv 2024

  77. [77]

    Shaoqiu Zhang, Yuhang Wang, Jialiang Liang, Yuling Shi, Wenhao Zeng, Mao- quan Wang, Shilin He, Ningyuan Xu, Siyu Ye, Kai Cai, and Xiaodong Gu

  78. [78]

    arXiv:2606.07297

    SWE-Explore: Benchmarking How Coding Agents Explore Repositories. arXiv:2606.07297. https://arxiv.org/abs/2606.07297

    Pith/arXiv arXiv

  79. [80]

    arXiv:2506.05176

    Qwen3 Embedding: Advancing Text Embedding and Reranking Through Foundation Models. arXiv:2506.05176. https://arxiv.org/abs/2506.05176

    Pith/arXiv arXiv

  80. [82]

    Zelin Zhao, Xizao Wang, Zhaogui Xu, Zhenhao Tang, Yongchao Li, and Peng Di

Showing first 80 references.