Pith. sign in

REVIEW 3 major objections 5 minor 38 references

Integrating Quantized LLMs into Robotics Systems as Edge AI to Leverage their Natural Language Processing Capabilities

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This paper introduces llama_ros, a set of ROS 2 packages for running quantized large language models locally on robots, and claims this enables efficient edge AI for planning and explanation tasks.

desk verdict A clean, useful ROS 2 wrapper for quantized LLMs, but the paper's central efficiency and planning claims are never measured; it is a tool announcement that needs an empirical companion. read the letter →

arxiv 2506.09581 v1 pith:M6B6JPGY submitted 2025-06-11 cs.RO

Miguel Á. González-Santamarta , Francisco J. Rodríguez-Lera , David Sobrín-Hidalgo , Ángel Manuel Guerrero-Higueras , Vicente MatellÁn-Olivera This is my paper · ORCID
classification cs.RO
keywords llama_rosquantizedlargelanguagemodelsedgeAIROS2retrieval-augmentedgenerationroboticplanningexplainabilityresource-constrainedrobotics
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

Quantized large language models can be heavy, but this paper argues they can run directly on a robot's own hardware if wrapped properly. The authors introduce llama_ros, a set of ROS 2 packages that expose the llama.cpp runtime through standard robot messages, services, and actions. They claim this makes locally executed LLMs practical as edge AI, and they show two pipelines: one that replaces a symbolic planner with a retrieval-augmented prompt, and one that answers natural-language questions about a robot's logs. The tool itself is the contribution; the paper does not report measurements of plan correctness, latency, or memory use.

What carries the argument

The central object is llama_ros, a ROS 2 wrapper around llama.cpp that turns a quantized LLM into robot-callable interfaces. Quantization is the mechanism that makes it fit: model weights are reduced from full floating-point precision to low-bit fixed-point numbers, cutting memory and computation. Retrieval-augmented generation (RAG) is the companion mechanism for the use cases: a query is embedded, similar knowledge is retrieved from a vector database, and the retrieved text is spliced into the prompt so the model has context for planning or explanation. A Backus-Naur form grammar option constrains the generated response to a structured format such as JSON.

What would settle it

Take the two described pipelines and run them on a fixed benchmark: a set of robot goals with known correct plans for the planning case, and a set of log questions with known correct answers for the explanation case; then count plan success and answer accuracy while measuring latency and peak memory on the robot's actual hardware. If success rates are near zero or response times miss real-time requirements, the central claim of efficient useful execution fails.

Watch

Extended reading notes

Core claim

On the paper's own terms, llama_ros is a bridge: it wraps llama.cpp, a highly optimized C/C++ runtime for quantized LLMs, inside ROS 2 nodes, exposing a response-generation action, a tokenization service, and an embeddings service. Because the models are quantized to low-precision numbers, memory and compute demands drop enough for edge deployment. The authors integrate this wrapper with a prompt-engineering library so that retrieval-augmented generation can feed the model relevant knowledge from a vector database. In the planning use case, a cognitive architecture's symbolic PDDL planner is replaced by an LLM prompted with the robot's goal, retrieved knowledge-graph facts, and available actions; in the explainability use case, robot logs are embedded, stored, and queried in natural language. The claim is that these locally running quantized LLMs provide useful natural-language understanding and generation for decision-making and interaction inside resource-constrained robots.

Load-bearing premise

The load-bearing premise is that a quantized model running on the robot's hardware produces plans and explanations accurate enough to be useful, and the paper does not measure that accuracy.

Editorial extensions

If this is right

  • A robot could carry out natural-language planning and explanation without an internet connection, since the model runs on board.
  • New quantized models can be dropped into a ROS 2 system without rewriting robot code, as long as they are exposed through the same interfaces.
  • Structured outputs via the grammar option make LLM-generated plans machine-readable and checkable by other robot nodes.
  • RAG lets a robot ground its answers in its own knowledge graph or logs, so explanations and plans reflect what the robot actually knows.
  • The same infrastructure would support other natural-language robot tasks, such as human-robot dialogue grounded in live sensor data.

Reading between the lines

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

  • Because the paper reports no quantitative results, the immediate next step is to benchmark these pipelines against the symbolic planners they replace; that comparison would decide whether the efficiency claim translates into usable behavior.
  • The architecture implies a concrete trade-off: localized quantized models buy privacy, offline operation, and predictable latency, but they will likely trail larger cloud models on reasoning quality, so the tool's value depends on the task tolerance for errors.
  • The same wrapper could be reused as a testbed for comparing quantization levels (for example, 4-bit versus 8-bit) on the same robotics tasks, giving robot developers a direct accuracy-cost curve.
  • Extending the interface to vision-language models, as the paper lists as future work, would let the same ROS 2 services handle visual questions and grounding, not just text.
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

3 major / 5 minor

Summary. The paper introduces llama_ros, a set of public ROS 2 packages that wrap llama.cpp to run quantized large language models locally on robots. The tool exposes three ROS 2 interfaces: an action server for response generation (with optional BNF grammar constraints), a service for tokenization, and a service for embeddings; it also integrates with LangChain to support prompt engineering and RAG. The paper describes two use cases: replacing the PDDL planner POPF in the MERLIN2 cognitive architecture with an LLM-based planner fed by knowledge-graph embeddings and vector-database retrieval, and generating explanations in social robots from ROS 2 logs via RAG. The central claim is that llama_ros enables efficient execution of quantized LLMs as edge AI, improving decision-making and human-robot interaction in resource-constrained robotics systems.

Significance. The open-source nature of llama_ros and the clear description of its ROS 2 interfaces are useful contributions: the paper makes a concrete, reproducible software artifact available to the robotics community, and the architecture (llama.cpp wrapped in ROS 2, with LangChain integration and grammar-constrained generation) is coherent and relevant to current efforts to deploy LLMs on edge robots. However, the significance of the paper as a research contribution is currently limited by the absence of any empirical evaluation. The claims of 'efficient execution', 'enhanced decision-making', and improved planning or explainability are not backed by measurements of latency, memory footprint, throughput, plan correctness, plan success rate, or explanation quality. The planning and explainability use cases are described at a conceptual level and largely defer to the authors' own prior companion works [28,36,37], which are not summarized with quantitative evidence here. As a result, the paper reads as a system description and position statement rather than a validated contribution.

major comments (3)
  1. [Abstract and Section 3] The central claim that llama_ros 'enables the efficient execution of quantized LLMs as edge artificial intelligence' is not supported by any experimental data in the manuscript. There are no measurements of latency, memory usage, throughput, energy consumption, or model/quantization configurations on any specific hardware platform, nor any comparison with running llama.cpp directly or with a non-quantized model. Sections 3 and 5 make statements about operating 'efficiently within their hardware constraints' and about 'real-time constraints' (Section 1), but no numbers or benchmarks are provided. This is a load-bearing omission because the paper's stated contribution is precisely efficient edge execution.
  2. [Section 4.1 and Figure 2] The planning use case replaces the PDDL planner POPF with an LLM executed via llama_ros and RAG, yet no evaluation is provided for the resulting plans: there are no data on plan validity, executability, plan length, success rate, or time-to-plan, and no comparison with the original symbolic planner. The text refers to the authors' companion work [28], but the results of that work are not reproduced or summarized in this paper. Without such evidence, the claim that llama_ros enables robots to perform planning in a way that is useful or competitive remains unverified.
  3. [Section 4.2] The explainability use case is presented qualitatively, with evaluation deferred to prior works [36,37]. The questionnaire-based evaluation mentioned in Section 4.2 is not reported here, no explanation examples are shown, and no metrics such as usefulness, trust, or correctness are given. Since one of the paper's advertised benefits is improved human-robot interaction through explanations, this missing evidence directly affects the strength of the central utility claim.
minor comments (5)
  1. [Section 3] There is a typo in the text: 'LlamaClienteNode' should be 'LlamaClientNode', and in Figure 1 the attribute 'lama_model' should be 'llama_model'. Additionally, Section 5 contains the typo 'llam ros' instead of 'llama_ros'.
  2. [Section 4.1] The sentence 'the LLM run with llama ros acts as a planner' would be clearer as 'the LLM running with llama_ros acts as a planner', and the phrase 'such as as planning' contains a duplicated word that should be corrected.
  3. [Figure 2 caption and labels] The caption and labels in Figure 2 ('a planGenerate', 'World State embeddings') are visually unclear and appear to mix the words 'plan' and 'generate'; this should be reformatted for readability.
  4. [References] Reference [37] is cited with only a year and no venue, arXiv identifier, or DOI, which makes the claimed evaluation impossible to locate and verify. The authors should provide a complete citation or, better, include a brief summary of the reported results.
  5. [Section 2] The related-work discussion would benefit from a brief note comparing llama_ros with other local LLM integration tools for ROS 2 (such as ROS-LLM and RosGpt) in terms of architecture and interfaces, rather than only stating that those tools require an Internet connection.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity; the llama_ros tool description is self-contained, and only minor non-load-bearing self-citations appear for the companion use-case evaluations.

full rationale

This paper is an integration/tool description rather than a derivation with fitted parameters or predicted quantities. The central capability claim—running quantized LLMs through llama.cpp inside ROS 2—relies on the external llama.cpp runtime and standard quantization literature, not on an equation defined in terms of its own output. Section 3 describes the ROS 2 interfaces (response-generation action, tokenize service, embedding service) and the LangChain wrapper; nothing in that architecture is constructed from the use-case results. Sections 4.1 and 4.2 describe planning and explainability pipelines, but their validation is deferred to the authors' own previous works [28,36,37]. Those self-citations are not load-bearing for the core tool description and are grounded in external evaluation settings (ERL navigation test, validation questionnaire). The absence of in-paper latency, memory, or plan-correctness measurements is a missing-support/correctness-risk concern, not circularity. No fitted input is renamed as a prediction, no uniqueness theorem is imported from the authors' prior work, and no ansatz is smuggled in via citation. The low score reflects only the minor self-citation pattern in the use-case sections.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The central claims rest on the correctness of third-party components (llama.cpp, ROS 2, LangChain) and on untested assumptions that quantized models retain enough capability for planning and explanation. The paper contains no equations, no fitted parameters, and no invented entities.

assumptions (4)
  • domain assumption llama.cpp provides correct, sufficiently fast tokenization, embedding, and text generation for quantized LLMs.
    Section 3 builds the Llama class directly on llama.cpp and assumes its correctness and performance.
  • domain assumption ROS 2 services and actions reliably transmit prompts, tokens, and embeddings between nodes.
    Section 3 describes the ROS 2 interfaces as sufficient for LLM communication.
  • domain assumption Quantized LLMs retain enough reasoning ability for planning and explanation tasks.
    Section 4 assumes quantized models, when combined with RAG and prompts, can act as planners and explainers; no evaluation supports this.
  • domain assumption RAG retrieval from a vector database returns relevant knowledge for prompt construction.
    Section 4.1 relies on RAG to condition the LLM prompt.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Integrating Quantized LLMs into Robotics Systems as Edge AI to Leverage their Natural Language Processing Capabilities." pith.science (2026). https://pith.science/paper/M6B6JPGY

@misc{pith2026250609581,
  author       = {Pith},
  title        = {Pith review of: Integrating Quantized LLMs into Robotics Systems as Edge AI to Leverage their Natural Language Processing Capabilities},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/M6B6JPGY}},
  note         = {Machine review of arXiv:2506.09581}
}
read the original abstract

Large Language Models (LLMs) have experienced great advancements in the last year resulting in an increase of these models in several fields to face natural language tasks. The integration of these models in robotics can also help to improve several aspects such as human-robot interaction, navigation, planning and decision-making. Therefore, this paper introduces llama\_ros, a tool designed to integrate quantized Large Language Models (LLMs) into robotic systems using ROS 2. Leveraging llama.cpp, a highly optimized runtime engine, llama\_ros enables the efficient execution of quantized LLMs as edge artificial intelligence (AI) in robotics systems with resource-constrained environments, addressing the challenges of computational efficiency and memory limitations. By deploying quantized LLMs, llama\_ros empowers robots to leverage the natural language understanding and generation for enhanced decision-making and interaction which can be paired with prompt engineering, knowledge graphs, ontologies or other tools to improve the capabilities of autonomous robots. Additionally, this paper provides insights into some use cases of using llama\_ros for planning and explainability in robotics.

Figures

Figures reproduced from arXiv: 2506.09581 by the authors.

Figure 1
Figure 1. UML diagram of llama ros. The diagram includes the Llama class, which wraps llama.cpp, the LlamaNode class, which presents the ROS 2 interfaces; and the Lla￾maClientNode, which is a node example to use llama ros. The ROS 2 interfaces are an action to generate a response from a prompt, a service to tokenize a text and a service to create embeddings from a text. The architecture of llama ros is depicted through the UM… view at source ↗
Figure 2
Figure 2. Pipeline of the new planning functionality after integrating llama ros in MER￾LIN2. The knowledge of the robot, which is represented by a knowledge graph, is converted into embeddings and stored in a vector database. Then, applying RAG, only relevant knowledge is used to make the LLM run with llama ros acts as a planner. 4.1 Planning and Reasoning Reasoning is the functionality of processing knowledge to accomplish … view at source ↗
Figure 3
Figure 3. Example of using an LLM to fill a vector database with embeddings created from texts or other data. The raw data, which could be any kind of text, such as PDF documents, are converted into embeddings, which are numerical vectors, that are stored in the vector database to be used later. embeddings stored in a vector database, as presented in [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Example of Retrieval Augmented Generation (RAG). A query is used to retrieve relevant data from the vector database. That data is used to create a refined prompt. example, [34] presents the SPIRES and OntoGPT for information extraction based on structured schema and st…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

38 extracted references · 26 canonical work pages

  1. [37]

    Gonz´ alez-Santamarta, ´Angel M

    David Sobr ´ ın-Hidalgo, Miguel A. Gonz´ alez-Santamarta, ´Angel M. Guerrero- Higueras, Francisco J. Rodr ´ ıguez-Lera, and Vicente Matell´ an-Olivera. Explain- ing autonomy: Enhancing human-robot interaction through explanation generation with large language models, 2024

    work page 2024

  2. [28]

    Gonz´ alez-Santamarta, Francisco J

    Miguel ´A. Gonz´ alez-Santamarta, Francisco J. Rodr ´ ıguez-Lera, ´Angel Manuel Guerrero-Higueras, and Vicente Matell´ an-Olivera. Integration of large language models within cognitive architectures for autonomous robots, 2023

    work page 2023

  3. [1]

    Gpt-4 technical report

    OpenAI. Gpt-4 technical report. https://arxiv.org/abs/2303.08774, 2023

    arXiv 2023

  4. [2]

    Gonz´ alez-Santamarta

    Miguel ´A. Gonz´ alez-Santamarta. llama ros. https://github.com/mgonzs13/ llama_ros, April 2023

    work page 2023

  5. [3]

    Robot operating system 2: Design, architecture, and uses in the wild

    Steven Macenski, Tully Foote, Brian Gerkey, Chris Lalancette, and William Woodall. Robot operating system 2: Design, architecture, and uses in the wild. Science Robotics, 7(66):eabm6074, 2022

    work page 2022

  6. [4]

    https://github.com/ggerganov/llama.cpp, 2023

    GitHub - ggerganov/llama.cpp: Port of Facebook’s LLaMA model in C/C++ — github.com. https://github.com/ggerganov/llama.cpp, 2023. Title Suppressed Due to Excessive Length 9

    work page 2023

  7. [5]

    Deep learning with low precision by half-wave gaussian quantization

    Zhaowei Cai, Xiaodong He, Jian Sun, and Nuno Vasconcelos. Deep learning with low precision by half-wave gaussian quantization. In Proceedings of the IEEE conference on computer vision and pattern recognition , pages 5918–5926, 2017

    work page 2017

  8. [6]

    Fixed point quantization of deep convolutional networks

    Darryl Lin, Sachin Talathi, and Sreekanth Annapureddy. Fixed point quantization of deep convolutional networks. In International conference on machine learning , pages 2849–2858. PMLR, 2016

    work page 2016

Show all 38 references
  1. [7]

    The era of 1-bit llms: All large language models are in 1.58 bits

    Shuming Ma, Hongyu Wang, Lingxiao Ma, Lei Wang, Wenhui Wang, Shaohan Huang, Li Dong, Ruiping Wang, Jilong Xue, and Furu Wei. The era of 1-bit llms: All large language models are in 1.58 bits. arXiv preprint arXiv:2402.17764 , 2024

    2024 arXiv

  2. [8]

    Hugo Touvron, Thibaut Lavril, Gautier Izacard, and Xavier Martinet et. al. Llama: Open and efficient foundation language models, 2023

    2023

  3. [9]

    Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, and Amjad Almahairi et. al. Llama 2: Open foundation and fine-tuned chat models, 2023

    2023

  4. [10]

    Chatgpt for robotics: Design principles and model abilities

    Sai Vemprala, Rogerio Bonatti, Arthur Bucker, and Ashish Kapoor. Chatgpt for robotics: Design principles and model abilities. Microsoft Auton. Syst. Robot. Res, 2:20, 2023

    2023

  5. [11]

    Rosgpt vision: Commanding robots using only language models’ prompts

    Bilel Benjdira, Anis Koubaa, and Anas M Ali. Rosgpt vision: Commanding robots using only language models’ prompts. arXiv preprint arXiv:2308.11236 , 2023

    2023 arXiv

  6. [12]

    Progprompt: pro- gram generation for situated robot task planning using large language models

    Ishika Singh, Valts Blukis, Arsalan Mousavian, Ankit Goyal, Danfei Xu, Jonathan Tremblay, Dieter Fox, Jesse Thomason, and Animesh Garg. Progprompt: pro- gram generation for situated robot task planning using large language models. Autonomous Robots, pages 1–14, 2023

    2023

  7. [13]

    Smart-llm: Smart multi-agent robot task planning using large language models

    Shyam Sundar Kannan, Vishnunandan LN Venkatesh, and Byung-Cheol Min. Smart-llm: Smart multi-agent robot task planning using large language models. arXiv preprint arXiv:2309.10062 , 2023

    2023 arXiv

  8. [14]

    https://github.com/Auromix/ROS-LLM, Apr 2024

    ROS-LLM. https://github.com/Auromix/ROS-LLM, Apr 2024

    2024

  9. [15]

    Rosgpt: Next-generation human-robot interaction with chatgpt and ros

    Anis Koubaa. Rosgpt: Next-generation human-robot interaction with chatgpt and ros. 2023

    2023

  10. [16]

    Grammatical evolution

    Michael O’Neill, Conor Ryan, Michael O’Neil, and Conor Ryan. Grammatical evolution. Springer, 2003

    2003

  11. [17]

    LangChain

    Harrison Chase. LangChain. https://github.com/hwchase17/langchain, Octo- ber 2022

    2022

  12. [18]

    A systematic survey of prompt engineering in large language models: Techniques and applications

    Pranab Sahoo, Ayush Kumar Singh, Sriparna Saha, Vinija Jain, Samrat Mondal, and Aman Chadha. A systematic survey of prompt engineering in large language models: Techniques and applications. arXiv preprint arXiv:2402.07927 , 2024

    2024 arXiv

  13. [19]

    Llms4ol: Large language models for ontology learning, 2023

    Hamed Babaei Giglou, Jennifer D’Souza, and S¨ oren Auer. Llms4ol: Large language models for ontology learning, 2023

    2023

  14. [20]

    Large language models are in-context semantic reasoners rather than symbolic reasoners

    Xiaojuan Tang, Zilong Zheng, Jiaqi Li, Fanxu Meng, Song-Chun Zhu, Yitao Liang, and Muhan Zhang. Large language models are in-context semantic reasoners rather than symbolic reasoners. arXiv preprint arXiv:2305.14825 , 2023

    2023 arXiv

  15. [21]

    A comprehensive evaluation of inductive reasoning capabilities and problem solving in large language models

    Chen Bowen, Rune Sætre, and Yusuke Miyao. A comprehensive evaluation of inductive reasoning capabilities and problem solving in large language models. In Findings of the Association for Computational Linguistics: EACL 2024 , pages 323–339, 2024

    2024

  16. [22]

    Training verifiers to solve math word problems, 2021

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems, 2021. URL https://arxiv. org/abs/2110.14168, 2021

    2021 arXiv

  17. [23]

    Wino- grande: An adversarial winograd schema challenge at scale

    Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Wino- grande: An adversarial winograd schema challenge at scale. Communications of the ACM, 64(9):99–106, 2021. 10 Miguel ´A. Gonz´ alez-Santamarta et al

    2021

  18. [24]

    Chain-of-thought prompting elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems , 35:24824–24837, 2022

    2022

  19. [25]

    Large language models are zero-shot reasoners, 2023

    Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. Large language models are zero-shot reasoners, 2023

    2023

  20. [26]

    Tree of thoughts: Deliberate problem solving with large language models

    Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. arXiv preprint arXiv:2305.10601 , 2023

    2023 arXiv

  21. [27]

    Graph of thoughts: Solving elaborate problems with large language models

    Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Michal Podstawski, Hubert Niewiadomski, Piotr Nyczyk, et al. Graph of thoughts: Solving elaborate problems with large language models. arXiv preprint arXiv:2308.09687 , 2023

    2023 arXiv

  22. [29]

    Gonz´ alez-Santamarta, Francisco J

    Miguel ´A. Gonz´ alez-Santamarta, Francisco J. Rodr ´ ıguez-Lera, Camino Fern´ andez- Llamas, and Vicente Matell´ an-Olivera. Merlin2: Machined ros 2 planing.Software Impacts, 15:100477, 2023

    2023

  23. [30]

    PDDL2.1: An extension to PDDL for expressing temporal planning domains

    Maria Fox and Derek Long. PDDL2.1: An extension to PDDL for expressing temporal planning domains. J. Artif. Intell. Res. (JAIR) , 20:61–124, 12 2003

    2003

  24. [31]

    Gonz´ alez-Santamarta, Francisco J

    Miguel ´A. Gonz´ alez-Santamarta, Francisco J. Rodr ´ ıguez-Lera, Francisco Mart ´ ın, Camino Fern´ andez, and Vicente Matell´ an. KANT: A Tool for Grounding and Knowledge Management. In Jos´ e Manuel Ferr´ andez Vicente, Jos´ e Ram´ on´Alvarez- S´ anchez, F´ elix de la Paz L´...

  25. [32]

    Forward-chaining partial-order planning

    Amanda Coles, Andrew Coles, Maria Fox, and Derek Long. Forward-chaining partial-order planning. pages 42–49, 01 2010

    2010

  26. [33]

    Retrieval-augmented generation for knowledge-intensive nlp tasks

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

    2020

  27. [34]

    Structured prompt interrogation and recursive extraction of semantics (spires): A method for populating knowledge bases using zero-shot learning

    J Harry Caufield, Harshad Hegde, Vincent Emonet, Nomi L Harris, Marcin P Joachimiak, Nicolas Matentzoglu, HyeongSik Kim, Sierra Moxon, Justin T Reese, Melissa A Haendel, et al. Structured prompt interrogation and recursive extraction of semantics (spires): A method for populat...

    2024

  28. [35]

    Towards safe and trustworthy social robots: ethical challenges and practical issues

    Maha Salem, Gabriella Lakatos, Farshid Amirabdollahian, and Kerstin Dauten- hahn. Towards safe and trustworthy social robots: ethical challenges and practical issues. In Social Robotics: 7th International Conference, ICSR 2015, Paris, France, October 26-30, 2015, Proceedings 7...

    2015

  29. [36]

    Using large language models for interpreting autonomous robots behaviors

    Miguel A Gonz´ alez-Santamarta, Laura Fern´ andez-Becerra, David Sobr ´ ın-Hidalgo, ´Angel Manuel Guerrero-Higueras, Irene Gonz´ alez, and Francisco J Rodr ´ ıguez Lera. Using large language models for interpreting autonomous robots behaviors. In Hybrid Artificial Intelligent ...

    2023

  30. [2022]

    Springer International Publishing

Pith tools

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