Paper deep dive
Squeez: Task-Conditioned Tool-Output Pruning for Coding Agents
Ádám Kovács
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 99%
Last extracted: 4/10/2026, 2:29:03 AM
Summary
Squeez is a task-conditioned tool-output pruning framework for coding agents that extracts minimal verbatim evidence blocks from tool observations. By fine-tuning a Qwen 3.5 2B model with LoRA on a new benchmark of 11,477 examples, the system achieves 0.86 recall and 0.80 F1 while removing 92% of input tokens, significantly outperforming larger zero-shot models and heuristic baselines.
Entities (5)
Relation Signals (3)
Squeez → evaluateson → SWE-Bench
confidence 100% · We introduce a benchmark of 11,477 examples built from SWE-bench repository interactions
Qwen 3.5 2B → outperforms → Qwen 3.5 35B A3B
confidence 100% · outperforming zero-shot Qwen 3.5 35B A3B by 11 recall points
Squeez → uses → Qwen 3.5 2B
confidence 100% · We fine-tune Qwen 3.5 2B with LoRA
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Coding agents repeatedly consume long tool observations even though only a small fraction of each observation matters for the next step. We study task-conditioned tool-output pruning: given a focused query and one tool output, return the smallest verbatim evidence block the agent should inspect next. We introduce a benchmark of 11,477 examples built from SWE-bench repository interactions and synthetic multi-ecosystem tool outputs, with a manually curated 618-example test set. We fine-tune Qwen 3.5 2B with LoRA and compare it against larger zero-shot models and heuristic pruning baselines. Our model reaches 0.86 recall and 0.80 F1 while removing 92% of input tokens, outperforming zero-shot Qwen 3.5 35B A3B by 11 recall points and all heuristic baselines by a wide margin.
Tags
Links
- Source: https://arxiv.org/abs/2604.04979v1
- Canonical: https://arxiv.org/abs/2604.04979v1
Trouble viewing inline? Open PDF directly →
Full Text
25,885 characters extracted from source content.
Expand or collapse full text
Squeez: Task-Conditioned Tool-Output Pruning for Coding Agents Ádám Kovács KR Labs kovacs@krlabs.eu https://github.com/KRLabsOrg/squeez Abstract Coding agents repeatedly consume long tool observations even though only a small fraction of each observation matters for the next step. We study task-conditioned tool-output pruning: given a focused query and one tool output, return the smallest verbatim evidence block the agent should inspect next. We introduce a benchmark of 11,477 examples built from SWE-bench repository interactions and synthetic multi-ecosystem tool outputs, with a manually curated 618-example test set. We fine-tune Qwen 3.5 2B with LoRA and compare it against larger zero-shot models and heuristic pruning baselines. Our model reaches 0.86 recall and 0.80 F1 while removing 92% of input tokens, outperforming zero-shot Qwen 3.5 35B A3B by 11 recall points and all heuristic baselines by a wide margin. Squeez: Task-Conditioned Tool-Output Pruning for Coding Agents Ádám Kovács KR Labs kovacs@krlabs.eu https://github.com/KRLabsOrg/squeez 1 Introduction Coding agents work over streams of file reads, grep hits, stack traces, build logs, API responses, and version-control history (Yang et al., 2024; Wang et al., 2025). In such observations, only a small fraction of the tokens is relevant to the next decision, yet the agent often has to re-read the entire output. This makes pruning a central efficiency problem for agent systems (Jiang et al., 2023, 2024; Hwang et al., 2025; Kerboua et al., 2025; Wang et al., 2026). We study a narrow but practical version of this problem: given a focused query and a single tool observation, return the smallest verbatim evidence block the agent should inspect next. The task is not to solve the issue from one observation, but to preserve the relevant evidence and discard the rest. This distinguishes our setting from generic prompt compression and from document-level retrieval compression, which typically operate on prose documents or retrieved passages rather than mixed-format tool output. We make three contributions. We formulate task-conditioned tool-output pruning as a benchmark task for coding agents, release a dataset spanning real SWE-bench repository interactions and synthetic multi-ecosystem tool outputs, and show that a compact Qwen 3.5 2B model fine-tuned for this task substantially outperforms larger zero-shot models and simple heuristic baselines. Because the model can be served through vLLM or used as a CLI filter on piped tool output, it can be inserted into existing coding-agent stacks such as Codex or Claude Code with minimal changes to the surrounding agent loop. The model, dataset, and evaluation code and CLI are publicly available under the Apache 2.0 license. 2 Related Work Prompt compression methods such as LLMLingua (Jiang et al., 2023) and LongLLMLingua (Jiang et al., 2024) compress long prompts before generation. LLMLingua uses a coarse-to-fine compression pipeline with a budget controller and iterative token removal, while LongLLMLingua adapts compression to long-context settings with query-aware compression and document reordering. These methods target prompt efficiency at the token or prompt-block level rather than query-conditioned extraction from a single mixed-format tool observation. Abstractive summarization addresses a different problem again, since it rewrites salient content rather than preserving verbatim source evidence (See et al., 2017; Liu and Lapata, 2019). Document-level context pruners are closer to our work. EXIT (Hwang et al., 2025) performs extractive compression for retrieval-augmented generation by selecting relevant portions of retrieved textual context for a downstream question-answering stage. Provence (Chirkova et al., 2025) formulates context pruning as sequence labeling, combining pruning with reranking, and training on diverse QA domains to obtain robust out-of-the-box RAG pruning. Open-source models such as Zilliz Semantic Highlight (Zilliz, 2025) adapt this idea to lightweight semantic highlighting, producing token- and sentence-level relevance scores over retrieved documents for real-time highlighting. These systems, however, assume retrieved passages or document text. They do not target the mixed observations that arise in coding agents, where code, logs, shell traces, metadata, and structured outputs are interleaved in a single artifact. Our setting is also related to agent-specific pruning. FocusAgent (Kerboua et al., 2025) reduces the context available to web agents by trimming web observations, while SWE-Pruner (Wang et al., 2026) targets coding agents more directly by pruning repository code context. The nearest of these to our work is SWE-Pruner, but its emphasis is repository-level code context rather than single tool observations spanning files, logs, build outputs, and other non-code modalities. Finally, our task is related to extractive QA and supporting-evidence supervision, where outputs are grounded in explicit spans or sentence sets rather than free generation (Rajpurkar et al., 2016; Thorne et al., 2018; Yang et al., 2018). Verbatim evidence extraction has also been applied in domain-specific QA, where lightweight extractive pipelines select grounded sentences to prevent hallucination (Kovacs et al., 2025). The common concern is faithfulness: outputs should remain traceable to source evidence. Our setting differs in focusing on query-conditioned pruning of tool observations rather than answer production from prose documents. Input Query: “Find the traceback that explains the ImportError.” Tool output: 501 lines from read_file, grep, pytest, git_log, … Grounded spans 183: ): 184: super().__init__( 185: import_name=... 191: self.name = name 193: self.subdomain = ... Gold: (start_line, end_line) Generative output <relevant_lines> 184: super().__init__( 185: import_name=... 191: self.name = name </relevant_lines> Eval: recall, F1, compression annotatederive Figure 1: System overview. The benchmark stores grounded spans over raw tool output, then derives a generative training target. At evaluation, predicted lines are compared to gold spans using recall, F1, and compression. 3 Task Definition Figure 1 illustrates the overall pipeline. The benchmark input is a pair (q,o)(q,o), where q is a short task-conditioned extraction query and o is one raw tool observation. The output is a set of one or more contiguous spans over o: Y=(s1,e1),…,(sk,ek),Y=\(s_1,e_1),…,(s_k,e_k)\, where each span refers to line indices in the original output. The task is intentionally narrower than bug solving. The model is not asked to infer the correct patch from one observation, but to extract the minimal evidence block that would help an agent on the next reasoning step. Queries are short, concrete, and tool-aware. They may be easy, medium, or moderately semantic; they need not avoid lexical cues if those cues reflect the underlying agent need. The key requirement is that they define a plausible pruning decision rather than a full diagnosis. 4 Dataset 4.1 Data Sources The benchmark draws on two sources of raw tool output. SWE-bench derived. We clone repository snapshots from SWE-bench (Jimenez et al., 2024) and execute 14 tool types against them — file reads, grep, Git log and blame, test runners, linters, type checkers, pip install, curl, and others — collecting 10,713 raw observations that reflect the kind of output a coding agent encounters during issue resolution. Synthetic multi-ecosystem. To extend coverage beyond SWE-bench’s Python-heavy distribution, we use openai/gpt-oss-120b to generate 2,039 realistic tool outputs for representative tasks in TypeScript, Go, Rust, Java, Docker, Terraform, Kubernetes, and related build or deployment workflows. We also construct 575 explicit negative examples by pairing mismatched queries and tool outputs, where the correct pruning decision is to return nothing. The released benchmark contains 11,477 examples in total: 9,205 SWE-derived, 1,697 synthetic positives, and 575 synthetic negatives, covering 27 tool types; Table 2 lists the tool-family counts. 4.2 Example Construction Each example pairs one focused query with one raw tool observation. Both sources go through the same two-stage teacher-labeling pipeline using openai/gpt-oss-120b. Given the background task and the raw tool output, the teacher first writes a focused, tool-aware extraction query: not the full issue statement, but a narrower local information need such as finding the failure block, the relevant code region, or the commit entry that matters for the next debugging step. It then selects the smallest contiguous span or set of spans that answers that query. The teacher sees a numbered rendering of the tool output for stable span selection, but the released labels are always mapped back onto the original raw text, so every target is a verbatim subset of the source. Positive examples whose query cannot be supported by the observation are discarded. For generative training, gold spans are linearized as XML-wrapped extracted text, while the released benchmark stores the span coordinates over the original tool output. 4.3 Curation and Statistics We split SWE-derived examples by repository and synthetic examples by tool family, yielding 10,508 training examples, 240 development examples, and 618 test examples. The held-out set was manually curated: from 729 candidate test examples, 111 (15.2%) were excluded as near-duplicates, trivial 1–2 line outputs, overly broad spans, or incorrect annotations. The final released test set therefore contains only manually reviewed examples. Table 1 summarizes the source composition of the released benchmark. Table 3 shows the largest tool families. The distribution is intentionally heterogeneous: the benchmark mixes very short observations such as Python exceptions and test summaries with long file reads, type-check outputs, and container logs. This variation is one reason simple truncation and lexical retrieval are weak baselines: relevant evidence may occur at the beginning, middle, or end of the observation, and the useful pruning unit depends on the tool type. Source Raw inputs Released rows SWE-derived 10,713 9,205 Synthetic positives 2,039 1,697 Synthetic negatives — 575 Total 12,752 11,477 Table 1: Source composition of the released benchmark. Synthetic negatives are constructed by pairing mismatched queries and tool outputs. Tool Rows Tool Rows Tool Rows read_file 3768 ls 347 build_output 168 grep 1330 type_check 317 docker_build 151 git_log 720 git_blame 291 make_cmake 133 python 698 npm_build 230 kubectl 123 test_output 546 tsc 229 cargo_build 122 curl 493 npm_install 227 go_build 120 pip_install 441 coverage 198 mvn_gradle 114 lint_output 184 docker_logs 198 terraform 103 mypy_pyright 95 eslint 78 git_diff 53 Table 2: Tool-family counts in the released benchmark. Tool Rows Avg. input Avg. gold read_file 3768 1677 84 grep 1330 779 19 git_log 720 161 11 python 698 60 28 curl 493 723 68 pip_install 441 438 79 type_check 317 3418 39 tsc 229 1444 56 remaining tools 3481 914 51 Table 3: Largest tool families in the dataset. Token counts are averages over released examples. 5 Model and Evaluation Our model is Qwen 3.5 2B (Qwen Team, 2026) fine-tuned with LoRA (Hu et al., 2021; Dettmers et al., 2023). The model receives the focused query and raw tool output and is trained to emit the verbatim extracted text wrapped in <relevant_lines> tags. We fine-tune for three epochs with maximum sequence length 20,000, per-device batch size 8, gradient accumulation 4, learning rate 2×10−42× 10^-4, warmup ratio 0.05, and weight decay 0.01. For serving we merge the LoRA adapter into the base model and run the merged checkpoint with vLLM. Training was performed on a single NVIDIA A100 80GB GPU. We choose Qwen 3.5 2B because the Qwen 3.5 family offers strong performance on code, reasoning, and agent benchmarks while providing small-scale variants suitable for efficient deployment (Qwen Team, 2026). In our setting, the aim is not to maximize zero-shot reasoning depth with the largest possible generator, but to learn a narrow supervised extraction policy that can run cheaply inside existing agent systems. A 2B backbone is therefore a better fit for this use case than a much larger decoder, while still remaining strong enough to benefit from task-specific supervision. We compare against three zero-shot generative baselines — Qwen 3.5 35B A3B, Kimi K2, and the unfine-tuned Qwen 3.5 2B base — and four simple heuristics: BM25, First-N, Last-N, and Random. The heuristic baselines keep approximately 10% of the input lines so that they operate at a compression level similar to the gold annotations. The matching unit is the line. Given a predicted line set P and a gold line set G, we report recall, exact match, compression, and two overlap scores. In the main text, F1 denotes a tolerant line-matching score in which a predicted line matches a gold line if fuzzy substring similarity exceeds 0.5, reducing brittleness from minor formatting differences in generative output. We also report strict exact-text overlap F1 in Table 4 for completeness. Our analysis focuses on recall under strong compression, with F1 as the summary metric. This reflects the task itself: dropping relevant evidence is usually more harmful than keeping a slightly larger block. In practice, the model is intended as a lightweight pre-processing step for agent systems. In our release it is exposed both as a CLI that can consume piped tool output and as a vLLM-served model, so existing coding agents can insert pruning before the next reasoning step without changing their core planning logic. 6 Results Setup. All models are evaluated on the held-out 618-example test set. All generative models receive the same <query>/<tool_output> prompt format as the fine-tuned model. The fine-tuned model is served with vLLM; the larger zero-shot models are accessed via OpenAI-compatible APIs. Model Prec. Recall Strict F1 Exact F1 Compression Squeez-2B 0.80 0.86 0.79 0.49 0.80 0.92 Qwen 3.5 35B A3B 0.74 0.75 0.70 0.39 0.73 0.92 Kimi K2 0.61 0.53 0.53 0.30 0.68 0.94 Qwen 3.5 2B (base) 0.42 0.53 0.41 0.19 0.55 0.82 BM25 (10%) 0.13 0.22 0.13 0.01 0.23 0.90 First-N (10%) 0.07 0.14 0.08 0.02 0.16 0.91 Random (10%) 0.07 0.10 0.07 0.01 0.20 0.91 Last-N (10%) 0.05 0.05 0.04 0.01 0.14 0.91 Table 4: Held-out test results. Compression is the fraction of input removed. Squeez-2B is LoRA-tuned; other generative models use the same prompt zero-shot. Pattern Query / Observation Squeez-2B Baseline error Precise selection in structured output git_log, 21 lines. Query asks for the commit relevant to the dimension-order change in xr.polyval. Selects the single correct commit entry. Qwen 35B chooses a plausible but wrong transpose-related commit; Qwen 2B base over-selects several polyval commits. Failure-block extraction service log, 176 lines. Query asks for the TLS handshake failure affecting the health-check request. Returns the correct 5-line health-check failure block. Qwen 35B selects a later payment-request TLS failure; Kimi K2 keeps only part of the correct block. Correct empty prediction docker_logs, 316 lines. Query asks for a numpy version conflict that is not present. Returns empty output. Qwen 35B generates explanatory text (“No relevant lines found…”); Qwen 2B base returns unrelated database errors. Adjacent over-selection build_output, 110 lines. Query asks for the Dockerfile syntax error on line 12. Finds the Dockerfile error but also includes a nearby Python SyntaxError. Qwen 35B misses the Dockerfile error entirely and selects only the Python block. Table 5: Representative held-out examples. The fine-tuned model is strongest on precise hits, compact failure blocks, and true negatives; its residual errors are usually adjacent over-selection. Squeez-2B attains the highest recall among all systems while maintaining 92% compression. It outperforms the 18× larger Qwen 3.5 35B A3B by 11 recall points and the unfine-tuned 2B base by 33 points. The gain is not just recall: the fine-tuned model is also the most precise system in the comparison, which indicates that it has learned a tool-specific extraction policy rather than generic instruction following. The zero-shot baselines differ in how they fail. Qwen 35B is the strongest of them, but still misses benchmark-specific regularities: in repetitive logs or Git history it often selects a semantically adjacent but incorrect block. Kimi K2 is the most aggressive compressor, but pays for that with lower recall, often dropping lines that look boilerplate-like but are actually part of the gold evidence. The unfine-tuned 2B base under-compresses and produces noisier extractions. Heuristic baselines perform substantially worse than any generative model. BM25, which is effective for document retrieval, reaches only 0.22 recall on tool output. This is a direct consequence of the task: relevant lines may occur at the beginning, middle, or end of an observation, and usefulness depends on the query rather than lexical overlap alone. Figure 2 shows the recall–compression trade-off across all systems. 0.810.810.820.820.830.830.840.840.850.850.860.860.870.870.880.880.890.890.90.90.910.910.920.920.930.930.940.940.950.9500.20.20.40.40.60.60.80.8Compression (fraction of input removed)Recall Figure 2: Recall–compression trade-off on the held-out test set. ∙ Squeez-2B, ■ Qwen 35B, ▲ Kimi K2, ◆ Qwen 2B, ∘ heuristic baselines. Qualitatively, the fine-tuned model succeeds for three recurring reasons. It learns to isolate a single relevant hit in structured outputs such as grep and git_log; it learns to keep compact failure blocks in noisy test, build, and service logs; and it is much better than larger zero-shot models at returning empty output on explicit negatives. On the 59 negative examples in the held-out test set, it returns empty output 80% of the time, compared with 7% for Qwen 35B. Its strongest remaining failures are usually semantically adjacent selections rather than wholly irrelevant output: the wrong file from an ls listing, a related commit from the same module, or a correct failure block with nearby extra context attached. Table 5 summarizes representative held-out examples. Figure 3 shows the same behavior on a compact kubectl observation, where the relevant evidence is a two-line failure block inside a much longer output. Query: Find the block showing the OOMKilled reason and exit code for the analytics-worker container. 23: State: Waiting 24: Reason: CrashLoopBackOff 25: Last State: Terminated 26: Reason: OOMKilled 27: Exit Code: 137 28: Started: Mon, 10 Mar 2026 08:12:45 +0000 … 30: Ready: False 31: Restart Count: 3 Gold span 26: Reason: OOMKilled 27: Exit Code: 137 Figure 3: Compact qualitative example from a kubectl observation. The full output has 250 lines; the gold evidence has two. 7 Limitations The benchmark evaluates pruning quality on single tool observations rather than full agent trajectories. It therefore measures evidence preservation directly, but not the downstream effect on end-to-end task completion. In addition, usefulness is approximated with span overlap, which cannot capture every valid alternative pruning decision. Finally, some tool families remain noisier than others, especially grep and lint_output. 8 Conclusion Squeez is a task-conditioned tool-output pruner for coding agents. The benchmark pairs grounded span annotations over 27 tool types with real SWE-bench workflows and synthetic multi-ecosystem observations. A compact LoRA-tuned Qwen 3.5 2B model reaches 0.86 recall while removing 92% of input tokens, outperforming the 18× larger Qwen 3.5 35B A3B and all heuristic baselines by a wide margin. The broader lesson is that mixed-format tool output is not handled well by zero-shot generative models or retrieval heuristics alone; it responds well to narrow, task-specific supervision. The model and evaluation code are available on GitHub, and the released model and dataset are available on Hugging Face. References N. Chirkova, T. Formal, V. Nikoulina, and S. Clinchant (2025) Provence: efficient and robust context pruning for retrieval-augmented generation. External Links: 2501.16214, Link Cited by: §2. T. Dettmers, A. Pagnoni, A. Holtzman, and L. Zettlemoyer (2023) QLoRA: efficient finetuning of quantized llms. In Advances in Neural Information Processing Systems, A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (Eds.), Vol. 36, p. 10088–10115. External Links: Link Cited by: §5. E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, and W. Chen (2021) LoRA: low-rank adaptation of large language models. External Links: 2106.09685, Link Cited by: §5. T. Hwang, S. Cho, S. Jeong, H. Song, S. Han, and J. C. Park (2025) EXIT: context-aware extractive compression for enhancing retrieval-augmented generation. In Findings of the Association for Computational Linguistics: ACL 2025, W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.), Vienna, Austria, p. 4895–4924. External Links: Link, Document, ISBN 979-8-89176-256-5 Cited by: §1, §2. H. Jiang, Q. Wu, C. Lin, Y. Yang, and L. Qiu (2023) LLMLingua: compressing prompts for accelerated inference of large language models. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, H. Bouamor, J. Pino, and K. Bali (Eds.), Singapore, p. 13358–13376. External Links: Link, Document Cited by: §1, §2. H. Jiang, Q. Wu, X. Luo, D. Li, C. Lin, Y. Yang, and L. Qiu (2024) LongLLMLingua: accelerating and enhancing LLMs in long context scenarios via prompt compression. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), L. Ku, A. Martins, and V. Srikumar (Eds.), Bangkok, Thailand, p. 1658–1677. External Links: Link, Document Cited by: §1, §2. C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. R. Narasimhan (2024) SWE-bench: can language models resolve real-world github issues?. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §4.1. I. Kerboua, S. O. Shayegan, M. Thakkar, X. H. Lù, L. Boisvert, M. Caccia, J. Espinas, A. Aussem, V. Eglin, and A. Lacoste (2025) FocusAgent: simple yet effective ways of trimming the large context of web agents. External Links: 2510.03204, Link Cited by: §1, §2. A. Kovacs, P. Schmitt, and G. Recski (2025) KR labs at ArchEHR-QA 2025: a verbatim approach for evidence-based question answering. In Proceedings of the 24th Workshop on Biomedical Language Processing (Shared Tasks), S. Soni and D. Demner-Fushman (Eds.), Vienna, Austria, p. 69–74. External Links: Link, Document Cited by: §2. Y. Liu and M. Lapata (2019) Text summarization with pretrained encoders. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), K. Inui, J. Jiang, V. Ng, and X. Wan (Eds.), Hong Kong, China, p. 3730–3740. External Links: Link, Document Cited by: §2. Qwen Team (2026) Qwen3.5: towards native multimodal agents. Note: https://qwen.ai/blog?id=qwen3.5Blog post Cited by: §5, §5. P. Rajpurkar, J. Zhang, K. Lopyrev, and P. Liang (2016) SQuAD: 100,000+ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, J. Su, K. Duh, and X. Carreras (Eds.), Austin, Texas, p. 2383–2392. External Links: Link, Document Cited by: §2. A. See, P. J. Liu, and C. D. Manning (2017) Get to the point: summarization with pointer-generator networks. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), R. Barzilay and M. Kan (Eds.), Vancouver, Canada, p. 1073–1083. External Links: Link, Document Cited by: §2. J. Thorne, A. Vlachos, C. Christodoulopoulos, and A. Mittal (2018) FEVER: a large-scale dataset for fact extraction and VERification. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), M. Walker, H. Ji, and A. Stent (Eds.), New Orleans, Louisiana, p. 809–819. External Links: Link, Document Cited by: §2. X. Wang, B. Li, Y. Song, F. F. Xu, X. Tang, M. Zhuge, J. Pan, Y. Song, B. Li, J. Singh, H. H. Tran, F. Li, R. Ma, M. Zheng, B. Qian, Y. Shao, N. Muennighoff, Y. Zhang, B. Hui, J. Lin, R. Brennan, H. Peng, H. Ji, and G. Neubig (2025) OpenHands: an open platform for ai software developers as generalist agents. External Links: 2407.16741, Link Cited by: §1. Y. Wang, Y. Shi, M. Yang, R. Zhang, S. He, H. Lian, Y. Chen, S. Ye, K. Cai, and X. Gu (2026) SWE-pruner: self-adaptive context pruning for coding agents. External Links: 2601.16746, Link Cited by: §1, §2. J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press (2024) SWE-agent: agent-computer interfaces enable automated software engineering. In Proceedings of the 38th International Conference on Neural Information Processing Systems, NIPS ’24, Red Hook, NY, USA. External Links: ISBN 9798331314385 Cited by: §1. Z. Yang, P. Qi, S. Zhang, Y. Bengio, W. Cohen, R. Salakhutdinov, and C. D. Manning (2018) HotpotQA: a dataset for diverse, explainable multi-hop question answering. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, E. Riloff, D. Chiang, J. Hockenmaier, and J. Tsujii (Eds.), Brussels, Belgium, p. 2369–2380. External Links: Link, Document Cited by: §2. Zilliz (2025) Semantic highlight bilingual model. Note: https://huggingface.co/zilliz/semantic-highlight-bilingual-v1Model card Cited by: §2.