Artificial Intelligence · arXiv:2610.39508 v1 · submitted 29 Oct 2026 · 43 references
Compile Away Uncertainty: Self-Evolving Agent Skills via Programmatic Compilation
The paper says
“Self-evolving agent skills enable AI agents to accumulate and refine reusable procedural knowledge from interaction experience without updating model parameters.”
more of the abstract
However, since such skills are typically represented as textual documents and executed through LLM reasoning, even previously learned procedures must be repeatedly interpreted and regenerated, introducing avoidable uncertainty into every execution. In contrast, program execution is deterministic and independently verifiable. Intuitively, transforming well-specified operations into executable programs can reduce reliance on LLM reasoning and, consequently, reduce execution uncertainty. Motivated by this intuition, we introduce SKillCompiler, a self-evolving skill framework that integrates programmatic compilation into the skill evolution process. Specifically, SkillCompiler adopts an executability-aware skill compilation strategy that decomposes skills into fine-grained operations, analyzes their executability, and constructs hybrid skill skeletons that retain LLM reasoning for context-dependent operations while compiling well-specified ones into validated programs. To avoid redundant program synthesis and enable executable knowledge to accumulate across evolving skills, we further design a program asset reuse mechanism that organizes validated programs as reusable assets, retrieves existing implementations whenever applicable, and synthesizes and verifies new programs only when necessary. Extensive experiments on five benchmarks and six model families demonstrate that SkillCompiler consistently outperforms state-of-the-art methods, achieving up to 32.33% improvement in task performance.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 30 Oct 2026 · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions. A real mechanism with a careful protocol; the performance claim is credible, but the uncertainty-reduction claim needs an error decomposition before it can be trusted. This line is wrong
2 major objections · 6 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 43 references say.
The paper says, at Section IV-C / Appendix Eq. (8)
The review did not quote this passage.
Pith says: Objection 1 of 2 · major
The stress-test concern about EIR lands on reading the paper. EIR@3 counts only tasks with both a success and a failure across the three repetitions, so tasks that fail all three times contribute zero. On LiveMath (100 test tasks), the reported EM of 78.67 implies about 21.33 failures per run, i.e., roughly 64 failures across 300 executions, while EIR@3 = …
more of objection 1
… 11.00 means at most 11 tasks flip, contributing at most 22 of those failures; a substantial share of failures therefore comes from tasks that fail deterministically on every repetition. Converting stochastic failures into repeatable deterministic failures lowers EIR without reducing "execution uncertainty" in the sense claimed in the abstract and Section I, and Table VII's PIS of 88.84% (about 11% of started program invocations recorded as unsuccessful) shows that the deterministic-error channel is not hypothetical. Because Section IV-F (b210) concedes that local validation establishes correctness only under tested inputs and environment states, the EIR gap of 32.00% to 11.00% in Table IV does not by itself establish the uncertainty-reduction claim. Please report, for each method on LiveMath and ALFWorld, the full three-way decomposition of tasks into always-correct, flip, and always-wrong categories using Eqs. (7)–(8), and trace the always-wrong tasks under SkillCompiler to compiled-program failures versus other causes.
This review says the paper's mathematics is wrong. Pith did not check that against the paper's source.
The paper says, at Section III-B.1–B.4 / Eq. (1)
The review did not quote this passage.
Pith says: Objection 2 of 2 · major
The pipeline that decides which operations are "well-specified" and writes the check functions check_i is the same LLM pipeline that is being partially displaced, and programs are admitted on the basis of validation against those LLM-written checks. The appendix's "Source-grounded checks" describe a stronger, reference-based validation protocol, but the manuscript does not state whether that protocol is applied to every …
more of objection 2
… compiled program on every benchmark before admission or only in restricted settings (the appendix conditions parameter variations on the source supplying a valid independent reference). Please state the coverage of reference-based validation explicitly, quantify how many admitted programs were validated against external references versus check_i alone, and report how many of the deterministically failing tasks trace to incorrect executability judgments or incorrect check functions. This decomposition is the concrete test that would separate a genuine reduction in outcome uncertainty from a reallocation of failures from stochastic to deterministic channels; the concern is a correctness-risk issue rather than a circularity accusation.
6 minor objections
The paper says, at Abstract / Section IV-B.1
Pith says: minor objection 1 of 6
The "up to 32.33% improvement" is an absolute percentage-point gain (77.00 versus 44.67 on LiveMath), while Section IV-C reports a "relative reduction of 65.6%" for EIR; please state absolute versus relative terminology consistently so the headline number is not misread as a relative improvement.
The paper says, at Section IV-D / Tables V–VI
Pith says: minor objection 2 of 6
On LiveMath, SkillCompiler's per-task inference tokens (13.984k) exceed SkillOpt's (6.672k), so the sentence saying SkillCompiler improves performance "without necessarily increasing inference costs" understates the tradeoff; one sentence on the accuracy-per-token tradeoff would clarify the cost analysis.
show 4 more
The paper says, at Eq. (3)
Pith says: minor objection 3 of 6
The retrieval weights w_u = 0.1 and w_a = 0.05 and the contract-compatibility filtering threshold are presented without justification or sensitivity analysis; a brief note on their origin or a one-point sensitivity check would suffice, especially since the appendix already states that no embedding-based retrieval is used.
The paper says, at Appendix
Pith says: minor objection 4 of 6
GCC (Graph Construction Coverage) is defined in the appendix but never used in the main text or in any reported result; either report it or remove the definition.
The paper says, at Section IV-C / Appendix (Repeated execution)
Pith says: minor objection 5 of 6
Please state the sampling temperature used for the three fixed-bank repetitions, since EIR@3 is informative only if the underlying LLM responses are stochastic.
The paper says, at Section IV-C / Fig. 2
Pith says: minor objection 6 of 6
The interpretation of EPR@3 (44.8%) alongside EIR@3 (3.0%) on ALFWorld would benefit from one sentence noting that exact path repetition is a much stricter standard than outcome-level stability, so the two numbers are not in tension.
What would settle it
Using the seed-42 LiveMath bank with Gemini-3.8-Flash, reconstruct the three-run outcome of every test task and split the 100 tasks by (a) success count over three runs and (b) whether a compiled program was invoked in the failing runs. Compute the all-fail rate among program-invoking tasks and the flip-only rate among agent-guided tasks. If program-invoking all-fail tasks account for most of the 21.33% EM error, the EIR reduction reflects deterministic-error compression and the uncertainty claim must be re-scoped; if errors concentrate in agent-guided flips, the concern is resolved.
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 30 Oct 2026
- Reader holds up, with conditions
- Skeptic partly agrees
- Editor wrote the verdict above
- Referee major revision: 2 major objections, 6 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
Short version: this is worth reading and worth refereeing. The operation-level executability split with a persistent program asset bank is a real combination I have not seen in the cited literature, and the authors run a noticeably more careful protocol than most skill-evolution papers. I take the main performance claim seriously; I take the uncertainty-reduction claim with a grain of salt until they report the error decomposition.
What is good. The core idea is coherent: keep LLM reasoning for context-dependent decisions, compile well-specified operations into validated programs, and store those programs for reuse. The appendix is unusually explicit about reporting units, frozen banks, per-seed accounting, program validation limits, and side-effect handling. The ablation points the right way: removing the Programmer drops ALFWorld success from 98.26 to 53.48 and multiplies test tokens by about 7.4, which is evidence that programmatic execution is doing real work rather than decoration. The 14-point EM gain on LiveMath over SkillOpt is large, and the advantage appears across all six model families, so the headline direction is probably not noise.
Where I would push. The closest programmatic-skill baselines cited in related work — FlowEvo, SkillDisCo, NSI, Agent Skill Induction — are absent from the experiments. That is the biggest hole. The comparison is against textual-skill evolution methods, so "consistently outperforms state of the art" is a qualified claim. At minimum, a program-aided baseline is needed to isolate the effect of code execution. Second, the stress-test concern about EIR has teeth. EIR@3 counts only tasks with both successes and failures; converting stochastic failures into deterministic all-fails lowers EIR without reducing outcome uncertainty in any meaningful sense. The paper's own PIS number, 88.84% on ALFWorld, shows that around 11% of started program invocations are unsuccessful, so the deterministic-error channel is real. The appendix defines RSR but no RSR or all-fail rate is reported. Reporting the flip/all-fail split would settle this and is cheap. Third, no code or data is released, and no per-seed variance or significance tests are reported; the appendix gives the recipe but not the results. A minor reporting point: the headline "32.33% improvement" is a percentage-point gain, not a relative improvement.
Bottom line: the mechanism is novel and the protocol is careful enough that the paper deserves a serious referee. I would want the baseline gap and EIR decomposition addressed before acceptance. That is a conditional-accept trajectory, not a rejection.
The strongest objection
SkillCompiler's executability judgment and validation are both produced by the same LLM pipeline: the task analyzer writes check_i in Eq. (1) and the programmer validates candidate programs against it, with no independent oracle. If that judgment is wrong, an admitted program fails identically on every repetition. EIR@3 (Eq. 8) counts only tasks with both success and failure across three runs, so deterministic all-fail tasks contribute zero EIR. In Table IV, SkillCompiler improves EM by 14 points and lowers EIR by 21 points versus SkillOpt; with only 21.33% of LiveMath tasks failing EM, a sizable part of the EIR gap could be produced by converting stochastic failures into deterministic ones rather than by genuinely reducing outcome uncertainty. The paper's own PIS statistic (Table VII, 88.84%) shows that over 11% of started program invocations are recorded as unsuccessful, so the deterministic-error channel is not hypothetical. The authors state in Section IV-F (b210) that local validation does not generalize to unseen conditions; combined with EIR's construction, the reported uncertainty reduction is ambiguous unless the error budget is decomposed into all-fail and flip components.
The reader's weakest assumption already identified the circularity risk and the possibility of silent, repeatable failures. I agree with that root and add the measurement consequence: because EIR@3 is defined over outcome flips, a deterministic wrong program improves the headline instability metric without improving reliability. That makes the concern load-bearing for the paper's second main claim, reducing execution uncertainty, not just for safe deployment. The paper does report higher EM alongside lower EIR, and the large margin on ALFWorld and the w/o-Programmer ablation are real evidence in its favor; however, the reported aggregation cannot separate genuine stabilization from variance compression. The proposed decomposition is cheap and uses already-recorded execution traces. I keep the reader's CONDITIONAL verdict because the concern is testable and does not by itself disprove the central mechanism; it strengthens the conditions under which the uncertainty claim should be accepted.
The referee's report
If the empirical claims hold, the paper makes a useful contribution: operation-level selective compilation with persistent program asset reuse is a reasonably novel design within the self-evolving-skills literature, and the performance gains on LiveMath and OfficeQA are large and consistent across six model families. The experimental protocol is careful by community standards: three seeds, a skill bank frozen before test evaluation, benchmark-native evaluators, explicit metric formulas with named denominators, and per-seed numerators for the program-execution statistics; the ablation showing that disabling the Programmer halves ALFWorld success directly evidences that programmatic execution, not the skill skeleton alone, drives the gain. The load-bearing issue is the uncertainty-reduction claim, which is exactly the part of the evaluation that is under-determined: EIR@3 counts only outcome flips, so deterministic all-fail tasks contribute zero, and the paper's own program-invocation success rate of 88.84% (Table VII) plus its stated limitation that local validation does not generalize (Section IV-F, b210) show that the deterministic-error channel is real.
Pith's reading of the paper (a machine's summary, not the authors')
Agent skills stored as text documents force the language model to re-derive the same procedure on every run, so even a perfected skill produces different outcomes each time. This paper claims that much of that uncertainty can be compiled away: decompose a skill into fine-grained operations, judge which ones are well-specified, and replace those with validated executable programs while leaving context-dependent decisions to LLM reasoning. The resulting framework, SkillCompiler, reports consistently higher average task performance than text-based skill evolution across six model families on five benchmarks, with the largest gains on mathematical reasoning and document tasks. It also reports steadier behavior under repeated execution: the fraction of tasks whose outcome flips between success and failure drops from 32% to 11% on LiveMath and to 3% on ALFWorld. If correct, this means agents can accumulate reliable executable knowledge without retraining the model, improving both accuracy and repeatability at once.
What carries the argument. The load-bearing object is the operation contract $\kappa_i = \langle I_i, O_i, \mathrm{pre}_i, \mathrm{post}_i, \mathrm{check}_i, g_i \rangle$, a six-part specification of inputs, outputs, preconditions, expected local effects, a check function defining how effects are verified, and reusable execution guidance. The check function is what makes an operation eligible for compilation: a synthesized program is validated against it in an isolated environment, and only validated programs are admitted to the skill skeleton and the persistent program asset bank. The hybrid skill skeleton $S_x = \langle O_x, \sigma_x, E_x, \beta_x \rangle$ carries the collaboration between deterministic programs and LLM reasoning, recording execution order, data and prerequisite relations, and argument bindings. Program asset reuse, governed by compatibility predicates over binding, preconditions, environment, and validation record, is what turns one-off compiled programs into accumulating executable knowledge across evolving skills.
Core claim. The paper's central discovery is that operation-level selective compilation makes skill execution both better and more predictable. On the paper's own terms: LLM reasoning is probabilistic, so interpreting the same textual skill repeatedly reintroduces uncertainty even when the skill itself never changes, whereas a compiled program encodes inputs, control flow, and state transformations explicitly, so the same operation follows a fixed procedure under fixed conditions. SkillCompiler therefore splits each skill into a hybrid skeleton $S_x = \langle O_x, \sigma_x, E_x, \beta_x \rangle$ in which well-specified operations are realized as validated programs and context-dependent operations remain agent-guided. Across three seeds on five benchmarks and six model families it claims the highest average score in every setting, including a 32.33% improvement over the strongest baseline on LiveMath with GLM-5.3-Flash, a 98.26% success rate on ALFWorld, and a drop in outcome-reversal rate from 32.00% to 11.00% on LiveMath. The claim is that compiled programs, persistently banked and reused across skills, deliver the accuracy gain while deterministic execution delivers the stability gain.
The premise it rests on. The whole pipeline rests on the task-analyzer model correctly decomposing tasks, judging which operations are truly well-specified, and writing the check functions that the compiled programs are validated against; the paper itself concedes that this local validation holds only under tested inputs and environment states, so a wrong executability judgment can install a deterministic program that passes its own model-written checks and then fails silently and repeatably.
If the paper is right (Pith's inferences, not the authors')
On benchmarks where operations recur with explicit inputs, clear procedures, and verifiable effects, the gains are largest: LiveMath improves by up to 32.33% and OfficeQA by up to roughly 17 points over the strongest baseline, while the nearly saturated SearchQA and DocVQA gains are small.
With a frozen skill bank, repeated executions flip between success and failure far less often: EIR@3 drops from 32.00% to 11.00% on LiveMath and to 3.0% on ALFWorld, so applications that need repeatable behavior inherit that stability.
Executable knowledge compounds across skills instead of being re-synthesized per skill: on ALFWorld, 54.85% of used programs are invoked by at least two distinct skill skeletons and 87.06% of environment actions occur inside program execution spans.
Failure recovery becomes local: the trace-based optimizer revises only the operations whose contracts were violated, so a failed task does not force whole-skill regeneration.
Because the reported gains appear across six model families without updating model parameters, the compilation layer is model-agnostic and can be layered onto existing agent pipelines.
A natural next test is dynamic web environments, which the paper explicitly leaves open: the key question there is whether frozen check functions stay valid as page structures and APIs drift, since the paper's own validation does not cover unseen conditions.
The verification loop is only as independent as the model that writes the check functions; commissioning contract-writing to a separate stronger model or to formal specifications would make the claim that programs are 'independently verified' harder to challenge.
The fraction of operations that cross the executability threshold could become a measurement in its own right: as models write better contracts, more of a skill should become compilable, making the compile rate a proxy for how much procedural knowledge has been made explicit.
Outcome-flip metrics like EIR@3 under a frozen bank measure reliability separately from mean accuracy; reporting them alongside accuracy would let the field distinguish methods that are merely better on average from methods that are genuinely more deterministic.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Self-evolving agent skills enable AI agents to accumulate and refine reusable procedural knowledge from interaction experience without updating model parameters. However, since such skills are typically represented as textual documents and executed through LLM reasoning, even previously learned procedures must be repeatedly interpreted and regenerated, introducing avoidable uncertainty into every execution. In contrast, program execution is deterministic and independently verifiable. Intuitively, transforming well-specified operations into executable programs can reduce reliance on LLM reasoning and, consequently, reduce execution uncertainty. Motivated by this intuition, we introduce SKillCompiler, a self-evolving skill framework that integrates programmatic compilation into the skill evolution process. Specifically, SkillCompiler adopts an executability-aware skill compilation strategy that decomposes skills into fine-grained operations, analyzes their executability, and constructs hybrid skill skeletons that retain LLM reasoning for context-dependent operations while compiling well-specified ones into validated programs. To avoid redundant program synthesis and enable executable knowledge to accumulate across evolving skills, we further design a program asset reuse mechanism that organizes validated programs as reusable assets, retrieves existing implementations whenever applicable, and synthesizes and verifies new programs only when necessary. Extensive experiments on five benchmarks and six model families demonstrate that SkillCompiler consistently outperforms state-of-the-art methods, achieving up to 32.33% improvement in task performance.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-10-30
The authors' main claim, as the classifier picked it out 1.00
“Extensive experiments on five benchmarks and six model families demonstrate that SkillCompiler consistently outperforms state-of-the-art methods, achieving up to 32.33\% improvement in task performance.”
How the main claim is stated: asserted 1.00
What the abstract itself states, as probabilities: claims first 0.07 · states limitation 0.15 · human participants 0.05 · controlled comparison 0.66 · randomized assignment 0.02 · states quantitative result 0.99 · compares with prior results 0.96 · mentions code or data availability 0.04
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Self-evolving agent skills enable AI agents to accumulate and refine reusable procedural knowledge from interaction experience without updating model parameters. | background 1.00 | 0.08 | 0.05 | asserted 1.00 |
| However, since such skills are typically represented as textual documents and executed through LLM reasoning, even previously learned procedures must be repeatedly interpreted and regenerated, introducing avoidable uncertainty into every execution. | background 0.68 | 0.10 | 0.03 | asserted 0.97 |
| In contrast, program execution is deterministic and independently verifiable. | background 0.97 | 0.06 | 0.04 | asserted 1.00 |
| Intuitively, transforming well-specified operations into executable programs can reduce reliance on LLM reasoning and, consequently, reduce execution uncertainty. | background 0.75 | 0.08 | 0.10 | hedged possibility 0.83 |
| Motivated by this intuition, we introduce SKillCompiler, a self-evolving skill framework that integrates programmatic compilation into the skill evolution process. | contribution 1.00 | 0.88 | 0.09 | asserted 0.97 |
| Specifically, SkillCompiler adopts an executability-aware skill compilation strategy that decomposes skills into fine-grained operations, analyzes their executability, and constructs hybrid skill skeletons that retain LLM reasoning for context-dependent operations while compiling well-specified ones into validated programs. | method 0.97 | 0.89 | 0.06 | asserted 0.99 |
| To avoid redundant program synthesis and enable executable knowledge to accumulate across evolving skills, we further design a program asset reuse mechanism that organizes validated programs as reusable assets, retrieves existing implementations whenever applicable, and synthesizes and verifies new programs only when necessary. | method 0.92 | 0.90 | 0.04 | asserted 0.99 |
| Extensive experiments on five benchmarks and six model families demonstrate that SkillCompiler consistently outperforms state-of-the-art methods, achieving up to 32.33\% improvement in task performance. | result 1.00 | 0.96 | 0.76 | asserted 1.00 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 1.00
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-10-30: 1 request, 6,388 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (2)
Figures are the authors', reproduced from the paper.
References (43)
- [1] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. InInternational Conference on Learning Representations. https://arxiv.org/abs/2210.03629 on PithPith's reviewarXiv
- [2] Xiang Deng, Yu Gu, Boyuan Zheng, Shijie Chen, Samuel Stevens, Boshi Wang, Huan Sun, and Yu Su. 2023. Mind2Web: Towards a Generalist Agent for the Web. InAdvances in Neural Information Processing Systems, V ol. 36. https://arxiv.org/abs/2306.06070 on PithPith's reviewarXiv
- [3] Shuyan Zhou, Frank F. Xu, Hao Zhu, Xuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng, Tianyue Ou, Yonatan Bisk, Daniel Fried, Uri Alon, and Graham Neubig. 2024. WebArena: A Realistic Web Environment for Building Autonomous Agents. InInternational Conference on Learning Repr... on PithPith's reviewarXiv
- [4] Hongliang He, Wenlin Yao, Kaixin Ma, Wenhao Yu, Yong Dai, Hongming Zhang, Zhenzhong Lan, and Dong Yu. 2024. WebV oyager: Building an End-to-End Web Agent with Large Multimodal Models. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics, 68... on Pithdoi:10.18653/v1/2024.acl-long.371
- [5] Zhengliang Shi, Shen Gao, Lingyong Yan, Yue Feng, Xiuyi Chen, Zhumin Chen, Dawei Yin, Suzan Verberne, and Zhaochun Ren. 2025. Tool Learning in the Wild: Empowering Language Models as Automatic Tool Agents. InProceedings of the ACM Web Conference 2025. https: //doi.org/10.1145/... on Pithdoi:10.1145/3696410.3714825
- [6] Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Reflexion: Language Agents with Verbal Reinforcement Learning. InAdvances in Neural Information Processing Systems, V ol. 36. https://papers.neurips.cc/paper files/paper/2023/hash/ 1b44b87... on Pith
- [7] Andrew Zhao, Daniel Huang, Quentin Xu, Matthieu Lin, Yong-Jin Liu, and Gao Huang. 2024. ExpeL: LLM Agents Are Experiential Learners. Proceedings of the AAAI Conference on Artificial Intelligence38, 17 (2024), 19632–19642. https://doi.org/10.1609/aaai.v38i17.29936 on Pithdoi:10.1609/aaai.v38i17.29936
- [8] Boxun Lan, Jiamei Li, Weijian Li, Chengyu Yang, Zhuang Qi, Chengcheng Wan, Xiaohong Chen, and Ming Hu. 2026. FedSkillGit: Federated Skill Evolution via Version Control.arXiv:2610.21348. https: //arxiv.org/abs/2610.21348 on PithPith's reviewarXiv
- [9] Jingwei Ni, Yihao Liu, Xinpeng Liu, Yutao Sun, Mengyu Zhou, Pengyu Cheng, Dexin Wang, Erchao Zhao, Xiaoxi Jiang, and Guanjun Jiang on Pith
- [10] Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou, Zisu Huang, Yan Li, Xuemei Gao, Qi Dai, Bei Liu, Kai Qiu, Yuqing Yang, Dongdong Chen, Xue Yang, and Chong Luo. 2026. SkillOpt: Executive Strategy for Self-Evolving Agent Skills.arXiv:2605.23904. https://arxiv.org/... on PithPith's reviewarXiv
- [11] Lakshya A. Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong, Arnav Singhvi, Herumb Shandilya, Michael J. Ryan, Meng Jiang, Christopher Potts, Koushik Sen, Alex Dimakis, Ion Stoica, Dan Klein, Matei Zaharia, and Omar Khattab. 2026. GEPA: Reflectiv... on Pith
- [12] Ruofei Ju, Xinrui Wang, Xin Ding, Yifan Yang, Hao Wu, Shiqi Jiang, Qianxi Zhang, Hao Wen, Xiangyu Li, Weijun Wang, Kun Li, Yunxin Liu, Haipeng Dai, Wei Wang, and Ting Cao. 2026. EmbodiSkill: Skill- Aware Reflection for Self-Evolving Embodied Agents.arXiv:2605.10332. https://ar... on PithPith's reviewarXiv
- [13] Salaheddin Alzubi, Noah Provenzano, Jaydon Bingham, Weiyuan Chen, and Tu Vu. 2026. EvoSkill: Automated Skill Discovery for Multi-Agent Systems.arXiv:2603.02766, version 1. https://arxiv.org/abs/2603.02766v1 on PithPith's reviewarXiv
- [14] Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2024. V oyager: An Open-Ended Embodied Agent with Large Language Models.Transac- tions on Machine Learning Research. https://openreview.net/forum?id= Mn3Lzp1sMQ on Pith
- [15] Simon Yu, Gang Li, Weiyan Shi, and Peng Qi. 2026. PolySkill: Learning Generalizable Skills Through Polymorphic Abstraction for Continual Learning. InInternational Conference on Learning Representations. https://proceedings.iclr.cc/paper files/paper/2026/hash/ e350897ed832f9cad... on Pith
- [16] Zeyu Ren, Ling Yue, Ran Li, Yishu Wang, Shengxiang Xu, Hanmo Liu, Shaowu Pan, and Shimin Di. 2026. FlowEvo: Self-Evolving Agents through the Co-Evolution of Workflows and Executable Skills. InThird Conference on Language Modeling. https://arxiv.org/abs/2607.21596 on PithPith's reviewarXiv
- [17] Zora Zhiruo Wang, Jiayuan Mao, Daniel Fried, and Graham Neubig on Pith
- [18] Boyuan Zheng, Michael Y . Fatemi, Xiaolong Jin, Zora Zhiruo Wang, Apurva Gandhi, Yueqi Song, Yu Gu, Jayanth Srinivasa, Gaowen Liu, Graham Neubig, and Yu Su. 2025. SkillWeaver: Web Agents Can Self- Improve by Discovering and Honing Skills.arXiv:2504.07079. https: //arxiv.org/ab... on PithPith's reviewarXiv
- [19] Zora Zhiruo Wang, Apurva Gandhi, Graham Neubig, and Daniel Fried on Pith
- [20] Jie-Jing Shao, Haiyan Yin, Yueming Lyu, Xingrui Yu, Lan-Zhe Guo, Ivor Tsang, James Kwok, and Yu-Feng Li. 2026. Lifting Traces to Logic: Programmatic Skill Induction with Neuro-Symbolic Learning for Long-Horizon Agentic Tasks. InProceedings of the 43rd International Conference ... on Pith
show 23 more
- [21] Zhongxin Guo, Danrui Qi, Hanwen Gu, Peng Cheng, and Yongqiang Xiong. 2026. SKILL-DISCO: Distilling and Compiling Agent Traces into Reusable Procedural Skills.arXiv:2606.26669. https://arxiv.org/abs/ 2606.26669 on PithPith's reviewarXiv
- [22] Inducing Programmatic Skills for Agentic Tasks. InSecond Conference on Language Modeling. https://openreview.net/forum?id= lsAY6fWsog on Pith
- [23] Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W. Cohen on Pith
- [24] Sehoon Kim, Suhong Moon, Ryan Tabrizi, Nicholas Lee, Michael W. Mahoney, Kurt Keutzer, and Amir Gholami. 2024. An LLM Compiler for Parallel Function Calling. InProceedings of the 41st International Conference on Machine Learning, PMLR 235, 24370–24391. https: //proceedings.mlr... on Pith
- [25] Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. 2023. PAL: Program-aided Language Models. InProceedings of the 40th International Conference on Machine Learning. https://arxiv.org/abs/2211.10435 on PithPith's reviewarXiv
- [26] Chenxi Wang, Zhuoyun Yu, Xin Xie, Wuguannan Yao, Runnan Fang, Shuofei Qiao, Kexin Cao, Guozhou Zheng, Xiang Qi, Peng Zhang, and Shumin Deng. 2026. SkillX: Automatically Constructing Skill Knowledge Bases for Agents.arXiv:2604.04804. https://arxiv.org/abs/2604.04804 on PithPith's reviewarXiv
- [27] Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. 2023. Code as Policies: Language Model Programs for Embodied Control. InIEEE International Conference on Robotics and Automation. https://arxiv.org/abs/2209.07753 on PithPith's reviewarXiv
- [28] Matthew Dunn, Levent Sagun, Mike Higgins, V . Ugur Guney, V olkan Cirik, and Kyunghyun Cho. 2017. SearchQA: A New Q&A Dataset Augmented with Context from a Search Engine.arXiv:1704.05179. https: //arxiv.org/abs/1704.05179 9 on PithPith's reviewarXiv
- [29] Omar Khattab, Arnav Singhvi, Paridhi Maheshwari, Zhiyuan Zhang, Keshav Santhanam, Sri Vardhamanan A, Saiful Haq, Ashutosh Sharma, Thomas Joshi, Hanna Moazam, Heather Miller, Matei Zaharia, and Christopher Potts. 2024. DSPy: Compiling Declarative Language Model Calls into State... on Pith
- [30] Minesh Mathew, Dimosthenis Karatzas, and C. V . Jawahar. 2021. DocVQA: A Dataset for VQA on Document Images. InIEEE Winter Conference on Applications of Computer Vision, 2200–2209. https: //arxiv.org/abs/2007.00398 on PithPith's reviewarXiv
- [31] Linyang He, Qiyao Yu, Hanze Dong, Baohao Liao, Xinxing Xu, Micah Goldblum, Jiang Bian, and Nima Mesgarani. 2026. LiveMathematician- Bench: A Live Benchmark for Mathematician-Level Reasoning with Proof Sketches.arXiv:2604.01754, version 1. https://arxiv.org/abs/2604. 01754v1 on PithPith's reviewarXiv
- [32] Mohit Shridhar, Xingdi Yuan, Marc-Alexandre Cˆot´e, Yonatan Bisk, Adam Trischler, and Matthew Hausknecht. 2021. ALFWorld: Aligning Text and Embodied Environments for Interactive Learning. InInternational Conference on Learning Representations. https://arxiv.org/abs/2010.03768 on PithPith's reviewarXiv
- [33] Databricks AI Research Team. 2025. Introducing OfficeQA: A Benchmark for End-to-End Grounded Reasoning.Databricks Research, December 9, 2025. https://www.databricks.com/blog/ introducing-officeqa-benchmark-end-to-end-grounded-reasoning on Pith
- [34] Cheng Qian, Chi Han, Yi Fung, Yujia Qin, Zhiyuan Liu, and Heng Ji. 2023. CREATOR: Tool Creation for Disentangling Abstract and Concrete Reasoning of Large Language Models. InFindings of the Association for Computational Linguistics: EMNLP 2023, 6922–6939. https://doi.org/10.18... on Pithdoi:10.18653/v1/2023.findings-emnlp.462
- [35] Tianle Cai, Xuezhi Wang, Tengyu Ma, Xinyun Chen, and Denny Zhou. 2024. Large Language Models as Tool Makers. InInternational Conference on Learning Representations. https://arxiv.org/abs/2305.17126 on PithPith's reviewarXiv
- [36] Gabriel Grand, Lio Wong, Maddy Bowers, Theo X. Olaus- son, Muxin Liu, Joshua B. Tenenbaum, and Jacob Andreas on Pith
- [37] Timo Schick, Jane Dwivedi-Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language Models Can Teach Themselves to Use Tools. InAdvances in Neural Information Process- ing Systems, V ol. 36... on Pith
- [38] Siyuan Guo, Cheng Deng, Ying Wen, Hechang Chen, Yi Chang, and Jun Wang. 2024. DS-Agent: Automated Data Science by Empowering Large Language Models with Case-Based Reasoning. InProceedings of the 41st International Conference on Machine Learning, PMLR 235, 16813–16848. https://... on Pith
- [42] Haiming Wang, Huajian Xin, Chuanyang Zheng, Zhengying Liu, Qingx- ing Cao, Yinya Huang, Jing Xiong, Han Shi, Enze Xie, Jian Yin, Zhenguo Li, and Xiaodan Liang. 2024. LEGO-Prover: Neural Theorem Proving with Growing Libraries. InInternational Conference on Learning Representati... on Pith
- [2023] Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks.Transactions on Machine Learning Research. https://arxiv.org/abs/2211.12588 on PithPith's reviewarXiv
- [2024] LILO: Learning Interpretable Libraries by Compressing and Documenting Code. InInternational Conference on Learning Representations. https://proceedings.iclr.cc/paper files/paper/2024/hash/ 819cebb05f993840e8a52d7564c5c282-Abstract-Conference.html on Pith
- [2025] Agent Workflow Memory. InProceedings of the 42nd International Conference on Machine Learning, PMLR 267, 63897–63911. https: //proceedings.mlr.press/v267/wang25bx.html on Pith
- [2026] Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills.arXiv:2603.25158. https://arxiv.org/abs/2603.25158 on PithPith's reviewarXiv
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment