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.
The Problem of Redundant Reasoning in Agentic Robotics
Modern LLM agents in robotics act as general-purpose planners: they perceive the environment, select a high-level sub-goal, and then invoke primitive actions such as "move arm to pose" or "grasp object." Each primitive triggers another round of LLM reasoning over the complete interaction history. As the episode progresses and more primitives are executed, the computational cost scales linearly with the number of primitives, creating a bottleneck that limits real-time applicability.
The root issue is that once a sub-goal is selected, the subsequent primitives are not exploratory—they follow a routine already encoded in the agent's memory. The LLM re-reasons over the same history on every step, duplicating work that could be eliminated. This design choice was motivated by the desire for flexibility, but it comes at the expense of efficiency: an episode of N primitives incurs O(N) LLM calls, each involving full-context processing.
From Full-History Reasoning to Chunked Execution
ChunkAct addresses this inefficiency by introducing action chunking. Instead of issuing one primitive at a time and invoking the LLM on each step, a single online call launches a chunk of chained primitives. The chunk executes autonomously under memory guidance, and control returns only if a primitive fails. This reduces the LLM's role from per-primitive reasoning to per-decision planning, cutting the total number of reasoning steps dramatically.
The chunking mechanism works as follows. During training or compilation, the agent's memory—which stores past successful task executions—is mined to identify sequences of primitives that consistently achieve sub-goals. These sequences are packaged into chunks, each with a well-defined entry condition and exit condition (failure). At test time, the online agent need only evaluate which chunk to launch; once launched, the primitives run without further LLM intervention unless a failure occurs, at which point the planner re-engages to select the next chunk.
Compiling Memory into Action Chunks
The offline phase is what makes ChunkAct truly memory-free at test time. The agent's memory, comprising past task executions and successful primitive sequences, is compiled into a library of chunks. Each chunk captures a reusable behavior pattern: e.g., "approach shelf, grasp object, lift object." The compiler extracts these patterns, validates their success conditions, and stores them as atomic units.
At test time, the planner no longer needs to re-reason over the full interaction history for every primitive. Instead, it selects a chunk based on the current state and task description, launches it, and waits for completion or failure. Because the chunk's internal primitives are already resolved, the LLM's computational load drops from O(primitives per episode) to O(decisions per episode). This separation of decision planning from primitive execution is the paper's central design contribution.
The LIBERO-Pro Results
Evaluated on LIBERO-Pro, a benchmark for agentic robotics, ChunkAct achieves a task success rate that is 5.0 points higher than the previous state of the art in the agentic robotics paradigm. In addition to the success-rate improvement, the LLM computation metrics show substantial reductions: 2.9x fewer LLM calls, 4.4x fewer input tokens, and 2.3x fewer output tokens compared to the baseline. These figures reflect the direct impact of chunking: fewer reasoning rounds and more compact context usage per decision.
The baseline method reasons over the full history for every primitive, so as the episode lengthens, both input and output token counts grow. ChunkAct's chunked execution means the planner only emits a small planning description per chunk, and the history kept in context is limited to the most recent chunk rather than the entire episode. This yields the token savings while maintaining or improving task success.
Constraints and Trade-offs
The chunk compilation step requires access to a memory bank of past executions; without sufficient coverage of task patterns, the chunk library may be sparse, limiting the online agent's ability to find an appropriate chunk. Additionally, chunks have fixed internal sequences; if a task requires highly variable primitive ordering, the chunk approach may need to emit more decisions, reducing some of the efficiency gains. The authors acknowledge that the benefit depends on the granularity and diversity of patterns stored in memory.
Another trade-off is the latency introduced by chunk assembly. Launching a chunk requires the planner to match the current state to a chunk, which adds a small overhead compared to issuing a single primitive. However, this overhead is amortized across the multiple primitives inside the chunk, and the net effect is a reduction in total LLM calls and tokens.
Practical Takeaways
For a working developer integrating an LLM agent into a robotic system, ChunkAct offers a practical path to reduce compute cost without sacrificing the generalization that LLM-based planning provides. The key practice is to maintain a memory repository of successful primitive sequences and compile them into chunks before deployment. At runtime, the planner reserves its reasoning budget for chunk selection and failure recovery, while the primitives inside each chunk run autonomously. This division of labor—decision planning versus primitive execution—aligns naturally with many robotics pipelines where perception and motion primitives are well-defined and reusable.
Developers can begin by clustering historical primitive sequences from recorded task runs, validating exit conditions (failure triggers), and packaging them as chunks. The resulting reduction in LLM calls and context size can be substantial, especially in long-horizon tasks where the episode comprises dozens of primitives.