Pith. sign in

REVIEW 5 major objections 4 minor 10 cited by

Programmatic skill networks claim faster, more stable continual learning than flat skill libraries: skills are executable programs in a graph, repaired via trace-based credit assignment and reorganized by rollback-validated refactoring.

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

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

An evolving network of executable skills, repaired by LLM-based 'symbolic backpropagation' and gated by maturity, beats flat skill libraries on Minecraft and Crafter.

T0 review reviewed 2026-08-03 challenge →

load-bearing objection A coherent and genuinely novel framework for programmatic skill networks, but the central 'architecture not LLM' claim is untested—send it to review, not to press. the 5 major comments →

arxiv 2601.03509 v2 pith:AEX5AB3A submitted 2026-01-07 cs.AI cs.NE

Evolving Programmatic Skill Networks

Haochen Shi , Xingdi Yuan , Bang Liu This is my paper
classification cs.AI cs.NE
keywords continual skill acquisitionprogrammatic skillscredit assignmentstructural refactoringmaturity-aware gatingembodied agentsopen-ended environmentsLLM agents
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.

The reading

The paper introduces the Programmatic Skill Network (PSN), where each skill is an executable symbolic program with preconditions and effects, and skills invoke one another, forming a directed graph. PSN's claim is that continual skill acquisition is driven by its scaffolding: fault localization over execution traces (REFLECT), maturity-aware gating that stabilizes reliable skills while keeping uncertain ones plastic, and canonical structural refactoring with rollback validation that keeps the network compact. The authors argue these mechanisms explain why PSN progresses faster through a Minecraft tech tree, earns higher cumulative reward in Crafter, retains mastered skills better, and maintains a smaller skill library than flat skill-library baselines. They also observe that these mechanisms mirror neural-network training—backpropagation, learning-rate scheduling, and architecture search—suggesting general principles for continual learning in symbolic systems. The paper itself flags batch-size-one online learning and the absence of formal convergence or projection guarantees as limitations.

Core claim

On the paper's own terms, the discovery is that an embodied agent can continually improve not by relying on an LLM's memory or planning alone, but by storing skills as executable programs in a network and treating failures as signals for structured credit assignment. Given a failure trace, REFLECT decomposes responsibility along invocation links and produces localized repair proposals that are applied bottom-up as code patches; on success, a refactor module applies a fixed set of canonical rewrites—merging duplicates, extracting common subskills, and synthesizing missing abstractions—validated by rollback if performance drops. The reported evidence is that PSN unlocks diamond-tier tools in a

What carries the argument

The central object is the Programmatic Skill Network: a directed graph whose nodes are executable skills (code with control flow, parameters, preconditions, and postconditions) and whose edges are invocation links. Three mechanisms carry the argument: REFLECT, a trace-based fault-localization operator that propagates failure signals top-down along the execution trace and emits symbolic 'gradients' applied bottom-up as code patches; a maturity-aware update gate that lowers update probability as a skill's empirical success rate rises, with a soft pivot at 0.6 and a minimum update probability of 0.1; and an online refactor module that applies five canonical rewrites—parametric coverage, behavio

Load-bearing premise

The claim that PSN's architecture, not the LLM backend, produces the learning gains rests on the untested premise that the REFLECT, CODEGEN, and PATCH operators behave stably across models; all experiments use a single LLM, so if code-generation or repair quality is the real driver, the framework's generality would fail.

What would settle it

Run PSN on the same two environments with two different LLM backends, or with a deliberately degraded repair operator, while keeping all scaffolding fixed; if tech-tree progression, Crafter reward, or retention differences shrink or reverse, the architecture-over-LLM claim is falsified. A minimal test is to disable REFLECT for a held-out set of new tasks and compare success rates against the full PSN on identical task streams.

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

If this is right

  • Persistent executable skills with pre/postconditions enable compositional generalization: unseen tasks can be solved by backward-chaining existing skills rather than synthesizing new ones from scratch.
  • Trace-based credit assignment is load-bearing for long-horizon tasks: ablating the optimizer reduces PSN to roughly flat-library performance on early and mid-tier tools and prevents reliable diamond or obsidian progression.
  • Maturity gating prevents oscillatory behavior: without it, converged skills are repeatedly modified by downstream failures, lowering cumulative task success.
  • Online refactoring outperforms offline compression: refactoring a static skill library with a strong LLM yields lower task success (0.6875) than PSN's online rollback-validated refactoring (0.8462).
  • PSN's dynamics resemble neural-network training—credit assignment as backpropagation, maturity gating as learning-rate scheduling, refactoring as architecture search—which suggests stability-plasticity tradeoffs are general principles for symbolic learning systems.

Where Pith is reading between the lines

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

  • If the architecture-over-LLM claim is right, the same scaffolding should transfer to cheaper or weaker code-generation backends; a direct test is to vary the LLM while holding all PSN mechanisms fixed and measure whether the gains persist.
  • The five canonical refactor cases are pre-enumerated; a natural extension is to have the system discover new rewrite patterns from execution traces instead of relying on a fixed casebook.
  • The trace-based credit assignment is effectively a discrete analogue of backpropagation; this primitive could be reused in neuro-symbolic systems where differentiable modules sit below programmable controllers.
  • The paper's batch-size-one setup and lack of a projection guarantee invite stress tests: running parallel task streams or adversarial task orderings would reveal whether the maturity gate and rollback validation remain stable under higher throughput.
Share X Bluesky LinkedIn Reddit HN

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

5 major / 4 minor

Summary. The paper introduces Programmatic Skill Networks (PSN), a framework for continual skill acquisition in embodied environments where skills are represented as executable symbolic programs organized in a directed invocation graph. Three mechanisms are proposed: REFLECT for trace-based credit assignment across skill compositions, maturity-aware update gating (Eq. 6) that gradually stabilizes reliable skills, and online canonical refactoring with rollback validation. The authors also present an interpretive analogy to neural-network training, where credit assignment is likened to backpropagation, gating to learning-rate scheduling/freezing, and refactoring to architecture search. Experiments on MineDojo and Crafter report faster tech-tree progression, better skill retention, and more compact skill libraries than flat skill-library baselines such as Voyager.

Significance. If the empirical claims are supported, PSN would be a meaningful step toward structured, inspectable continual skill acquisition in open-ended embodied agents. The conceptual contributions—trace-based symbolic credit assignment over executable programs, maturity-gated updates, and rollback-validated refactoring—are well-motivated and could be useful beyond the specific LLM implementation. The paper is also transparent in its Limitations section about batch-size-one training and the absence of formal convergence guarantees. However, the current evidence does not establish the paper's central attribution that the architectural scaffolding, rather than the LLM backend, drives the observed gains. The lack of released code/data, small number of runs, and reliance on inherited baseline numbers also limit the strength of the empirical conclusions.

major comments (5)
  1. [§2 (LLM implementation), §4.1] The central claim that PSN's learning dynamics 'emerge from the architectural choices of PSN rather than from the internal mechanisms of the LLM' is not experimentally isolated. All operators (CODEGEN, REFLECT, PATCH) use gpt-5-mini-2025-08-07 in every experiment; no run varies the backend. The ablation 'PSN w/o Optimizer' removes the optimizer, REFLECT, and gating, but it does not control for the presence or format of LLM-generated repair prompts. A flat skill library that receives the same execution traces and the same REFLECT/PATCH prompts could plausibly reproduce much of the gain. To support the attribution, the authors should either vary the backbone (e.g., a different LLM) or compare against a flat-library baseline that feeds identical trace and repair information to the LLM.
  2. [Table 1, §4.2] The headline result—faster tech-tree progression—is under-supported. The ReAct, Reflexion, and AutoGPT numbers are inherited from the Voyager paper, likely with different LLMs and harnesses; the comparison is not apples-to-apples. Only three runs are reported per method, and the obsidian result comes from a single successful run (1/3). While PSN's diamond result (51±9, 3/3) is better than Voyager's (102, 1/3), the variance and run count are too small to establish a robust difference, especially for the later stages. More runs and a fully matched baseline suite are needed.
  3. [Figures 3–6, §4.3–4.4] The claimed benefits in cumulative reward, retention rate, and skill-library compactness are presented without error bars or confidence intervals. Figure 3, Figure 4, and Figure 6 appear to show single trajectories, so the reader cannot assess run-to-run variability. Since the paper's key qualitative conclusions (reduced forgetting, compact repertoire, higher reward) rest on these curves, the authors should report multiple seeds with interval estimates or at least overlay individual run curves.
  4. [§4.4 (Offline Refactor vs. Online Refactor)] The offline-refactor comparison does not isolate the claimed benefit of online refactoring. Voyager-R is produced by Claude Opus 4.5, a different LLM from the gpt-5-mini used in PSN, and is evaluated on a single fixed task sequence with no error bars. Moreover, the reported refactor turns 58 skills into 65 skills (7 generic + 20 wrappers + 38 unchanged), so the comparison is not a clean test of 'compactness' or of online vs. offline structural change. The 0.6875 vs. 0.8462 difference is suggestive but not statistically grounded.
  5. [Eq. (6), §2.4] Maturity-aware update gating is a core mechanism, yet the hand-set constants in Eq. (6) (pivot 0.6, γ=5, ϵ=0.1), the rolling repair buffer of 5, and the 20% rollback threshold are used without sensitivity analysis. The paper's qualitative conclusions about stabilization and plasticity would be more robust if the authors reported how performance changes when these hyperparameters are varied. At a minimum, some motivation or a small sensitivity study is needed, because these choices directly affect the claimed stability-plasticity tradeoff.
minor comments (4)
  1. [Throughout] Typographical and naming inconsistencies: the paper alternates between 'Voyager' and 'Voyager' in text and table captions (e.g., Table 1 uses 'Voyager*' but the abstract uses 'MineDojo' with inconsistent hyphenation). Please standardize.
  2. [§4.1] The description of the Crafter environment as 'a Mineflayer-like Python API system' is vague; without code or a precise API specification, the reader cannot assess whether the implementation faithfully simulates the target environment.
  3. [Appendix D] The prompt templates are useful, but the relation between the 'hybrid REFLECT' rule-based component and pure LLM-based reflection is unclear. Please describe the rule set or provide a reference.
  4. [Limitations] The Limitations section honestly acknowledges batch-size-one optimization and the lack of formal projection guarantees. These are appropriate caveats, but they further argue for more extensive empirical validation rather than weaker wording.

Circularity Check

0 steps flagged

No load-bearing circularity: PSN's empirical claims rest on new experiments, not on fitted inputs or self-cited theorems.

full rationale

The paper makes no mathematical derivation that reduces to its inputs. P(updates) and refactor thresholds are hand-set hyperparameters (Eq. 6: 0.6, gamma=5, eps=0.1; 20% rollback), not fit to benchmark outcomes. The 'optimization perspective' in Section 3 is explicitly a partial analogy ('Scope of the analogy. The neural network analogy is partial'), not a claim that PSN is derived from backpropagation. The central attribution that PSN's architectural scaffolding, rather than the LLM backend, drives learning is asserted in Section 2 ('the learning dynamics we observe ... emerge from the architectural choices of PSN ... rather than from the internal mechanisms of the LLM'), but all experiments use gpt-5-mini-2025-08-07; this is an untested empirical generalization, not a circular step. Existing self-citations (Sun et al. 2024; Wang et al. 2025a; Fu et al. 2024) appear only in related-work contrast and do not carry the load-bearing argument. The paper's own Limitations section acknowledges the absence of 'a formal projection guarantee' and convergence theory, which further indicates the results are empirical rather than definitional. Baseline numbers from Voyager are external and clearly marked. No fitted parameter is renamed as a prediction; no uniqueness theorem is imported from the authors' prior work. Hence no circularity step can be exhibited under the required quote-and-reduction standard.

Axiom & Free-Parameter Ledger

7 free parameters · 6 axioms · 0 invented entities

No new physical or ontological entities are introduced. 'Symbolic gradients' and skill values are internal bookkeeping, not independently evidenced postulates; the potential entity-like concepts have no extramural falsifiable handle beyond the reported benchmarks. The framework does rest on several hand-set constants and domain assumptions listed above.

free parameters (7)
  • Maturity pivot V0 = 0.6
    Eq. (6): inflection point separating reliable from uncertain skills; hand-chosen, no sensitivity analysis.
  • Sigmoid sharpness gamma = 5.0
    Eq. (6): controls how abruptly update probability drops with V(s); set by hand.
  • Minimum update probability epsilon = 0.1
    Eq. (6): ensures occasional updates of mature skills; hand-set.
  • Rolling repair buffer size = 5
    Section 2.4: last 5 repair proposals constrain contradictory edits.
  • Refactor rollback window = 3 tasks
    Section 2.5: validates refactor on sliding window of 3 recent tasks.
  • Success-drop rollback threshold = 20%
    Section 2.5: revert refactor if success rate drops by more than 20%.
  • Refactor candidate top-k = 5
    Section 2.5: top-5 semantically related skills by embedding similarity; chosen by hand.
axioms (6)
  • domain assumption Skills are faithfully representable as programs with control flow, parameters, and pre/postconditions in the chosen environments.
    Section 2.1 defines skills as symbolic programs; the whole framework depends on this representation being adequate for Minecraft/Crafter.
  • domain assumption LLM operators (REFLECT, CODEGEN, PATCH) produce sufficiently correct code/repairs that learning dynamics reflect architecture, not LLM stochasticity.
    Section 2, 'LLM implementation', asserts this separation but no LLM-backend ablation is provided.
  • domain assumption Backward-chaining over postconditions plus LLM forward planning covers all reachable goals.
    Section 2.2, Eq. (2), assumes S(g) can be computed and that unmet subgoals can always be resolved by the LLM planner.
  • ad hoc to paper Refactor candidate set (graph neighbors + top-5 embeddings) contains all redundancy relationships; rewrites are semantics-preserving enough for rollback validation.
    Section 2.5 restricts refactoring to a hand-picked candidate set and five canonical cases; no completeness or safety certificate is given.
  • ad hoc to paper Rollback validation on 3 recent tasks with a 20% threshold is a sufficient safety proxy to prevent harmful refactors.
    Section 2.5 defines the validation rule; no analysis shows this window/threshold catches semantic regressions.
  • domain assumption MineDojo/Crafter simulator feedback faithfully reflects goal satisfaction.
    Section 2.3 treats delta_t as ground-truth task success; the claim relies on simulator correctness.

reviewed 2026-08-03 · how reviews work

0 comments
Cite this review

Pith. "Pith review of Evolving Programmatic Skill Networks." pith.science (2026). https://pith.science/paper/AEX5AB3A

@misc{pith2026260103509,
  author       = {Pith},
  title        = {Pith review of: Evolving Programmatic Skill Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AEX5AB3A}},
  note         = {Machine review of arXiv:2601.03509}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

We study continual skill acquisition in open-ended embodied environments where an agent must construct, refine, and reuse an expanding library of executable skills. We introduce the Programmatic Skill Network (PSN), a framework in which skills are executable symbolic programs forming a compositional network that evolves through experience. PSN defines three core mechanisms instantiated via large language models: (1)~\opreflect for structured fault localization over skill compositions, (2)~progressive optimization with maturity-aware update gating that stabilizes reliable skills while maintaining plasticity for uncertain ones, and (3)~canonical structural refactoring under rollback validation that maintains network compactness. We further show that PSN's learning dynamics exhibit structural parallels to neural network training. Experiments on MineDojo and Crafter demonstrate robust skill reuse, rapid adaptation, and strong generalization across open-ended task distributions.

Figures

Figures reproduced from arXiv: 2601.03509 by Bang Liu, Haochen Shi, Xingdi Yuan.

Figure 1
Figure 1. Figure 1: The Programmatic Skill Network (PSN) framework. The agent maintains a skill network [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Tech tree mastery on Minecraft. compositional credit assignment, and architecture search emerge as general principles when learn￾ing structured representations. This suggests that insights from neural network optimization may in￾form symbolic learning systems, and vice versa. 4 Experiments and Analysis We evaluate Programmatic Skill Networks (PSN) on two complementary embodied benchmarks: MineDojo (Fan et … view at source ↗
Figure 3
Figure 3. Figure 3: Cumulative Reward on Crafter. Shorter curves [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 5
Figure 5. Figure 5: The cumulative success rate of tasks for PSN [PITH_FULL_IMAGE:figures/full_fig_p007_5.png] view at source ↗
Figure 7
Figure 7. Figure 7: Parametric coverage. A specialized skill is rewritten as a wrapper around a more general, parameterized [PITH_FULL_IMAGE:figures/full_fig_p014_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Behavioral (subgraph) coverage. Duplicated logic inside a composite skill is replaced by a call to an [PITH_FULL_IMAGE:figures/full_fig_p015_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Sibling specializations. Multiple specialized skills expose a missing higher-level abstraction that can be [PITH_FULL_IMAGE:figures/full_fig_p016_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Common subskill extraction. Repeated sub-operations across different skills are factored into a shared [PITH_FULL_IMAGE:figures/full_fig_p017_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Duplication removal. Functionally equivalent skills are merged into a single canonical representation. [PITH_FULL_IMAGE:figures/full_fig_p017_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Example prompt template instantiating the R [PITH_FULL_IMAGE:figures/full_fig_p019_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: Example prompt template instantiating the skill optimization operator ( 20 [PITH_FULL_IMAGE:figures/full_fig_p020_13.png] view at source ↗

discussion (0)

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

Forward citations

Cited by 10 Pith papers

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

  1. Test-Time Learning with an Evolving Library

    cs.LG 2026-05 unverdicted novelty 7.0

    EvoLib enables LLMs to accumulate, reuse, and evolve knowledge abstractions from inference trajectories at test time, yielding substantial gains on math reasoning, code generation, and agentic benchmarks without param...

  2. EasyBCI Agent: Towards Universal Neural Data Preprocessing for Brain-Computer Interfaces

    q-bio.QM 2026-07 conditional novelty 6.0

    An LLM agent with a text-only data fingerprint, quality-gated skill reuse, and expert checkpoints outperforms manual and general-purpose coding pipelines for EEG preprocessing and produces QC-passing pipelines for fiv...

  3. EasyBCI Agent: Towards Universal Neural Data Preprocessing for Brain-Computer Interfaces

    q-bio.QM 2026-07 conditional novelty 6.0

    Domain-specific LLM orchestration preserves more task-relevant EEG signal than a manual pipeline or general-purpose coding agents on one small private dataset, and extends to five other modalities.

  4. Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries

    cs.AI 2026-07 conditional novelty 6.0

    Dynamic agent skill libraries are lifecycle-managed evolving stores whose admission, verification, maintenance, and retrieval choices determine whether reuse helps or hurts.

  5. VideoWeaver: Evaluating and Evolving Skills for Agentic Long Video Generation

    cs.CV 2026-06 unverdicted novelty 6.0

    Introduces VideoWeaver benchmark (16 categories, 285 cases) plus agent-as-judge and skill-evolution algorithm to assess and improve agentic long video generation across frameworks.

  6. Mem-$\pi$: Adaptive Memory through Learning When and What to Generate

    cs.CL 2026-05 unverdicted novelty 6.0

    Mem-π is a framework using a dedicated model and decision-content decoupled RL to generate context-specific guidance on demand for LLM agents, outperforming retrieval baselines by over 30% on web navigation.

  7. Test-Time Learning with an Evolving Library

    cs.LG 2026-05 conditional novelty 6.0

    EvoLib improves black-box LLM test-time performance by maintaining an evolving, self-scored library of reusable skills and insights, without parameter updates or ground-truth feedback.

  8. A Comprehensive Survey on Agent Skills: Taxonomy, Techniques, and Applications

    cs.IR 2026-05 unverdicted novelty 5.0

    A survey that taxonomizes agent skills for LLM-based agents across representation, acquisition, retrieval, and evolution stages while reviewing methods, resources, and open challenges.

  9. A Comprehensive Survey on Agent Skills: Taxonomy, Techniques, and Applications

    cs.IR 2026-05 unverdicted novelty 4.0

    The paper surveys agent skills for LLM agents, organizing the literature into a four-stage lifecycle of representation, acquisition, retrieval, and evolution while highlighting their role in system scalability.

  10. A Comprehensive Survey on Agent Skills: Taxonomy, Techniques, and Applications

    cs.IR 2026-05 unverdicted novelty 3.0

    A survey that defines agent skills as reusable procedural artifacts and reviews methods, resources, and applications across their representation, acquisition, retrieval, and evolution stages.

Reference graph

Works this paper leans on

16 extracted references · 2 linked inside Pith · cited by 6 Pith papers

  1. [111]

    Fix ALL issues mentioned in LAYER 1 - these are mandatory

  2. [122]

    Focus your changes on the areas mentioned in LAYER 2

  3. [133]

    Follow ALL constraints in LAYER 3

  4. [144]

    Return COMPLETE code with all brackets matched - do NOT truncate

  5. [155]

    Keep the function signature unchanged

  6. [166]

    Do NOT add new functions with same names as external skills

  7. [177]

    AUTOMATION ONLY - We only support fully automated skills: 18- Use Mineflayer APIs (bot.craft, bot.dig, bot.placeBlock, bot.equip, etc.) 19- Do NOT require user interaction (windowOpen events, "press E", manual operations) 20- Do NOT convert automated code to interactive/manual flows 21- All operations must be programmatic and automatic

  8. [221]

    Identify the root cause of the failure

  9. [228]

    Do NOT add unnecessary helper functions

    CODE CONCISENESS: Keep code concise. Do NOT add unnecessary helper functions. 23- Only keep helper functions that are ACTUALLY USED 24- Remove redundant code. If optimized code is longer than original, review and simplify

  10. [232]

    Determine if the issue is in THIS skill or in a child skill

  11. [243]

    Expand maxDistance from 6 to 16, expand vertical search from [-1,1] to [-2,2]

    For each identified issue, specify: 25- The type of gradient (logic, parameter_semantic, physical_constraint, error_handling, etc.) 26- The magnitude (0.0 to 1.0, higher = more urgent) 27- The direction (what needs to change) 28- The suggested_fix (REQUIRED: concrete code modification suggestions) 29 30**IMPORTANT:** For physical_constraint issues (placem...

  12. [259]

    issues": [ 43{

    DO NOT REDEFINE SYSTEM CONTROL PRIMITIVES: The following functions are PROVIDED BY THE SYSTEM. 26DO NOT create local functions with these exact names - they already exist externally: 27 28mineBlock, craftItem, smeltItem, exploreUntil, placeItem, 29killMob, useChest, givePlacedItemBack, shoot, waitForMobRemoved 30 31CONTROL PRIMITIVE API SIGNATURES (CRITIC...

  13. [1999]

    obtain diamond

    Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112(1–2):181–211. Mingxing Tan and Quoc V . Le. 2019. Efficientnet: Re- thinking model scaling for convolutional neural net- works. InProceedings of the International Confer- ence on Machine Learning (ICML). Guanzhi Wang, Yuqi Xie, Yunfan J...

    arXiv 2019

  14. [2016]

    Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom

    Progressive neural networks.arXiv preprint arXiv:1606.04671. Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. InAdvances in Neural Information Processing Sys- tems (NeurIPS). Noam Shazeer, Azalia Mirhosein...

    Pith/arXiv arXiv 2023

  15. [2022]

    InAdvances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track

    Minedojo: Building open-ended embodied agents with internet-scale knowledge. InAdvances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track. Outstanding Paper Award. Haotian Fu, Pratyusha Sharma, Elias Stengel-Eskin, George Konidaris, Nicolas Le Roux, Marc-Alexandre Côté, and Xingdi Yuan. 2024. Language-guided skill learning ...

    Pith/arXiv arXiv 2024

  16. [2024]

    InProceedings of the 41st International Conference on Machine Learning, volume 235 ofProceedings of Machine Learning Research, pages 46605–46624

    ReGAL: Refactoring programs to discover generalizable abstractions. InProceedings of the 41st International Conference on Machine Learning, volume 235 ofProceedings of Machine Learning Research, pages 46605–46624. PMLR. ICML 2024. Zhiyuan Sun, Haochen Shi, Marc-Alexandre Côté, Glen Berseth, Xingdi Yuan, and Bang Liu. 2024. Enhanc- ing agent learning throu...

    2024

This paper was first reviewed by deepseek-v4-flash on August 3, 2026.