Pith. sign in

REVIEW 1 major objections 6 minor 28 references

Reviewed by Pith at T0; open to challenge.

T0 means a machine referee read the full paper against a public rubric. The mark states how deep the mechanical check went, never who wrote it. the ladder, T0–T4 →

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

T0 review · glm-5.2

Agents that compress their own routines into reusable tools

2026-07-09 14:08 UTC pith:BAVNK6UC

load-bearing objection EvoSOP combines trajectory mining, tool merging, execution-based evaluation, and pruning into a unified iterative loop for LLM agent toolset optimization. The framework is well-engineered and the experimental gains are real, but there is a load-bearing evaluation gap: the checkpointing criterion selects the best iteration based on training-task success rate, and those same training tasks are part the 1 major comments →

arxiv 2607.07321 v1 pith:BAVNK6UC submitted 2026-07-08 cs.AI cs.CLcs.MA

From Atomic Actions to Standard Operating Procedures: Iterative Tool Optimization for Self-Evolving LLM Agents

Haipeng Ding , Yuexiang Xie , Zhewei Wei , Yaliang Li , Bolin Ding This is my paper
classification cs.AI cs.CLcs.MA
keywords LLM agentstool optimizationstandard operating proceduresself-evolving agentsnon-parametric learningtool lifecycle management
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 LLM-based agents can improve themselves without any parameter updates by discovering recurring patterns in their own action histories and packaging those patterns into reusable higher-level tools called Standard Operating Procedures (SOPs). The authors present EvoSOP, a framework that runs a four-phase lifecycle — construction, merging, evaluation, and pruning — to iteratively distill multi-step atomic-action sequences into callable functions, then test whether those functions actually help on real tasks, and cut the ones that do not. The central claim is that this loop of synthesizing, consolidating, empirically validating, and pruning tools produces a lean toolset that both raises task success rates and cuts the number of reasoning steps the agent needs per task, relative to agents that either use only atomic actions or create tools in a single one-shot pass. The paper draws an explicit analogy to a machine-learning training pipeline: trajectory collection stands in for data acquisition, task execution for forward propagation, SOP extraction for backpropagation, and merging/pruning for regularization — all without touching model weights. Experiments on two agent benchmarks show gains of 2.5–13.4 percentage points in success rate and a visible drop in interaction rounds over ten iterations, with the pruning step identified as the single most important contributor.

Core claim

The paper's central result is that an iterative, four-module lifecycle (Constructor, Merger, Evaluator, Reviewer) can transform raw execution traces into a compact set of reliable higher-order tools, and that doing so yields both higher success rates and fewer reasoning rounds compared to static atomic-action toolsets and one-shot tool-induction methods. The ablation study shows that the Reviewer — the module that empirically evaluates and prunes low-utility or buggy SOPs — has the largest individual impact, confirming that active toolset management matters more than tool creation alone. The case study and toolset-size tracking show the system converges to a small stable set (typically fewer

What carries the argument

The EvoSOP lifecycle has four modules. The Constructor scans execution trajectories for frequently co-occurring atomic-action sequences and rewrites them into callable SOP functions with docstrings and parameter schemas. The Merger identifies functionally overlapping SOPs within a training batch and consolidates them into generalized composite tools, without immediately removing the originals. The Evaluator re-runs all training tasks with the expanded toolset and records new trajectories that reveal each SOP's real-world reliability. The Reviewer classifies each SOP invocation into one of five states (optimal execution, partial utility, neutrality, negative interference, implementation

Load-bearing premise

The checkpointing mechanism selects the final toolset as the iteration with the highest training success rate, without a separate validation set, assuming that training performance reliably predicts test performance — a risky assumption given that only 25 trajectories are used and SOPs are constructed from those same trajectories.

What would settle it

If agents equipped with EvoSOP-evolved toolsets showed no success-rate improvement over agents using only atomic actions, or if the improvement disappeared when tested on task distributions different from the 25 training trajectories, the central claim that iterative tool optimization produces transferable capability gains would be undermined.

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

If this is right

  • If iterative toolset optimization works without parameter updates, it could be layered on top of any black-box LLM agent — including proprietary models where fine-tuning is impossible — as a plug-in self-improvement loop.
  • The pruning step's outsized importance suggests that the failure mode of prior one-shot tool-creation systems is not generating bad tools but failing to remove them, which is a simpler problem to fix than generating better tools.
  • The convergence to a compact toolset (fewer than 10 SOPs) implies there may be a natural ceiling on useful abstraction levels for a given task domain, beyond which additional hierarchy adds noise rather than capability.
  • The reasoning-round reduction observed in Figure 2 means lower API cost and latency per task, which could make long-horizon agent deployments economically viable where they currently are not.

Where Pith is reading between the lines

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

  • If training-set success rate is a noisy proxy for test-set generalization — as the reader notes flag — then the checkpointing mechanism could select an iteration whose SOPs encode training-specific quirks rather than transferable logic. A held-out validation set or cross-validation across trajectory batches would test whether the selected toolset generalizes beyond the 25 training tasks.
  • The analogy to a learning-rate decay is suggestive but untested: one could measure whether the toolset's edit distance between iterations follows a predictable decay curve, and whether that decay correlates with test-set performance, to determine if the convergence signal is genuine or an artifact of the fixed iteration budget.
  • The framework's reliance on the same LLM for both SOP construction and SOP evaluation creates a potential self-reinforcement loop: if the LLM systematically misjudges tool quality, the Reviewer would propagate rather than correct that bias. Using a different model family for evaluation than for construction would test this.
  • The five-state Reviewer taxonomy could be replaced with a continuous utility score, enabling softer pruning decisions (e.g., demotion to lower-priority retrieval rather than outright removal), which might recover some of the useful-but-imperfect SOPs the current binary remove/retain decision discards.

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

1 major / 6 minor

Summary. The paper introduces EvoSOP, a framework for iteratively optimizing LLM agent toolsets by synthesizing atomic actions into reusable Standard Operating Procedures (SOPs). The lifecycle consists of four modules: CONSTRUCTOR (extracts SOPs from trajectories), MERGER (consolidates redundant SOPs), EVALUATOR (re-executes tasks with updated toolset), and REVIEWER (prunes low-utility SOPs). Experiments on ACEBench and Tau2Bench show improvements of 2.5%–13.4% over baselines (Table 1), and the ablation study (Figure 3) supports the contribution of each module. The framework is parameter-free (no model weight updates) and model-agnostic.

Significance. The paper addresses a real gap: most prior work on tool creation for LLM agents treats it as a one-shot event without lifecycle management. The iterative construction-merging-evaluation-pruning loop is a reasonable design, and the ablation in Figure 3 provides evidence that each module contributes. The framework is parameter-free and model-agnostic, which is a practical strength. The case study (Figure 4) and toolset evolution analysis (Appendix C, Figure 5) provide useful qualitative insight. However, the central empirical claim rests on an evaluation protocol with a train/test separation issue that must be addressed before the results can be interpreted (see Major Comments).

major comments (1)
  1. §3.4 (Checkpointing) and Appendix B: The checkpointing mechanism selects the final toolset as the iteration with the highest training success rate. Appendix B states: 'The reported results include performance on both exposed and unseen tasks.' This means the 25 training tasks are included in the evaluation set, and the model selection criterion (training success rate) directly optimizes for a subset of the reported test metric. The headline gains in Table 1 (2.5%–13.4%) could be substantially driven by improvements on the 25 checkpointed tasks, with unknown gains on genuinely unseen tasks. The paper does not report seen vs. unseen performance separately. This is the most load-bearing issue because the central claim — 'significantly boosts task success rates' — is evaluated on a metric partially optimized during model selection. The fix is straightforward: report seen vs. unseen task性能seu
minor comments (6)
  1. Table 1: The '/' entries for ReAct and DFSDT under Gemini-3-FP and Qwen-Max columns are explained in Appendix B, but a footnote in the table itself would improve readability.
  2. §3.2: The conceptual parallel between EvoSOP and the ML pipeline (forward propagation, backward propagation, regularization, decaying learning rate) is presented as analogy. The paper should clarify that this is metaphorical, not a formal correspondence, to avoid overstating the connection.
  3. Figure 2: The y-axis label 'Rounds' and the legend could be clearer about whether these are per-task averages or aggregate counts across all tasks.
  4. Appendix C, Figure 5: The three curves (Constructed, Involved, Maintained SOPs) are described but 'Involved' is not clearly defined in the main text. Please add a brief definition.
  5. §4.2: The paper mentions '6 complete workflows on ACEBench and 3 complete workflows on Tau2Bench' (Appendix B). The rationale for these specific numbers and the variance implications should be briefly discussed.
  6. The paper does not report computational cost (API calls, token usage) beyond stating experiments ran on 'a standard CPU.' Given that EvoSOP involves multiple re-execution cycles, cost analysis would strengthen the practical assessment.

Circularity Check

0 steps flagged

No circularity found: EvoSOP's SOP construction, evaluation, and pruning are grounded in independent execution feedback from the environment, not in self-referential definitions.

full rationale

The paper's derivation chain is not circular. SOPs are constructed from execution trajectories (§3.3, CONSTRUCTOR), evaluated by re-executing tasks in a real environment (§3.3, EVALUATOR), and pruned based on empirical execution outcomes (§3.3, REVIEWER). The checkpointing mechanism (§3.4) selects the iteration with the highest training success rate, which is a model-selection criterion — not a circular definition. The reported gains in Table 1 are measured on benchmark tasks (ACEBench, Tau2Bench) via environment-determined success, not by a metric the framework defines. The conceptual parallel to ML training pipelines (forward/backward propagation, regularization) is explicitly framed as an analogy (§3.2: 'conceptual parallel'), not as a derivation. No step reduces to its inputs by construction, no prediction is a fitted parameter renamed, and no self-citation chain is load-bearing for the central claim. The train/test overlap concern raised by the skeptic is a methodological/generalization issue, not a circularity issue — the evaluation metric (task success) is determined by the environment, not defined by the framework.

Axiom & Free-Parameter Ledger

5 free parameters · 4 axioms · 1 invented entities

The axiom ledger captures the key parameters (iteration count, batch size, step limits, SOP size bounds) and the foundational assumptions (trajectory patterns are meaningful, training success generalizes, LLM judgments are reliable). The single invented entity (SOPs) has independent empirical validation through test-set evaluation.

free parameters (5)
  • max_iterations (M) = 10
    The number of optimization iterations is set to 10 (inferred from Figure 2 axis). Not fitted to data but chosen empirically.
  • mini-batch size = 5
    5 trajectories sampled per batch for the first 5 iterations (Appendix B). Chosen empirically.
  • max_steps (agent) = 100
    Maximum reasoning steps per task for ReAct and DFSDT (Appendix B).
  • max_beam_size (DFSDT) = 3
    Beam size for DFSDT search (Appendix B).
  • SOP tool_call bounds = min 2, max 5
    Constructor prompt constrains SOPs to contain 2-5 tool_call actions (Appendix D).
axioms (4)
  • domain assumption Recurring sequences of atomic tool calls in execution trajectories reflect meaningful logical or causal dependencies that can be abstracted into reusable procedures.
    This is the foundational premise of the CONSTRUCTOR module (§3.3). The entire framework depends on this being true for the SOPs to be useful.
  • ad hoc to paper Training-set success rate is a reliable proxy for test-set generalization when selecting the best iteration's toolset.
    The checkpointing mechanism (§3.4) selects the final toolset based on highest training success rate without a separate validation set.
  • domain assumption LLM-based modules (Constructor, Merger, Reviewer) can reliably identify functional overlap, assess tool quality, and categorize execution states from natural-language trajectories.
    The framework's modules depend on LLM judgments for extraction, merging, and review (§3.3). The accuracy of these judgments is assumed, not independently verified.
  • standard math The environment provides deterministic and reliable feedback for task success/failure.
    The EVALUATOR and REVIEWER depend on environment responses to assess SOP utility (§3.3). Standard assumption for tool-use benchmarks.
invented entities (1)
  • Standard Operating Procedures (SOPs) as callable higher-order tools independent evidence
    purpose: Encapsulate multi-step atomic action logic into reusable single-call functions with conditional logic and error handling.
    SOPs are evaluated by re-execution on training and test tasks (Table 1), providing falsifiable evidence of their utility beyond the construction process.

pith-pipeline@v1.1.0-glm · 19568 in / 2709 out tokens · 264175 ms · 2026-07-09T14:08:34.066846+00:00 · methodology

0 comments
read the original abstract

Tool utilization enables Large Language Model (LLM) agents to interact with the real world and resolve complex tasks. However, existing agent frameworks predominantly rely on static toolsets composed of granular atomic actions (e.g., basic file I/O or single-turn search), which forces agents to reinvent low-level logic for every recurring workflow, leading to increased reasoning overhead and failure rates. In this study, we propose that agents can achieve self-evolution by synthesizing these atomic actions into reusable Standard Operating Procedures (SOPs), which function as callable higher-order tools that encapsulate multi-step logic. We further introduce EvoSOP, a framework that empowers agents to extract SOPs from execution trajectories and iteratively optimize the toolset through a systematic lifecycle of construction, merging, evaluation, and pruning. Extensive experiments demonstrate that EvoSOP significantly boosts task success rates while substantially reducing the number of interaction rounds compared to baselines. Our analysis also reveals that iterative tool optimization fosters reliable and efficient tool-use patterns, providing a scalable pathway for the development of self-evolving agents.

Figures

Figures reproduced from arXiv: 2607.07321 by Bolin Ding, Haipeng Ding, Yaliang Li, Yuexiang Xie, Zhewei Wei.

Figure 1
Figure 1. Figure 1: The overall architecture of EVOSOP, illustrating the iterative tool optimization lifecycle. The framework employs four collaborative modules, including CONSTRUCTOR, MERGER, EVALUATOR, and REVIEWER. 3 Methodology 3.1 Design Motivation and Principle As mentioned in Section 1, most LLM-based agents rely on a static toolset F composed of granular atomic actions. While recent studies have explored expanding the… view at source ↗
Figure 3
Figure 3. Figure 3: Performance of EVOSOP and its ablated vari￾ants in dataset ACEBench. rounds stabilizes at a significantly lower level than that of baselines. Such reasoning compression not only reduces API latency and cost but also min￾imizes the risk of the agent losing focus within long-horizon trajectories, which is a primary driver of the observed increase in success rates. 4.3 Ablation Study To quantify the individua… view at source ↗
Figure 4
Figure 4. Figure 4: The lifetime of synthesized SOPs. The num [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Trends of constructed, involved, and main [PITH_FULL_IMAGE:figures/full_fig_p013_5.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

28 extracted references · 28 canonical work pages · 13 internal anchors

  1. [1]

    Liu , title =

    Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu , title =. J. Mach. Learn. Res. , volume =. 2020 , bibsource =

    work page 2020

  2. [2]

    LLaMA: Open and Efficient Foundation Language Models

    Hugo Touvron and Thibaut Lavril and Gautier Izacard and Xavier Martinet and Marie. LLaMA: Open and Efficient Foundation Language Models , journal =. 2023 , eprinttype =. 2302.13971 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2023

  3. [3]

    Tom B. Brown and Benjamin Mann and Nick Ryder and Melanie Subbiah and Jared Kaplan and Prafulla Dhariwal and Arvind Neelakantan and Pranav Shyam and Girish Sastry and Amanda Askell and Sandhini Agarwal and Ariel Herbert. Language Models are Few-Shot Learners , booktitle =. 2020 , bibsource =

    work page 2020

  4. [4]

    Evaluating Large Language Models Trained on Code

    Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan and Henrique Pond. Evaluating Large Language Models Trained on Code , journal =. 2021 , eprinttype =. 2107.03374 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  5. [5]

    The Twelfth International Conference on Learning Representations,

    Gr. The Twelfth International Conference on Learning Representations,. 2024 , bibsource =

    work page 2024

  6. [6]

    Narasimhan and Yuan Cao , title =

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

    work page 2023

  7. [7]

    The Twelfth International Conference on Learning Representations,

    Yujia Qin and Shihao Liang and Yining Ye and Kunlun Zhu and Lan Yan and Yaxi Lu and Yankai Lin and Xin Cong and Xiangru Tang and Bill Qian and Sihan Zhao and Lauren Hong and Runchu Tian and Ruobing Xie and Jie Zhou and Mark Gerstein and Dahai Li and Zhiyuan Liu and Maosong Sun , title =. The Twelfth International Conference on Learning Representations,. 2...

    work page 2024

  8. [8]

    Forty-first International Conference on Machine Learning,

    Xingyao Wang and Yangyi Chen and Lifan Yuan and Yizhe Zhang and Yunzhu Li and Hao Peng and Heng Ji , title =. Forty-first International Conference on Machine Learning,. 2024 , bibsource =

    work page 2024

  9. [9]

    Inducing Programmatic Skills for Agentic Tasks

    Zora Zhiruo Wang and Apurva Gandhi and Graham Neubig and Daniel Fried , title =. CoRR , volume =. 2025 , eprinttype =. 2504.06821 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  10. [10]

    The Twelfth International Conference on Learning Representations,

    Lifan Yuan and Yangyi Chen and Xingyao Wang and Yi Fung and Hao Peng and Heng Ji , title =. The Twelfth International Conference on Learning Representations,. 2024 , bibsource =

    work page 2024

  11. [11]

    Brent Venable , title =

    Francesco Fabiano and Marianna Bergamaschi Ganapini and Andrea Loreggia and Nicholas Mattei and Keerthiram Murugesan and Vishal Pallagani and Francesca Rossi and Biplav Srivastava and K. Brent Venable , title =. Commun. 2025 , bibsource =

    work page 2025

  12. [12]

    REST: Stress Testing Large Reasoning Models by Asking Multiple Problems at Once

    Zhuoshi Pan and Qizhi Pei and Yu Li and Qiyao Sun and Zinan Tang and H. Vicky Zhao and Conghui He and Lijun Wu , title =. CoRR , volume =. 2025 , eprinttype =. 2507.10541 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  13. [13]

    Kimi K2: Open Agentic Intelligence

    Yifan Bai and Yiping Bao and Guanduo Chen and Jiahao Chen and Ningxin Chen and Ruijue Chen and Yanru Chen and Yuankun Chen and Yutian Chen and Zhuofu Chen and Jialei Cui and Hao Ding and Mengnan Dong and Angang Du and Chenzhuang Du and Dikang Du and Yulun Du and others , title =. CoRR , volume =. 2025 , eprinttype =. 2507.20534 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  14. [14]

    From Exploration to Mastery: Enabling LLMs to Master Tools via Self-Driven Interactions , booktitle =

    Changle Qu and Sunhao Dai and Xiaochi Wei and Hengyi Cai and Shuaiqiang Wang and Dawei Yin and Jun Xu and Ji. From Exploration to Mastery: Enabling LLMs to Master Tools via Self-Driven Interactions , booktitle =. 2025 , bibsource =

    work page 2025

  15. [15]

    DeepAgent:

    Xiaoxi Li and Wenxiang Jiao and Jiarui Jin and Guanting Dong and Jiajie Jin and Yinuo Wang and Hao Wang and Yutao Zhu and Ji. DeepAgent:. CoRR , volume =. 2025 , eprinttype =. 2510.21618 , bibsource =

    work page arXiv 2025

  16. [16]

    Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies,

    Siyu Yuan and Kaitao Song and Jiangjie Chen and Xu Tan and Yongliang Shen and Kan Ren and Dongsheng Li and Deqing Yang , title =. Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies,. 2025 , bibsource =

    work page 2025

  17. [17]

    SkillWeaver: Web Agents can Self-Improve by Discovering and Honing Skills

    Boyuan Zheng and Michael Y. Fatemi and Xiaolong Jin and Zora Zhiruo Wang and Apurva Gandhi and Yueqi Song and Yu Gu and Jayanth Srinivasa and Gaowen Liu and Graham Neubig and Yu Su , title =. CoRR , volume =. 2025 , eprinttype =. 2504.07079 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  18. [18]

    2023 , eprint=

    Voyager: An Open-Ended Embodied Agent with Large Language Models , author=. 2023 , eprint=

    work page 2023

  19. [19]

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

    Creator: Tool creation for disentangling abstract and concrete reasoning of large language models , author=. Findings of the Association for Computational Linguistics: EMNLP 2023 , pages=

    work page 2023

  20. [20]

    CoRR , volume =

    Chen Chen and Xinlong Hao and Weiwen Liu and Xu Huang and Xingshan Zeng and Shuai Yu and Dexun Li and Shuai Wang and Weinan Gan and Yuefeng Huang and Wulong Liu and Xinzhi Wang and Defu Lian and Baoqun Yin and Yasheng Wang and Wu Liu , title =. CoRR , volume =. 2025 , eprinttype =. 2501.12851 , bibsource =

    work page arXiv 2025

  21. [21]

    $\tau^2$-Bench: Evaluating Conversational Agents in a Dual-Control Environment

    Victor Barres and Honghua Dong and Soham Ray and Xujie Si and Karthik Narasimhan , title =. CoRR , volume =. 2025 , eprinttype =. 2506.07982 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  22. [22]

    ToolScope: Enhancing LLM Agent Tool Use through Tool Merging and Context-Aware Filtering

    Marianne Menglin Liu and Daniel Garcia and Fjona Parllaku and Vikas Upadhyay and Syed Fahad Allam Shah and Dan Roth , title =. CoRR , volume =. 2025 , eprinttype =. 2510.20036 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  23. [23]

    Alita: Generalist Agent Enabling Scalable Agentic Reasoning with Minimal Predefinition and Maximal Self-Evolution

    Jiahao Qiu and Xuan Qi and Tongcheng Zhang and Xinzhe Juan and Jiacheng Guo and Yifu Lu and Yimin Wang and Zixin Yao and Qihan Ren and Xun Jiang and Xing Zhou and Dongrui Liu and Ling Yang and Yue Wu and Kaixuan Huang and Shilong Liu and Hongru Wang and Mengdi Wang , title =. CoRR , volume =. 2025 , eprinttype =. 2505.20286 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  24. [24]

    Enhancing Open-Domain Task-Solving Capability of LLMs via Autonomous Tool Integration from GitHub

    Bohan Lyu and Xin Cong and Heyang Yu and Pan Yang and Yujia Qin and Yining Ye and Yaxi Lu and Zhong Zhang and Yukun Yan and Yankai Lin and Zhiyuan Liu and Maosong Sun , title =. CoRR , volume =. 2023 , eprinttype =. 2312.17294 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2023

  25. [25]

    AgentScope 1.0: A Developer-Centric Framework for Building Agentic Applications

    Dawei Gao and Zitao Li and Yuexiang Xie and Weirui Kuang and Liuyi Yao and Bingchen Qian and Zhijian Ma and Yue Cui and Haohao Luo and Shen Li and Lu Yi and Yi Yu and Shiqi He and Zhiling Luo and Wenmeng Zhou and Zhicheng Zhang and Xuguang He and Ziqian Chen and Weikai Liao and Farruh Isakulovich Kushnazarov and Yaliang Li and Bolin Ding and Jingren Zhou ...

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  26. [26]

    A Survey of Self-Evolving Agents: What, When, How, and Where to Evolve on the Path to Artificial Super Intelligence

    Huan. A Survey of Self-Evolving Agents: On Path to Artificial Super Intelligence , journal =. 2025 , eprinttype =. 2507.21046 , bibsource =

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  27. [27]

    Proceedings of the 31st International Conference on Computational Linguistics,

    Xinzhe Li , title =. Proceedings of the 31st International Conference on Computational Linguistics,. 2025 , bibsource =

    work page 2025

  28. [28]

    GPT-4o System Card

    OpenAI , title =. CoRR , volume =. 2024 , url =. doi:10.48550/ARXIV.2410.21276 , eprinttype =. 2410.21276 , timestamp =

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.2410.21276 2024