LMPVC and Policy Bank: Adaptive voice control for industrial robots with code generating LLMs and reusable Pythonic policies

Ossi Parikka; Roel Pieters

REVIEW 4 major objections 5 minor 30 references

LMPVC and Policy Bank: Adaptive voice control for industrial robots with code generating LLMs and reusable Pythonic policies

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read A voice-control system for industrial robots, LMPVC, keeps a small locally running LLM competitive by letting users teach and save reusable Python policies, which are then automatically injected into the model's prompts.

desk verdict A useful Policy Bank extension to Code-as-Policies with a real robot demo, but the headline compensation claim is not backed by a controlled comparison—send to review with a request for that ablation. read the letter →

arxiv 2506.22028 v1 pith:C4V2OLIQ submitted 2025-06-27 cs.RO

Ossi Parikka , Roel Pieters This is my paper

classification cs.RO

keywords voicecontrolcode-generatingLLMsPolicyBankhuman-robotcollaborationROS2industrialrobotsreusablepolicieslocalLLMdeployment

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 LMPVC, a modular voice-control architecture for ROS2 robots, and the Policy Bank, a companion framework that turns voice-guided demonstrations into saved Python policies. The central claim is that this policy repository compensates for the weaknesses of the underlying code-generating LLM, letting a small local model (StarCoder2-15B) handle specialized industrial tasks—such as inspecting parts or handing over a held object—that it could not generate from scratch. If this holds, manufacturers can adapt a robot to new tasks by talking to it, without fine-tuning or cloud dependence. The authors support the claim with a 78% completion rate over 50 varied commands, a recorded pump-assembly collaboration, and sub-1.5-second median code-generation latencies on an RTX 3080.

What carries the argument

The Policy Bank is the central mechanism: a file-based repository of Python functions with import statements, a #BODY section, and a #HINT comment, registered via a JSON configuration. When the user says 'record policy', the Core passes each generated code block to the Policy Bank; 'save policy' prompts for a name and a hint and writes the code to disk, after which the hint is included in every future prompt to the code-generation LLM. The architecture also implements hierarchical generation—the model can call undefined functions that are then generated in a second pass—and context retention, where previously generated code stays in the prompt to support follow-up commands.

What would settle it

Run the open-source LMPVC on the pump-assembly task while artificially degrading or occluding the object detector (for example, moving the pipe and cover to novel poses or dimming the camera), and count how often parts_check and full_check give the correct 'found' or 'missing' answer. If the error rate of the taught policies tracks the detector's failures rather than the LLM's code quality, the claim that the Policy Bank compensates for the LLM's limitations is not supported.

Watch

Extended reading notes

Core claim

The paper's core discovery is that a library of short, human-readable Python functions—recorded from successful code-generation runs or written by hand, each tagged with a natural-language hint—can be folded into the prompt of a code-generating LLM. Once a function like handover or parts_check is registered, the model calls it when the user's command matches the hint, so the robot's behaviour is not limited to what the LLM can invent on the spot. The authors show that with this mechanism, StarCoder2-15B running on a single RTX 3080 completes 39 of 50 commands (78%), including multi-step inspection and handover routines that require object detection and motion, and that the resulting policies survive conversational follow-ups like 'check again' because earlier generated code is retained as context.

Load-bearing premise

The whole demonstration assumes the object detection module—which the paper deliberately leaves out, shipping only interfaces—returns correct object names and poses every time the generated code calls robot.find(), and no detection accuracy is reported.

Editorial extensions

If this is right

If the central claim is correct, a factory can add a new workflow to a robot by walking it through the steps once by voice, and the saved policy then triggers automatically from a matching spoken request.
The dependence on a large cloud model is reduced: a 15B parameter model in 4-bit quantization, running on a consumer GPU, is enough for real-time voice command latency (mostly under 1.5 seconds) and reasonable task success.
Policies are editable text files, so a programmer can fix or extend a taught behaviour afterwards, and policies can call other policies, creating arbitrarily long composite routines.
The same Policy Bank approach could be applied to any LLM-based code-generation control system, since it only requires prompt injection and a file save step.

Reading between the lines

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

The paper's principle—save successful generated code as a named, hint-tagged function and let the model call it—is a general prompt-engineering pattern that could improve code-generating LLMs in non-robotics settings too, such as data-processing scripts, where a library of previously validated functions is injected into the context.
The Policy Bank's reliance on robot.find() as the only perception channel suggests that the framework's ceiling is set by the object detector; a natural extension would be to also record and replay failure-handling branches when detection returns nothing, so the policy can ask for help rather than abort.
Because the system stores policy code verbatim, security-sensitive industrial users could audit exactly what a taught policy executes; this transparency might be a stronger selling point than the task success itself, but the paper does not discuss it.

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.

Desk Editor's Note

read the letter

Quick take: this is a legitimate, clearly-written systems paper that builds on Code as Policies by adding a Policy Bank that records generated code as reusable voice-programmable skills, and it runs on a local 15B model rather than a cloud LLM. The open-source ROS2 implementation and the real-robot pump assembly demo are real assets. Give it credit for shipping code, latency numbers, and a 39/50 command success rate.

Where it falls short: the paper's central claim—that the Policy Bank compensates for the underlying LLM's limitations—is not actually measured. There is no ablation with the Policy Bank disabled or with policies removed from the prompt. The 78% success rate includes the policies, and the pump assembly is a qualitative demo, not a comparison. The failures listed (e.g., 'press the red button') are never retested after creating a policy, so we can't see compensation happening. The Discussion asserts the disadvantage of pure generation without showing data. The external object detector is also a black box: only interfaces are provided, so the detection accuracy that every policy depends on is unknown.

These are fixable concerns. A simple before/after comparison on the same command set—raw generation vs. generation with recorded policies—would directly test the thesis. Reporting detection accuracy, or at least acknowledging the dependency, would close the biggest practical gap. The paper's own writing suggests this comparison was not run, so the conclusion currently rides on an assertion.

The manuscript reads like a solid workshop/ICRA systems paper that needs a revision to match its claims. The Policy Bank idea is concrete and useful, and the local-LLM angle is relevant for industrial adoption. If the authors add the missing baseline, it becomes a much stronger submission. I'd send it to peer review, with a clear request for that ablation.

I'd bring it to the reading group as a 'how to evaluate systems claims' case. I'd cite it if I worked on LLM-based robot control, for the Policy Bank concept and the latency data.

Referee Report

4 major / 5 minor

Summary. The paper presents LMPVC, an open ROS 2 based voice-control architecture in which locally hosted StarCoder2-15B generates Python code from transcribed user commands, and introduces the Policy Bank, a mechanism for voice-based teaching and reuse of Pythonic policies. The authors report transcript-level demonstrations of direct control, context-sensitive modification, policy creation and reuse, a qualitative pump-assembly use case, a latency study, and a 39/50 command-completion result. The central claim, stated in the Abstract and Discussion, is that the Policy Bank compensates for limitations of the underlying LLM and enables adaptation to downstream tasks without model retraining.

Significance. If the central claim were supported, the work would be a practical and timely contribution: it combines a local, data-safe LLM with a modular robot-control stack and a reusable-policy mechanism, and it releases code and a video demonstration. The paper also includes useful engineering evidence, such as latency measurements on modest hardware and a real robot assembly demonstration. However, the evidence as presented does not isolate the contribution of the Policy Bank from raw code generation, and the evaluation inherits an unvalidated object-detection dependency. The core idea is plausible and the missing experiments are feasible, so the contribution is currently under-supported rather than invalid.

major comments (4)

[Abstract and §V-G] The central claim that the Policy Bank 'can compensate for the limitations of the underlying LLM' is not tested. The 78% success rate in §V-G is computed for the full system where policies are included in the prompt; there is no comparison condition with the Policy Bank disabled. The pump assembly (§V-E) is also run only in the full-system configuration. To support the claim, the authors should run the same 50-command set with and without the policies included, report per-command outcomes, and show that failures such as 'press the red button' or 'back the other way' are repaired when a relevant policy is available. Without this ablation, the paper's headline conclusion remains an assertion.
[§V-G] The stated methodology says 'we analyze the generated code for each command, calculate the success rate' — not that the commands were executed on the robot. Code-level success is not task-level success: generated code can be syntactically and semantically plausible yet fail at runtime due to motion planning, collision, gripper failure, or perception errors. The paper should either execute the command set on the real robot or in a simulator, or explicitly relabel the 39/50 result as a code-generation accuracy metric and avoid presenting it as full-system task completion.
[§IV-A, §V-A] The object detection module is a load-bearing unvalidated dependency. The text states that the reference implementation 'only contains interfaces,' and the experimental setup says that the detection implementation used for testing is based on a separate thesis, but no detection accuracy, failure modes, or timing characteristics are reported. Every demonstrated policy and several test commands rely on robot.find() returning correct object names and poses. If detection is unreliable, the pump assembly and the policy-based commands will fail regardless of LLM code quality. The authors should either report detection performance on the actual test scenes or state explicitly that all results in §V presuppose a reliable detector.
[§V-E] The pump assembly demonstration is qualitative: there is no baseline, no success metric, no timing data, and no count of user interventions. The text says the experiment 'demonstrates that the Policy Bank can allow LMPVC to adapt,' but without a comparison to the same task performed with raw code generation, the demonstration cannot distinguish the Policy Bank's contribution from the LLM's own capability on those commands. Adding at least one quantitative run with the Policy Bank disabled, or a clear statement that no such run was performed, would make the scope of the claim explicit.

minor comments (5)

[§V-B, §V-C] The generated circle-drawing code contains an extra closing parenthesis: 'for i in range(waypoints + 1)):' appears in both examples. This is presumably a transcription error, but it should be corrected because the examples are otherwise presented as faithful output.
[§II] The reference [10] is spelled 'Vemprala' in the Introduction and 'Vemparala' in the Related Work; the spelling should be made consistent.
[§V-G] The test-set selection procedure is described only as commands 'possible to complete with the tools the system has access to.' Because several commands closely resemble the hand-written examples in the static prompt, the authors should discuss the risk that the success rate is inflated by prompt memorization, and ideally report a second set of commands that are semantically distant from the prompt examples.
[§V-F] The latency measurements exclude speech recognition and policy-retrieval overhead, as the text acknowledges; it would be helpful to state the Whisper transcription latency separately so readers can estimate end-to-end command latency.
[§IV-C] The sentence 'These files are then registered with the system through a JSON configuration file' could be clarified with an example of the JSON structure or a pointer to the GitHub repository's configuration format, since this is the interface that determines prompt construction.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: LMPVC/Policy Bank is an empirical systems paper; the unsupported Policy Bank benefit claim is a missing-baseline evidence gap, not a circular step.

full rationale

This is an empirical systems paper with no formal derivation chain, fitted parameters, uniqueness theorems, or mathematical predictions that could be equivalent to their inputs by construction. The self-citation to the first author's M.Sc. thesis [11] is used to credit the origin of several experiments, but it is not load-bearing for the paper's claims. The central assertion that the Policy Bank 'can compensate for the limitations of the underlying LLM' (Abstract, Section VI) is not isolated by an ablation: the reported 78% command-completion rate (Section V-G) is for the full system with policies included in the prompt, and no comparison condition with the Policy Bank disabled is presented. Likewise, the pump assembly demonstration (Section V-E) uses policies created earlier by the same system, making it self-referential as an evaluation but not a reduction of a predicted quantity to its input. These are evidence-gap and baseline concerns, not circularity. No specific equation, fitted parameter, or self-citation chain can be quoted to demonstrate that a result is forced by definition. Therefore no circular step is exhibited.

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

The central claim does not rest on numeric fitted parameters; the hand-chosen prompt examples and heuristic distances are listed as free parameters for transparency. The main axioms are that the local LLM can generate valid code for the provided API, that speech-to-text is accurate enough, and that the object detection interface supplies correct poses, none of which are independently benchmarked in this paper.

free parameters (2)

Static prompt preamble examples and policy hints (#BODY, #HINT) = text (not numeric)
Section IV-B and IV-C describe hand-written examples in the prompt that define the API and expected behavior; these are design choices, not fitted to data, but they directly shape code generation success.
Heuristic distance for 'a little' = 0.05 m
Section V-B shows commands like 'Move a little down' are resolved to 0.05 m based on prompt examples; this is an ad hoc scale constant.

assumptions (4)

domain assumption StarCoder2-15B, as loaded via llama.cpp in IQ4_XS quantization, can generate executable code for the LMPVC high-level controller API from the engineered prompt.
The system's operation depends on this; Section IV-B and V-G provide evidence on 50 commands, but not a systematic coverage analysis.
domain assumption The object detection interface returns correct object names and 6D poses via robot.find() whenever requested.
Section IV states the object detection module is not included; Section V-A bases the implementation on [23] without reporting detection accuracy.
domain assumption Whisper (or Wav2Vec2) transcription errors are rare enough and benign enough that the LLM can recover, as with 'twotwenty'.
Speech recognition accuracy is not measured; one error-recovery example is shown in Section V-B.
domain assumption The high-level controller primitives (get_pose, add_waypoint, go, find, say, open_hand) are sufficient to express the tested industrial tasks.
The command set in Section V-G is chosen to be feasible with these primitives, so this is baked into the evaluation design.

how reviews work

0 comments

Cite this review

Pith. "Pith review of LMPVC and Policy Bank: Adaptive voice control for industrial robots with code generating LLMs and reusable Pythonic policies." pith.science (2026). https://pith.science/paper/C4V2OLIQ

@misc{pith2026250622028,
  author       = {Pith},
  title        = {Pith review of: LMPVC and Policy Bank: Adaptive voice control for industrial robots with code generating LLMs and reusable Pythonic policies},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/C4V2OLIQ}},
  note         = {Machine review of arXiv:2506.22028}
}

read the original abstract

Modern industry is increasingly moving away from mass manufacturing, towards more specialized and personalized products. As manufacturing tasks become more complex, full automation is not always an option, human involvement may be required. This has increased the need for advanced human robot collaboration (HRC), and with it, improved methods for interaction, such as voice control. Recent advances in natural language processing, driven by artificial intelligence (AI), have the potential to answer this demand. Large language models (LLMs) have rapidly developed very impressive general reasoning capabilities, and many methods of applying this to robotics have been proposed, including through the use of code generation. This paper presents Language Model Program Voice Control (LMPVC), an LLM-based prototype voice control architecture with integrated policy programming and teaching capabilities, built for use with Robot Operating System 2 (ROS2) compatible robots. The architecture builds on prior works using code generation for voice control by implementing an additional programming and teaching system, the Policy Bank. We find this system can compensate for the limitations of the underlying LLM, and allow LMPVC to adapt to different downstream tasks without a slow and costly training process. The architecture and additional results are released on GitHub (https://github.com/ozzyuni/LMPVC).

Figures

Figures reproduced from arXiv: 2506.22028 by the authors.

**Figure 2.** The modular structure of the LMPVC architecture encourages modification and increases adaptability. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** Basic operating principle of the code generation. [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Experimental assembly of a pump, demonstrating practical human-robot collaboration aided by the Policy Bank. [11] [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

**Figure 5.** Figure 5: The goal of the collaborative task. To demonstrate how LMPVC and the Policy Bank can enable HRC in practice, we conduct an experimental assembly task: A human and a robot arm collaboratively assembling a pump. For brevity, the experiment focuses on the last step of th…

**Figure 6.** Figure 6: Mean command latency in the test set. The mean latency results for each command can be seen in [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

30 extracted references · 23 canonical work pages

[1]

Challenges and opportunities in human robot collaboration context of industry 4.0 - a state of the art review,

A. K. Inkulu et al. , “Challenges and opportunities in human robot collaboration context of industry 4.0 - a state of the art review,” Industrial robot, vol. 49, no. 2, pp. 226–239, 2022

work page 2022
[2]

Survey of human–robot collab- oration in industrial settings: Awareness, intelligence, and compli- ance,

S. Kumar, C. Savur, and F. Sahin, “Survey of human–robot collab- oration in industrial settings: Awareness, intelligence, and compli- ance,” IEEE Transactions on Systems, Man, and Cybernetics: Systems, vol. 51, no. 1, pp. 280–297, 2021

work page 2021
[3]

Lightweight robots in manual assembly–best to start simply,

W. Bauer, M. Bender, M. Braun, P. Rally, and O. Scholtz, “Lightweight robots in manual assembly–best to start simply,” Frauenhofer-Institut fur Arbeitswirtschaft und Organisation IAO, Stuttgart , vol. 1, 2016

work page 2016
[4]

Spoken language interaction with robots: Recommendations for future research,

M. Marge et al. , “Spoken language interaction with robots: Recommendations for future research,” Computer Speech &; Language, vol. 71, p. 101255, 2022. [Online]. Available: http: //dx.doi.org/10.1016/j.csl.2021.101255

arXiv 2022
[5]

Sam2act: Integrating visual foundation model with a memory architecture for robotic manipulation,

H. Fang et al. , “Sam2act: Integrating visual foundation model with a memory architecture for robotic manipulation,” 2025. [Online]. Available: https://arxiv.org/abs/2501.18564

arXiv 2025
[6]

Rvt-2: Learning precise manipulation from few demonstrations,

A. Goyal, V . Blukis, J. Xu, Y . Guo, Y .-W. Chao, and D. Fox, “Rvt-2: Learning precise manipulation from few demonstrations,”

work page
[7]

Palm-e: An embodied multimodal language model,

D. Driess et al., “Palm-e: An embodied multimodal language model,” in Proceedings of the 40th International Conference on Machine Learning, ICML 2023 , vol. 202, 2023, pp. 8469–8488

work page 2023
[8]

Progprompt: Generating situated robot task plans using large language models,

I. Singh et al., “Progprompt: Generating situated robot task plans using large language models,” in 2023 IEEE International Conference on Robotics and Automation (ICRA) , 2023, pp. 11 523–11 530

work page 2023

Show all 30 references

[9]

Code as policies: Language model programs for em- bodied control,

J. Liang et al., “Code as policies: Language model programs for em- bodied control,” in 2023 IEEE International Conference on Robotics and Automation (ICRA) , vol. 2023-. IEEE, 2023, pp. 9493–9500

2023
[10]

Chatgpt for robotics: Design principles and model abilities,

S. H. Vemprala, R. Bonatti, A. Bucker, and A. Kapoor, “Chatgpt for robotics: Design principles and model abilities,” IEEE access, vol. 12, pp. 55 682–55 696, 2024

2024
[11]

V oice control of industrial robots with large language models trained on code,

O. Parikka, “V oice control of industrial robots with large language models trained on code,” Tampere University, 2024. [Online]. Available: https://urn.fi/URN:NBN:fi:tuni-2024112910646

2024
[12]

Welcome to the era of chatgpt et al.: The prospects of large language models,

T. Teubner, C. Flath, C. Weinhardt, W. Aalst, and O. Hinz, “Welcome to the era of chatgpt et al.: The prospects of large language models,” Business & Information Systems Engineering , vol. 65, 03 2023

2023
[13]

Large language models for human–robot interaction: A review,

C. Zhang, J. Chen, J. Li, Y . Peng, and Z. Mao, “Large language models for human–robot interaction: A review,” Biomimetic Intelligence and Robotics, vol. 3, no. 4, p. 100131, 2023

2023
[14]

Cliport: What and where path- ways for robotic manipulation,

M. Shridhar, L. Manuelli, and D. Fox, “Cliport: What and where path- ways for robotic manipulation,” in Proceedings of the 5th Conference on Robot Learning, CoRL 2021 , vol. 164, 2021, pp. 894–906

2021
[15]

Manipulate-anything: Automating real-world robots using vision-language models,

J. Duan et al. , “Manipulate-anything: Automating real-world robots using vision-language models,” 2024. [Online]. Available: https://arxiv.org/abs/2406.18915

2024 arXiv
[16]

Perceiver-actor: A multi- task transformer for robotic manipulation,

M. Shridhar, L. Manuelli, and D. Fox, “Perceiver-actor: A multi- task transformer for robotic manipulation,” in Proceedings of the 6th Conference on Robot Learning, CoRL 2022 , vol. 205, 2023, pp. 785– 799

2022
[17]

Text2motion: from natural language instructions to feasible plans,

K. Lin, C. Agia, T. Migimatsu, M. Pavone, and J. Bohg, “Text2motion: from natural language instructions to feasible plans,” Autonomous Robots, vol. 47, no. 8, p. 1345–1365, Nov. 2023. [Online]. Available: http://dx.doi.org/10.1007/s10514-023-10131-7

2023 doi
[18]

Robotgpt: Robot manipulation learning from chatgpt,

Y . Jin, D. Li, Y . A, J. Shi, P. Hao, F. Sun, J. Zhang, and B. Fang, “Robotgpt: Robot manipulation learning from chatgpt,” IEEE Robotics and Automation Letters , vol. 9, no. 3, pp. 2543–2550, 2024

2024
[19]

wav2vec 2.0: A framework for self-supervised learning of speech representations,

A. Baevski, H. Zhou, A. Mohamed, and M. Auli, “wav2vec 2.0: A framework for self-supervised learning of speech representations,” in 34th Conference on Neural Information Processing Systems, NeurIPS 2020, vol. 2020-, 2020

2020
[20]

Robust speech recognition via large-scale weak supervision,

A. Radford et al. , “Robust speech recognition via large-scale weak supervision,” in Proceedings of the 40th International Conference on Machine Learning, ICML 2023 , vol. 202, 2023, pp. 28 492–28 518

2023
[21]

Starcoder 2 and the stack v2: The next generation,

A. Lozhkov et al., “Starcoder 2 and the stack v2: The next generation,”
[22]

Structured chain-of-thought prompting for code generation,

J. Li, G. Li, Y . Li, and Z. Jin, “Structured chain-of-thought prompting for code generation,” ACM transactions on software engineering and methodology, vol. 34, no. 2, pp. 1–23, 2025

2025
[23]

Available: https://arxiv.org/abs/2402.19173

[Online]. Available: https://arxiv.org/abs/2402.19173

arXiv
[24]

mradermacher/starcoder2-15b-i1-gguf,

Mradermacher, “mradermacher/starcoder2-15b-i1-gguf,” 2024. [Online]. Available: https://huggingface.co/mradermacher/ starcoder2-15b-i1-GGUF

2024
[25]

Human-robot collaboration by speech in an industrial assembly task,

R. Ojanen, “Human-robot collaboration by speech in an industrial assembly task,” Tampere University, 2024. [Online]. Available: https://urn.fi/URN:NBN:fi:tuni-202409188790

2024
[26]

Flashattention-2: Faster attention with better parallelism and work partitioning,

T. Dao, “Flashattention-2: Faster attention with better parallelism and work partitioning,” in 12th International Conference on Learning Representations, ICLR 2024 , 2024

2024
[27]

llma.cpp,

G. Gerganov, “llma.cpp,” 2024. [Online]. Available: https://github. com/ggerganov/llama.cpp

2024
[28]

Nadine: A large language model-driven intelligent social robot with affective capabili- ties and human-like memory,

H. Kang, M. Ben Moussa, and N. M. Thalmann, “Nadine: A large language model-driven intelligent social robot with affective capabili- ties and human-like memory,”Computer animation and virtual worlds, vol. 35, no. 4, 2024

2024
[29]

Industrial robot control by means of gestures and voice commands in off-line and on-line mode,

W. Kaczmarek, J. Panasiuk, S. Borys, and P. Banach, “Industrial robot control by means of gestures and voice commands in off-line and on-line mode,” Sensors, vol. 20, no. 21, 2020. [Online]. Available: https://www.mdpi.com/1424-8220/20/21/6358

2020
[2024]

Available: https://arxiv.org/abs/2406.08545

[Online]. Available: https://arxiv.org/abs/2406.08545

arXiv

Pith tools

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

[1] [1]

Challenges and opportunities in human robot collaboration context of industry 4.0 - a state of the art review,

A. K. Inkulu et al. , “Challenges and opportunities in human robot collaboration context of industry 4.0 - a state of the art review,” Industrial robot, vol. 49, no. 2, pp. 226–239, 2022

work page 2022

[2] [2]

Survey of human–robot collab- oration in industrial settings: Awareness, intelligence, and compli- ance,

S. Kumar, C. Savur, and F. Sahin, “Survey of human–robot collab- oration in industrial settings: Awareness, intelligence, and compli- ance,” IEEE Transactions on Systems, Man, and Cybernetics: Systems, vol. 51, no. 1, pp. 280–297, 2021

work page 2021

[3] [3]

Lightweight robots in manual assembly–best to start simply,

W. Bauer, M. Bender, M. Braun, P. Rally, and O. Scholtz, “Lightweight robots in manual assembly–best to start simply,” Frauenhofer-Institut fur Arbeitswirtschaft und Organisation IAO, Stuttgart , vol. 1, 2016

work page 2016

[4] [4]

Spoken language interaction with robots: Recommendations for future research,

M. Marge et al. , “Spoken language interaction with robots: Recommendations for future research,” Computer Speech &; Language, vol. 71, p. 101255, 2022. [Online]. Available: http: //dx.doi.org/10.1016/j.csl.2021.101255

arXiv 2022

[5] [5]

Sam2act: Integrating visual foundation model with a memory architecture for robotic manipulation,

H. Fang et al. , “Sam2act: Integrating visual foundation model with a memory architecture for robotic manipulation,” 2025. [Online]. Available: https://arxiv.org/abs/2501.18564

arXiv 2025

[6] [6]

Rvt-2: Learning precise manipulation from few demonstrations,

A. Goyal, V . Blukis, J. Xu, Y . Guo, Y .-W. Chao, and D. Fox, “Rvt-2: Learning precise manipulation from few demonstrations,”

work page

[7] [7]

Palm-e: An embodied multimodal language model,

D. Driess et al., “Palm-e: An embodied multimodal language model,” in Proceedings of the 40th International Conference on Machine Learning, ICML 2023 , vol. 202, 2023, pp. 8469–8488

work page 2023

[8] [8]

Progprompt: Generating situated robot task plans using large language models,

I. Singh et al., “Progprompt: Generating situated robot task plans using large language models,” in 2023 IEEE International Conference on Robotics and Automation (ICRA) , 2023, pp. 11 523–11 530

work page 2023