PaperlayerView exact revision on arXiv

Source-linked AI summary

ChunkAct: Action Chunking for Agentic Robotics

Bingxin Xu, Wenrui Bao, Xinxin Liu, Jiawei Zhou, Yuzhang Shang, Emilio Ferrara

arXiv:2610.18874v1cs.ROcs.AIcs.CLcs.CV

TL;DR

Agentic robotics can generalize without retraining, but primitive-by-primitive LLM reasoning over the interaction history makes episodes costly. ChunkAct compiles memory into autonomous action chunks and calls the planner at decision points; on LIBERO-Pro it improves success while using fewer LLM calls and tokens.

  • Problem

    Agentic robotics repeatedly invokes the LLM for each primitive over the full interaction history, although primitives after a chosen sub-goal follow a routine already prescribed by memory.

    Source: §1 · p. 1

  • Method

    ChunkAct compiles memory offline into executable chunks of chained primitives that run without memory access at test time, returning control to the planner upon failure or at decisions requiring reasoning.

    Source: §1 · p. 2, §3.2 · p. 4, §3.3 · p. 5

  • Results

    5.0 points higher task success than the previous SOTA agentic robotics approach on LIBERO-Pro, with 2.9× fewer LLM calls, 4.4× fewer input tokens, and 2.3× fewer output tokens.

    Source: §1 · p. 2

  • Takeaways & Limitations

    On LIBERO-Pro, ChunkAct’s planner computation scales with decisions rather than primitives while improving task success and reducing LLM use.

    Source: §5 · p. 8

Abstract

from arXiv · show

Agentic robotics places a large language model (LLM) agent in the robot control loop, where it composes perception, motion, and vision-language-action (VLA) tools under the guidance of a memory and thereby generalizes to new tasks without retraining. This generality comes at a steep price in efficiency. Every primitive requires a round of LLM reasoning over the full interaction history, so the cost of an episode grows with the number of primitives. We find this reasoning largely redundant: once a sub-goal is chosen, its primitives follow a routine already prescribed by memory. We present ChunkAct, which introduces action chunking to agentic robotics. Online, a single call launches a chunk of chained primitives, which executes autonomously and returns control only upon failure. Offline, ChunkAct compiles the memory into these chunks, so execution is memory-free at test time and the planner is reserved for decisions that require reasoning. LLM computation therefore scales with the number of decisions rather than the number of primitives. On LIBERO-Pro, ChunkAct improves task success by 5.0 points over the state of the art in agentic robotics while requiring 2.9x fewer LLM calls, 4.4x fewer input tokens, and 2.3x fewer output tokens.

1 Introduction

Agentic robotics can generalize to new tasks by placing an LLM and tools in the robot control loop, but repeated planning over the full history makes execution costly. ChunkAct compiles memory into executable action chunks, reserving the planner for decisions and improving LIBERO-Pro success while reducing LLM use.

1 Introduction

  • Each primitive prompts another LLM reasoning round over the full interaction history, making calls and output tokens grow linearly and input tokens grow quadratically with episode length.A pick-and-place task averages 24.2 LLM calls and 2.2M input tokens, with an estimated cost of about $22 per episode using GPT-6 Astra.Source: §1 · p. 1
  • After a sub-goal is chosen and targets are localized, memory already prescribes a fixed primitive routine, so repeated reasoning can reproduce an existing decision.The passage continues that memory retrieval and reasoning become less reliable as context grows.Source: §1 · pp. 1–2
  • ChunkAct launches chained primitives as an autonomous action chunk with one planner call, returning a typed failure exit and reserving LLM reasoning for scene understanding, failure diagnosis, and redirection.Offline, it compiles memory into chunks so execution is memory-free at test time.Source: §1 · p. 2
  • ChunkAct combines chunked execution and offline memory internalization to improve efficiency and performance; it is described as the first agentic robot manipulation system to commit to chained perception and control primitives per call.The introduction frames the approach as action chunking for agentic robotics.Source: §1 · p. 2
  • 5.0 points higher success on LIBERO-Pro than the previous SOTA agentic robotics approach, with 2.9× fewer LLM calls, 4.4× fewer input tokens, and 2.3× fewer output tokens.The introduction also reports strong zero-shot transfer capability.Source: §1 · p. 2

2 Related Work

Related work brings together agentic robotics, policy action chunking, and memory systems, but distinguishes ChunkAct by compiling recurring call sequences into executable physical routines. The paper positions its approach as addressing planner cost while extending action chunks beyond motor commands.

2 Related Work

  • Earlier agentic robotics work used LLMs with perception, motion, and VLA tools and memory, but did not address planner cost before every primitive; caching plans for seen tasks was a narrower approach [Zhang et al., 2026a; Kim et al., 2026a].The authors claim to be the first to improve agentic robotics efficiency by consolidating recurring call sequences into reusable action routines.Source: §2 · p. 3
  • In robotics, learned-policy chunks are short motor-command sequences, whereas ChunkAct explores chunks spanning perception, control primitives, and internalized memory [Zhao et al., 2023].Prior work also tunes the reactivity–consistency–cost trade-off by interleaving chunks for closed-loop reactivity [Liu et al., 2025; Black et al., 2026].Source: §2 · p. 3
  • Prior agentic memories are retrieved into the prompt and interpreted at test time, while ChunkAct compiles memory offline into physical executable chunks requiring no deployment-time memory access [Li et al., 2025].The cited datastore approach emits recurring spans, but its chunks remain text.Source: §2 · p. 3

3 Action Chunking for Agentic Robotics

ChunkAct compiles memory into executable action chunks offline, then runs chained primitives from a single planner call and returns control upon failure. This reserves planner reasoning for decisions rather than routine execution.

3.1 Preliminaries

  • Input tokens grow quadratically with episode steps, while calls and output tokens grow linearly; 20.5% of calls are actions versus 31.7% memory reads and 44.3% perception.The call distribution and repeated context costs motivate chunking planner work.Source: §3.1 · p. 4

3.2 Offline action chunk building

  • Chunks consolidate memory by typed sub-goal and retain stages, primitives, class-conditioned parameters, fallbacks, and verification, while excluding privileged coordinates and resolving class content by lookup.A single compiled chunk covers tasks of its type, and the library remains frozen after compilation.Source: §3.2 · p. 4

3.3 Online action chunk triggering

  • At test time, the planner grounds targets and launches chunks for ordered typed sub-goals; they execute autonomously, returning typed errors only when a stage fails.Error exits carry robot state, fresh observations, and a log; the planner can re-ground, redo a failed sub-goal, or fall back to primitives.Source: §3.3 · pp. 4–5

3.4 Role of LLM planner in agentic robotics

  • The planner retains task and scene understanding and failure response, while memory retrieval and stepwise selection move into chunks; planner calls scale with decisions rather than procedure length.Its context contains the instruction, decision-time observations, and exits.Source: §3.4 · pp. 5–6

4 Experiments

The experiments evaluate ChunkAct on LIBERO-Pro and LIBERO-Plus, measuring task success and LLM efficiency. They compare its main results, planner role, zero-shot transfer, and a qualitative rollout.

4.1 Setup

  • The study evaluates LIBERO-Pro and LIBERO-Plus, measures success and per-episode calls and tokens, compares VLA and agentic baselines, and keeps Harness VLA and ChunkAct setups identical except for memory use.LIBERO-Pro uses instruction and initial-state perturbations; LIBERO-Plus spans seven perturbation axes, with a single seed per task and axis.Source: §4.1 · p. 6

4.2 Main results

  • ChunkAct reaches 83.8% overall success on LIBERO-Pro, beating Harness VLA by 5.0 points while using 2.9× fewer calls, 4.4× fewer input tokens, and 2.3× fewer output tokens.The comparison uses the same planner, primitive, perception, and memory; the systems differ in how memory is used.Source: §4.2 · p. 7

4.3 Analysis of LLM planner role in ChunkAct

  • ChunkAct's success stays stable without planner reasoning, while chunks alone reach 57.5%; the LLM adds 22.5 points through recovery after chunk failures.Harness VLA degrades sharply when reasoning is disabled; the scripted driver tests chunk execution without an LLM call.Source: §4.3 · pp. 7–8

4.4 Generalization to unseen perturbations

  • Zero-shot on LIBERO-Plus, ChunkAct exceeds the strongest prior method by 11.0 points overall and leads in six of seven perturbation dimensions.The chunk library and planner prompt are unchanged from the LIBERO-Pro setup, while VLA baselines are fine-tuned on LIBERO-Plus data.Source: §4.4 · p. 8

4.5 Qualitative analysis

  • In a 22-second rollout, the planner intervenes at launch and after a slip, then a second chunk completes placement autonomously.After the can slips, the planner re-localizes it and invokes ChunkAct again.Source: §4.5 · p. 8, Figure 4 · p. 8

5 Conclusion

The conclusion presents ChunkAct as a way to reduce the inefficiency of agentic robotics by internalizing memory into executable chunks. On LIBERO-Pro it improves success and reduces LLM costs, and it transfers zero-shot to unseen LIBERO-Plus perturbations.

5 Conclusion

  • Agentic robotics generalizes to novel tasks without retraining, but incurs steep efficiency costs because the planner reasons before every primitive and spends many calls on information gathering.The conclusion identifies repetitive reasoning over routine primitives and perception and memory retrieval as the two bottlenecks.Source: §5 · p. 8
  • ChunkAct internalizes memory offline into executable chunks, decoupling the LLM from routine execution and engaging it when reasoning is needed.The conclusion characterizes this as action chunking for agentic robotics.Source: §5 · p. 8
  • On LIBERO-Pro, ChunkAct improves success by 5.0 points over the state-of-the-art method while using 2.9× fewer calls, 4.4× fewer input tokens, and 2.3× fewer output tokens, and transfers zero-shot to unseen LIBERO-Plus tasks.Source: §5 · p. 8

A Typed Exit Taxonomy

The appendix table lists all exit codes that a chunk may return upon failure and pairs each with its meaning and the planner reaction expected.

A Typed Exit Taxonomy

B Primitive Library

The appendix describes the primitive library used in the experiments and notes that ChunkAct retains it while adding one call.

B Primitive Library

Related papers

Loading 2610.18874v1…