Pith. sign in

REVIEW 4 major objections 6 minor 55 references

Enabling Autonomic Microservice Management through Self-Learning Agents

T0 review · 4 major / 6 minor · reviewed 2026-08-09 · deepseek-v4-flash

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

Pith's one-line read ServiceOdyssey proposes a self-learning agent system that manages microservices from scratch, building operational knowledge through curriculum-guided exploration and feedback.

desk verdict A clean architecture for LLM agents that learn operational skills via exploration, but the evaluation is too thin and the curriculum too hand-authored to support the 'autonomous' claims. read the letter →

arxiv 2501.19056 v1 pith:WBGSHBKT submitted 2025-01-31 cs.SE cs.AIcs.CLcs.MA

Fenglin Yu , Fangkai Yang , Xiaoting Qin , Zhiyang Zhang , Jue Zhang , Qingwei Lin , Hongyu Zhang , Yingnong Dang
show 3 more authors
Saravan Rajmohan Dongmei Zhang Qi Zhang
This is my paper · ORCID
classification cs.SEcs.AIcs.CLcs.MA
keywords microservicemanagementself-learningagentslargelanguagemodelscurriculumlearningskilllibraryautonomiccomputingKubernetesPrometheus
verification ladder T0 review T1 audit T2 compute T3 formal

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 proposes ServiceOdyssey, an LLM-based agent system for autonomic microservice management that starts with no service-specific configuration knowledge and acquires it by interacting with the live system. It claims that curriculum-ordered exploration tasks, followed by solution refinement through environment, peer, and hierarchical feedback, let the agent build a reusable skill library. On a Sock Shop prototype, the authors report that task success improves as knowledge accumulates, with each self-learning trial costing under $10 and finishing in under 30 minutes. The motivation is to reduce dependence on human-provided setup details and static documentation for operating complex software.

What carries the argument

The load-bearing object is the self-learning loop formed by three LLM modules: the Curriculum Builder generates easy-to-hard, observation-to-action tasks; the Execution Planner, a high-level manager plus low-level component agents, refines solutions using environment feedback, peer feedback, and hierarchical feedback; and the Knowledge Curator validates and stores successful command, reflection, and configuration skills in a skill library for later use. The loop turns the managed microservice into an agentic microservice system whose components expose natural-language management interfaces.

What would settle it

A single controlled replication would settle it: run ServiceOdyssey on a second microservice with no service-specific prompt knowledge, track success on held-out operational tasks after each curriculum round, and check whether the improvement curve tracks the validated skill count; if success is flat or high from the first round, the self-learning loop is not carrying the result.

Watch

Extended reading notes

Core claim

The central claim is that a microservice management agent can bootstrap its own operational competence: instead of being fed service-specific configurations, the agent generates exploration tasks that move from observation to action, executes them through a hierarchy of LLM-based agents, and distills successful traces into typed skills that are validated before reuse. The paper shows this loop working on the Sock Shop demo, where the accumulated skill library correlates with success on held-out operational tasks, with the sharpest gains in early rounds. The system is presented as a step toward autonomic computing, where the human engineer is relieved of repetitive service-specific learning.

Load-bearing premise

Every component of the target microservice must already expose an LLM-friendly management interface, effectively an agentic wrapper, plus the usual monitoring and control APIs; if a service lacks that, ServiceOdyssey has nothing to learn through.

Editorial extensions

If this is right

  • Operators could deploy a management agent into an unfamiliar microservice without writing service-specific prompts, as long as the service has agentic wrappers and standard observability and control APIs.
  • Each validated skill becomes reusable, so later tasks are solved with less trial and error.
  • In canary environments the full action loop can run safely; without a sandbox, the system can restrict itself to observation tasks and still learn component structure and properties.
  • If the correlation between skill-library growth and task success holds across services, the cost of onboarding a new microservice for automated management could drop to tens of minutes and single-digit dollars per learning trial.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper does not test whether the skill library transfers across different microservices; a natural extension is to check whether Command, Reflection, and Configuration skills learned on one service speed up learning on a second service with a different stack.
  • The authors note that manual diagnosis and mitigation logs, when available, can be converted into skills, which suggests a hybrid path where legacy incident records bootstrap the curriculum before live exploration begins.
  • Because the approach requires an agentic wrapper around every component, the value of self-learning likely shrinks as the wrapper cost grows; comparing wrapped versus API-only services would clarify where the approach pays off.
  • Figure 4 reports one trial in detail, while the three trials already show different knowledge-acquisition trajectories, so success rates across all trials would sharpen the performance claim.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper proposes ServiceOdyssey, a self-learning agent system for autonomic microservice management. The system combines three LLM-based modules: a Curriculum Builder that generates a progression of exploration tasks, an Execution Planner that translates tasks into executable actions in an agentic microservice environment, and a Knowledge Curator that extracts and validates reusable skills (Command, Reflection, and Configuration). The authors claim that ServiceOdyssey can manage microservices without prior knowledge of service-specific configurations, progressively building understanding through curriculum-learning-guided exploration. A prototype on the Sock Shop microservice is reported, with three self-learning trials, a knowledge-curation visualization, and a performance evaluation for Trial 1 showing improved success rates on six operational tasks after successive exploration rounds. The paper also reports per-trial cost under $10 and completion time under 30 minutes.

Significance. If the central claim were established, ServiceOdyssey would represent a useful step toward reducing human effort in microservice management. The proposed architecture is coherent, the three-schema skill library (Command, Reflection, Configuration) is a sensible design choice for capturing environment-specific operational knowledge, and the explicit reporting of LLM API cost and wall-clock time is a practical strength. The appendix includes full prompts, which aids reproducibility of the prompt design. However, the empirical support is preliminary: the performance result is based on a single trial, lacks a control condition or ablation, and the evaluation is anchored to the authors' own prior framework, so the load-bearing claim that self-learning, rather than the hand-authored curriculum prompt or the underlying [50] system, produces the observed gains is not yet established.

major comments (4)
  1. [Section 3, Figure 4] The central empirical claim—'a clear correlation between accumulated service knowledge and task performance'—rests entirely on the single-trial results in Figure 4, yet the figure's x/y cell values are not reported in the text. The reader cannot verify the success counts, the number of repetitions per task (stated as three in Section 3), or the variance across repetitions. Without the actual counts and error bars, or a table of the per-round and per-task numbers, the claim is not quantitatively supported. Please report the full trial-by-trial and repetition-by-repetition results, and ideally aggregate across all three trials, not just Trial 1.
  2. [Section 3, Figure 4 vs. Appendix A.1] No control condition isolates the self-learning loop. The improvement across rounds could be caused by the increasingly detailed, human-authored curriculum prompt rather than by the knowledge accumulated by the Knowledge Curator. The prompt in Table 1 contains explicit, prescriptive instructions such as 'Check the basic resource usage of the component... obtainable with built-in kubectl commands' and 'If Prometheus is used in the component, try to get familiar with its basic usage.' To support the abstract's claim that the system 'autonomously manages microservices without requiring prior knowledge of service-specific configurations,' the evaluation needs a zero-shot baseline (an agent that receives the same evaluation tasks but no exploration rounds) and an ablation that disables the Knowledge Curator. Without these conditions, the observed improvement does not demonstrate that self-learning is the cause.
  3. [Section 2.2] The approach assumes that the managed microservice can be transformed into an 'agentic microservice system' in which each component is wrapped as an LLM-enhanced agent with natural-language management interfaces (built on [50]). This is a strong deployment assumption: most production microservices do not have such wrappers, and without them the self-learning loop cannot start because the Execution Planner depends on the high-level manager and low-level agents for task decomposition and feedback. Section 2.4 concedes that in settings without a sandbox the system 'restricts itself to safer observation tasks,' but the evaluation only covers the fully wrapped Sock Shop setting. Please clarify the scope of the claimed autonomy and discuss how the approach would be applied to microservices that do not already expose LLM-agent interfaces.
  4. [Section 3] The evaluation is anchored to the authors' own prior framework: the prototype 'builds on the codebase of [50]' and the operational tasks are 'outlined in [50].' The paper states that Sock Shop-specific instructions were removed from prompts, but the Curriculum Builder prompt still embeds substantial tool-specific and environment-specific guidance (e.g., kubectl, Prometheus, namespace 'sock-shop'). This makes it difficult to assess the claim that the system operates 'without requiring prior knowledge of service-specific configurations.' A more convincing test would use a microservice that was not the subject of the authors' prior work and would measure how much of the task generation prompt can be removed before performance degrades. At minimum, the authors should clarify exactly which instructions were removed and which service-specific details remain in the prompts.
minor comments (6)
  1. [Abstract / Section 5] The conclusion explicitly states 'we have yet to experiment with more complex systems and challenges such as LLM limitations persist.' This is an honest limitation, but it should be reflected in the abstract, which currently makes a broader claim of autonomic management of microservices in general.
  2. [Section 3] The text refers to knowledge points in Figure 3 using colors ('the one in orange dot'), but the figure's legend and color coding are not described in the caption. Please add a clear legend or annotate the figure directly.
  3. [Section 3, Figure 4] The caption says 'each cell's x/y indicates the number of successful trials out of the total,' but the total number of repetitions is not specified in the caption. Please state that each task was repeated three times and define 'Initial' explicitly (e.g., zero exploration rounds, no skills).
  4. [Throughout] There are several typographical errors, e.g., 'mciroservices' (Section 4), 'NuerIPS' (reference [12]), 'intellient' and 'Excuation' (Table 2), 'peddagoical' (Table 1), and 'Trail 1' instead of 'Trial 1' (Appendix A.1).
  5. [Section 4] The related work section groups gaming, web automation, computer control, smartphone usage, social interaction, and robotics under 'self-learning agents,' but it does not compare ServiceOdyssey's curriculum-learning approach to prior self-learning systems in terms of how they handle exploration efficiency, skill validation, or safety constraints in production-like environments. A brief comparative discussion would strengthen the positioning.
  6. [Section 2.3] The validation process for skills says LLMs are used to verify whether execution results 'matches the expected output of the skill,' but the expected output is not defined. Please clarify how the expected output is obtained, since this affects the reliability of the skill library and the risk of hallucinated skills.

Circularity Check

0 steps flagged · score 2.0 of 10

Evaluation inherits tasks and wrappers from the authors' prior work [50], but the central self-learning claim is not defined into existence; the observed improvement is a measured empirical trajectory with confounding, not circularity.

full rationale

The paper contains no fitted constants, no closed-form derivation, and no equation that is defined in terms of its own output, so the core circularity patterns (self-definitional, fitted-input-called-prediction, uniqueness-imported-from-authors, ansatz-smuggled-in-via-citation) do not apply. The load-bearing evidence is the Figure 4 trajectory showing task success improving across exploration rounds in Trial 1, which is a measured execution record rather than a quantity manufactured from the inputs. The paper explicitly separates exploration tasks from evaluation tasks: 'Tasks that altered system states were chosen to ensure no overlap with those used in self-exploration,' so the evaluation is not the same task set as the curriculum by construction. The main self-citation concern is that the prototype 'build[s] on the codebase of [50]' and evaluation uses 'the operational tasks outlined in [50],' where [50] is by overlapping authors; however, this only makes the benchmark less independent, it does not force the observed improvement to equal the curriculum input. A real threat to the claim is the hand-authored curriculum prompt, which pre-encodes the order 'kubectl' then Prometheus and prescribes specific sub-steps; the observed early-round gains could therefore reflect prompt-following rather than an emergent skill library. That is a confound and an ablation gap, not a by-construction equivalence: the paper does not define 'accumulated service knowledge' as the evaluation score, and a zero-shot control or a Knowledge-Curator ablation would be needed to isolate the mechanism. No uniqueness theorem from prior work is invoked to forbid alternative explanations, and the Voyager-style exploration design is openly credited rather than renamed. Overall, the central derivation is not circular; the score of 2 reflects the minor, non-load-bearing self-citation in the evaluation setup, not a reduction of the result to its inputs.

Assumptions & free parameters 4 free parameters · 5 assumptions · 3 invented entities

The paper's central claim rests on a handful of hand-chosen experimental settings and several domain assumptions about LLM reliability, environment observability, curriculum ordering, and skill transfer. No free parameters are fitted to data in a mathematical sense; the entries list the hand-chosen settings that shape all reported results. The architecture adds software components (CB, KC, skill library) that are not externally validated.

free parameters (4)
  • Number of exploration rounds = 5
    Hand-chosen in Section 3; Figure 4 shows improvement over exactly five rounds, with no evidence that five is sufficient or generally appropriate.
  • Tasks per round = 3
    Hand-chosen in Section 3; this affects cost, time, and the learning trajectory reported in Figures 3 and 4.
  • Self-learning trials = 3
    Only three trials were run, and detailed performance is drawn from Trial 1; this sample size is hand-chosen and limits reliability.
  • Evaluation repetitions per task = 3
    Each evaluation task was repeated three times in Trial 1; no variance or confidence intervals are reported, and this repetition count is hand-chosen.
assumptions (5)
  • domain assumption LLM agents can reliably produce executable management actions and correct results from natural language task descriptions.
    Invoked in Section 2.2 (solution initialization) and throughout the prototype; if planning or execution is unreliable, the skill library is built from invalid solutions.
  • domain assumption The operational environment (kubectl, Prometheus, Sock Shop) provides sufficient observability and control for all exploration and evaluation tasks.
    The prototype and all reported results depend on these interfaces being available and stable; this is assumed in Sections 2.2 and 3.
  • domain assumption The curriculum order (easy to hard, observation to action, Prometheus after kubectl) is what drives learning, rather than simple repetition or exposure.
    Section 2.1 states this as a design principle and Figure 4 is interpreted as evidence of it, but no ablation compares curriculum order with random task order.
  • domain assumption Skills extracted from successful task executions transfer to previously unseen operational tasks of the same type.
    Section 2.3 and Figure 4 assume the skill library built from exploration tasks generalizes to evaluation tasks chosen to avoid overlap; no measurement of transfer to another service is provided.
  • domain assumption The agentic wrapper (each service component managed by an LLM agent) is a reasonable representation of real microservices.
    Section 2.2 transitions Sock Shop into agentic microservices; production systems do not come with this wrapper, and the paper does not discuss how to build it.
invented entities (3)
  • ServiceOdyssey self-learning loop (Curriculum Builder, Execution Planner, Knowledge Curator)
    purpose: Generates tasks, refines solutions, and distills reusable skills.
    Implemented as a prototype in Section 3; no released code, benchmark, or external validation. It is a software architecture, not an independently evidenced entity.
  • Skill library with Command, Reflection, and Configuration schemas
    purpose: Stores reusable microservice management knowledge.
    Illustrated with examples in Section 2.3 and a decoded list in the appendix; no artifact or dataset supports independent audit.
  • Agentic microservice system (LLM-agent wrappers per component)
    purpose: Enables natural language management and feedback between agents.
    Inherited from [50] and adapted here; no implementation is released, and the wrapper itself is a precondition rather than a measured result.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Enabling Autonomic Microservice Management through Self-Learning Agents." pith.science (2026). https://pith.science/paper/WBGSHBKT

@misc{pith2026250119056,
  author       = {Pith},
  title        = {Pith review of: Enabling Autonomic Microservice Management through Self-Learning Agents},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WBGSHBKT}},
  note         = {Machine review of arXiv:2501.19056}
}
read the original abstract

The increasing complexity of modern software systems necessitates robust autonomic self-management capabilities. While Large Language Models (LLMs) demonstrate potential in this domain, they often face challenges in adapting their general knowledge to specific service contexts. To address this limitation, we propose ServiceOdyssey, a self-learning agent system that autonomously manages microservices without requiring prior knowledge of service-specific configurations. By leveraging curriculum learning principles and iterative exploration, ServiceOdyssey progressively develops a deep understanding of operational environments, reducing dependence on human input or static documentation. A prototype built with the Sock Shop microservice demonstrates the potential of this approach for autonomic microservice management.

Figures

Figures reproduced from arXiv: 2501.19056 by the authors.

Figure 1
Figure 1. An overview of the ServiceOdyssey system. 2 Design of the ServiceOdyssey System The ServiceOdyssey system architecture, shown in [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Agentic microservice system for Sock Shop. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 4
Figure 4. Performance evaluation in Trial 1 after each [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

55 extracted references · 31 canonical work pages

  1. [50]

    The Vision of Autonomic Computing: Can LLMs Make It a Reality?

    Zhiyang Zhang, Fangkai Yang, Xiaoting Qin, Jue Zhang, Qingwei Lin, Gong Cheng, Dongmei Zhang, Saravan Rajmohan, and Qi Zhang. 2024. The Vision of Autonomic Computing: Can LLMs Make It a Reality? arXiv:arXiv:2407.14402 7 A Prompts A.1 Prompts for Our Framework The specific system prompts used for the task generation, and the memory mechanism are presented ...

    work page Pith review arXiv 2024

  2. [1]

    Toufique Ahmed, Supriyo Ghosh, Chetan Bansal, Thomas Zimmer- mann, Xuchao Zhang, and Saravan Rajmohan. 2023. Recommending Root-Cause and Mitigation Steps for Cloud Incidents using Large Lan- guage Models. In 45th IEEE/ACM International Conference on Software Engineering, ICSE 2023, Melbourne, Australia, May 14-20, 2023 . IEEE, 1737–1749. https://doi.org/1...

    work page arXiv 2023

  3. [2]

    Kaikai An, Fangkai Yang, Liqun Li, Zhixing Ren, Hao Huang, Lu Wang, Pu Zhao, Yu Kang, Hua Ding, Qingwei Lin, Saravan Rajmohan, and Qi Zhang. 2024. Nissist: An Incident Mitigation Copilot based on Troubleshooting Guides. CoRR abs/2402.17531 (2024). https://doi.org/ 10.48550/ARXIV.2402.17531 arXiv:2402.17531

    arXiv doi:10.48550/arxiv.2402.17531 2024

  4. [3]

    Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason We- ston. 2009. Curriculum learning. In Proceedings of the 26th annual international conference on machine learning . 41–48

    work page 2009

  5. [4]

    Jerome S Bruner. 1961. The act of discovery. Harvard educational review (1961)

    work page 1961

  6. [5]

    Lianping Chen. 2018. Microservices: architecting for continuous de- livery and DevOps. In 2018 IEEE International conference on software architecture (ICSA). IEEE, 39–397

    work page 2018

  7. [6]

    Yinfang Chen, Huaibing Xie, Minghua Ma, Yu Kang, Xin Gao, Liu Shi, Yunjie Cao, Xuedong Gao, Hao Fan, Ming Wen, Jun Zeng, Supriyo Ghosh, Xuchao Zhang, Chaoyun Zhang, Qingwei Lin, Saravan Ra- jmohan, Dongmei Zhang, and Tianyin Xu. 2024. Automatic Root Cause Analysis via Large Language Models for Cloud Incidents. In Proceedings of the Nineteenth European Con...

    work page arXiv 2024

  8. [7]

    Microservices Demo. [n. d.]. Sock Shop: A Microservices Demo Appli- cation. https://github.com/microservices-demo/microservices-demo. Accessed: 2025-01-14

    work page 2025

Show all 55 references
  1. [8]

    Zhiyu Fan, Xiang Gao, Martin Mirchev, Abhik Roychoudhury, and Shin Hwei Tan. 2023. Automated repair of programs from large lan- guage models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 1469–1481

    2023

  2. [9]

    Peiyuan Feng, Yichen He, Guanhua Huang, Yuan Lin, Hanchong Zhang, Yuchen Zhang, and Hang Li. 2024. AGILE: A Novel Reinforce- ment Learning Framework of LLM Agents. arXiv:arXiv:2405.14751

    2024 arXiv

  3. [10]

    Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu Pan, Yuxi Bi, Yi Dai, Jiawei Sun, and Haofen Wang. 2023. Retrieval-augmented generation for large language models: A survey. arXiv preprint arXiv:2312.10997 (2023)

    2023 arXiv

  4. [11]

    Jake Grigsby, Linxi Fan, and Yuke Zhu. 2023. AMAGO: Scal- able In-Context Reinforcement Learning for Adaptive Agents. arXiv:arXiv:2310.09971

    2023 arXiv

  5. [12]

    Zhenyu Guan, Xiangyu Kong, Fangwei Zhong, and Yizhou Wang

  6. [13]

    Taicheng Guo, Xiuying Chen, Yaqi Wang, Ruidi Chang, Shichao Pei, Nitesh V Chawla, Olaf Wiest, and Xiangliang Zhang. 2024. Large lan- guage model based multi-agents: A survey of progress and challenges. arXiv preprint arXiv:2402.01680 (2024)

    2024 arXiv

  7. [14]

    Izzeddin Gur, Hiroki Furuta, Austin Huang, Mustafa Safdari, Yutaka Matsuo, Douglas Eck, and Aleksandra Faust. 2023. A Real-World WebAgent with Planning, Long Context Understanding, and Program Synthesis. arXiv:arXiv:2307.12856

    2023 arXiv

  8. [15]

    Lei Huang, Weijiang Yu, Weitao Ma, Weihong Zhong, Zhangyin Feng, Haotian Wang, Qianglong Chen, Weihua Peng, Xiaocheng Feng, Bing Qin, et al. 2023. A survey on hallucination in large language models: Principles, taxonomy, challenges, and open questions. ACM Transac- tions on In...

    2023

  9. [16]

    Xu Huang, Weiwen Liu, Xiaolong Chen, Xingmei Wang, Hao Wang, Defu Lian, Yasheng Wang, Ruiming Tang, and Enhong Chen. 2024. Understanding the planning of LLM agents: A survey. arXiv preprint arXiv:2402.02716 (2024)

    2024 arXiv

  10. [17]

    Ramtin Jabbari, Nauman bin Ali, Kai Petersen, and Binish Tanveer

  11. [18]

    Haolin Jin, Linghan Huang, Haipeng Cai, Jun Yan, Bo Li, and Huam- ing Chen. 2024. From llms to llm-based agents for software engi- neering: A survey of current, challenges and future. arXiv preprint arXiv:2408.02479 (2024)

    2024 arXiv

  12. [19]

    Pengxiang Jin, Shenglin Zhang, Minghua Ma, Haozhe Li, Yu Kang, Liqun Li, Yudong Liu, Bo Qiao, Chaoyun Zhang, Pu Zhao, Shilin He, Federica Sarro, Yingnong Dang, Saravan Rajmohan, Qingwei Lin, and Dongmei Zhang. 2023. Assess and Summarize: Improve Outage Understanding with Large...

    2023

  13. [20]

    Sungmin Kang, Gabin An, and Shin Yoo. 2024. A Quantitative and Qualitative Evaluation of LLM-Based Explainable Fault Localization. Proc. ACM Softw. Eng. 1, FSE, Article 64 (jul 2024), 23 pages. https: //doi.org/10.1145/3660771

    2024 doi

  14. [21]

    Kephart and David M

    J. Kephart and David M. Chess. 2003. The Vision of Autonomic Com- puting. Computer 36 (2003), 41–50. https://api.semanticscholar.org/ CorpusID:44705503

    2003

  15. [22]

    Tushar Khot, Harsh Trivedi, Matthew Finlayson, Yao Fu, Kyle Richard- son, Peter Clark, and Ashish Sabharwal. 2022. Decomposed prompt- ing: A modular approach for solving complex tasks. arXiv preprint arXiv:2210.02406 (2022)

    2022 arXiv

  16. [23]

    Van-Hoang Le and Hongyu Zhang. 2023. Log Parsing: How Far Can ChatGPT Go?. In 38th IEEE/ACM International Conference on Auto- mated Software Engineering, ASE 2023, Luxembourg, September 11-15,

    2023

  17. [24]

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al . 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing ...

    2020

  18. [25]

    Shoujie Li, Ran Yu, Tong Wu, Junwen Zhong, Xiao-Ping Zhang, and Wenbo Ding. 2024. Growing from Exploration: A Self-Exploring Frame- work for Robots Based on Foundation Models. CAAI Artificial Intelli- gence Research 3 (2024), 9150037. https://doi.org/10.26599/AIR.2024. 9150037

    2024 doi

  19. [26]

    Junting Lu, Zhiyang Zhang, Fangkai Yang, Jue Zhang, Lu Wang, Chao Du, Qingwei Lin, Saravan Rajmohan, Dongmei Zhang, and Qi Zhang. 2024. Turn Every Application into an Agent: Towards Effi- cient Human-Agent-Computer Interaction with API-First LLM-Based Agents. arXiv:arXiv:2409.17140 6

    2024 arXiv

  20. [27]

    Yecheng Jason Ma, William Liang, Guanzhi Wang, De-An Huang, Osbert Bastani, Dinesh Jayaraman, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Eureka: Human-Level Reward Design via Coding Large Language Models. arXiv:arXiv:2310.12931

    2023 arXiv

  21. [28]

    OpenAI. 2024. Hello GPT-4o. https://openai.com/index/hello-gpt-4o/

    2024

  22. [29]

    OpenAI. 2024. Introducing OpenAI o1 Preview. https://openai.com/ index/introducing-openai-o1-preview/

    2024

  23. [30]

    Archiki Prasad, Alexander Koller, Mareike Hartmann, Peter Clark, Ashish Sabharwal, Mohit Bansal, and Tushar Khot. 2023. Adapt: As- needed decomposition and planning with language models. arXiv preprint arXiv:2311.05772 (2023)

    2023 arXiv

  24. [31]

    Prometheus. 2024. Prometheus - From metrics to insight. https: //prometheus.io/ Accessed: 2025-01-14

    2024

  25. [32]

    Bo Qiao, Liqun Li, Xu Zhang, Shilin He, Yu Kang, Chaoyun Zhang, Fangkai Yang, Hang Dong, Jue Zhang, Lu Wang, et al

  26. [34]

    Lucy Xiaoyang Shi, Yunfan Jiang, Jake Grigsby, Linxi Fan, and Yuke Zhu. 2023. Cross-Episodic Curriculum for Trans- former Agents. In Advances in Neural Information Processing Sys- tems, A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (Eds.), Vol. 36. Curran...

    2023

  27. [35]

    Karlsson, Bo An, Shuicheng Yan, and Zongqing Lu

    Weihao Tan, Wentao Zhang, Xinrun Xu, Haochong Xia, Ziluo Ding, Boyu Li, Bohan Zhou, Junpeng Yue, Jiechuan Jiang, Yewen Li, Ruyi An, Molei Qin, Chuqiao Zong, Longtao Zheng, Yujie Wu, Xiaoqiang Chai, Yifei Bi, Tianbao Xie, Pengjie Gu, Xiyun Li, Ceyao Zhang, Long Tian, Chaojie Wa...

    2024 arXiv

  28. [36]

    arXiv preprint arXiv:2311.17541 (2023)

    Taskweaver: A code-first agent framework. arXiv preprint arXiv:2311.17541 (2023)

    2023 arXiv

  29. [37]

    Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Voy- ager: An Open-Ended Embodied Agent with Large Language Models. arXiv:arXiv:2305.16291

    2023 arXiv

  30. [38]

    Hanlin Wang, Chak Tou Leong, Jian Wang, and Wenjie Li. 2024. E2CL: Exploration-based Error Correction Learning for Embodied Agents. In Findings of the Association for Computational Linguistics: EMNLP 2024, Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.). Association f...

    2024

  31. [39]

    https://proceedings.neurips.cc/paper_files/paper/2023/file/ 001608167bb652337af5df0129aeaabd-Paper-Conference.pdf

    2023

  32. [40]

    Zefan Wang, Zichuan Liu, Yingying Zhang, Aoxiao Zhong, Jihong Wang, Fengbin Yin, Lunting Fan, Lingfei Wu, and Qingsong Wen

  33. [41]

    Cunxiang Wang, Xiaoze Liu, Yuanhao Yue, Xiangru Tang, Tianhang Zhang, Cheng Jiayang, Yunzhi Yao, Wenyang Gao, Xuming Hu, Zehan Qi, et al. 2023. Survey on factuality in large language models: Knowl- edge, retrieval and domain-specificity. arXiv preprint arXiv:2310.07521 (2023)

    2023 arXiv

  34. [42]

    Lin Xu, Zhiyuan Hu, Daquan Zhou, Hongyu Ren, Zhen Dong, Kurt Keutzer, See Kiong Ng, and Jiashi Feng. 2024. Magic: Investigation of large language model powered multi-agent in cognition, adaptability, rationality and collaboration. In Proceedings of the 2024 Conference on Empir...

    2024

  35. [43]

    Zelai Xu, Chao Yu, Fei Fang, Yu Wang, and Yi Wu. 2024. Language Agents with Reinforcement Learning for Strategic Play in the Were- wolf Game. In Proceedings of the 41st International Conference on Ma- chine Learning (Proceedings of Machine Learning Research, Vol. 235) , Ruslan...

    2024

  36. [45]

    Xin Wang, Yudong Chen, and Wenwu Zhu. 2021. A survey on cur- riculum learning. IEEE transactions on pattern analysis and machine intelligence 44, 9 (2021), 4555–4576

    2021

  37. [46]

    Danyang Zhang, Lu Chen, Situo Zhang, Hongshen Xu, Zihan Zhao, and Kai Yu. 2024. Large language models are semi-parametric re- inforcement learning agents. In Proceedings of the 37th International Conference on Neural Information Processing Systems (New Orleans, LA, USA) (NIPS ...

    2024

  38. [47]

    In Proceedings of the 33rd ACM International Conference on Information and Knowledge Management (Boise, ID, USA) (CIKM ’24)

    RCAgent: Cloud Root Cause Analysis by Autonomous Agents with Tool-Augmented Large Language Models. In Proceedings of the 33rd ACM International Conference on Information and Knowledge Management (Boise, ID, USA) (CIKM ’24). Association for Computing Machinery, New York, NY, US...

  39. [48]

    Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2023. Auto- mated program repair in the era of large pre-trained language models. In 2023 IEEE/ACM 45th International Conference on Software Engineer- ing (ICSE). IEEE, 1482–1494

    2023

  40. [49]

    Zeyu Zhang, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Quanyu Dai, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2024. A Survey on the Memory Mechanism of Large Language Model based Agents. arXiv:arXiv:2404.13501

    2024 arXiv

  41. [52]

    Chi Zhang, Zhao Yang, Jiaxuan Liu, Yucheng Han, Xin Chen, Zebiao Huang, Bin Fu, and Gang Yu. 2023. AppAgent: Multimodal Agents as Smartphone Users. arXiv:arXiv:2312.13771

    2023 arXiv

  42. [54]

    Lingzhe Zhang, Tong Jia, Mengxi Jia, Yifan Wu, Aiwei Liu, Yong Yang, Zhonghai Wu, Xuming Hu, Philip S Yu, and Ying Li. 2024. A survey of aiops for failure management in the era of large language models. arXiv preprint arXiv:2406.11213 (2024)

    2024 arXiv

  43. [55]

    Xuchao Zhang, Supriyo Ghosh, Chetan Bansal, Rujia Wang, Minghua Ma, Yu Kang, and Saravan Rajmohan. 2024. Automated Root Causing of Cloud Incidents using In-Context Learning with GPT-4. In Com- panion Proceedings of the 32nd ACM International Conference on the Foundations of So...

    2024

  44. [2016]

    In Proceedings of the scientific workshop proceedings of XP2016

    What is DevOps? A systematic mapping study on definitions and practices. In Proceedings of the scientific workshop proceedings of XP2016. 1–11

  45. [2023]

    https://doi.org/10.1109/ASE56229.2023.00206

    IEEE, 1699–1704. https://doi.org/10.1109/ASE56229.2023.00206

    2023

  46. [2024]

    NuerIPS 2024

    Richelieu: Self-Evolving LLM-Based Agents for AI Diplomacy. NuerIPS 2024. (2024). arXiv:arXiv:2407.06813

    2024

  47. [7639]

    https://doi.org/10.18653/v1/2024.findings-emnlp.448

    2024 doi

Pith tools

Reviewed August 9, 2026 · model on record in the stance chip above.