ChunkAct: Introducing Action Chunking to Agentic Robots, Cutting LLM Calls by 2.9x

The Efficiency Dilemma of Agentic Robots

Putting large language models into robot control loops has been one of the most exciting directions in robotics over the past few years. LLM agents can compose tools for perception, motion, and vision-language-action (VLA), completing new tasks under the guidance of a memory module without retraining. This generalization capability has moved robots a big step forward from "specialists" toward "generalists."

The cost is efficiency. According to the paper, each basic action primitive requires a full round of inference on the large model, with input containing the complete interaction history. This means the cost of a single task episode grows linearly with the number of primitives—the more primitives, the more times the LLM is called, the greater the token consumption, and the higher the latency. For complex tasks requiring dozens or even hundreds of consecutive actions, this overhead quickly becomes unbearable.

Vision-Language-Action models (VLA) are a class of multimodal architectures that unify visual perception, natural language instructions, and robot action generation into a single model. Typical representatives include RT-2 and OpenVLA, which usually use a pretrained vision-language model as a backbone, discretizing actions into tokens and predicting them alongside text tokens, thereby enabling robots to understand open-ended instructions like "put the red block in the blue box." The advantage of VLA lies in cross-task and cross-object generalization, without needing to collect data or retrain for each new task. In agentic robot frameworks, VLA often serves as the underlying "hands and feet" invoked by an LLM planner, while the LLM handles higher-level subgoal selection and workflow orchestration.

Action primitives refer to the smallest, atomic action units a robot can execute, such as "move forward 10 centimeters," "grasp," "release," or "rotate the wrist 30 degrees." Primitives can be combined into complex behaviors through sequences, and below them, specific controllers translate them into joint torques or velocity commands. In hierarchical agent architectures, the planner outputs primitive sequences rather than low-level motor signals—this abstraction layer allows the same planning logic to adapt to different hardware. The number of primitives directly determines the length of a task episode: a "tidy up the desk" task might decompose into dozens of primitives, and if each primitive triggers an LLM inference, the overhead rapidly accumulates.

Core Insight: Most Inference Is Redundant

ChunkAct's researchers discovered a key fact: a large portion of this inference is redundant. Once a subgoal is selected, the series of primitives needed to execute that subgoal actually follows a routine already specified in the memory module—there's no need for the LLM to "rethink" at every step.

In other words, the LLM plays two fundamentally different roles in agentic robots: one is genuine decision-making—which subgoal to choose, what to do when encountering the unexpected; the other is mechanical execution scheduling—calling tools step by step according to a known procedure. The former requires reasoning ability; the latter only requires following a routine. Mixing the two together and having the LLM perform a full inference for every primitive is a massive waste of compute.

How ChunkAct Works: Online Chunking + Offline Compilation

ChunkAct's approach is direct and effective: introducing action chunking into agentic robots.

During online execution, a single LLM call no longer triggers just one primitive but launches an entire chain of primitives. This chunk executes autonomously, returning control to the planner only upon failure. As a result, the number of LLM calls shifts from "one per primitive" to "one per decision."

In the offline phase, ChunkAct compiles the memory module into these action chunks. During execution, memory queries are no longer needed—the test phase is "memoryless," and the planner is reserved for decisions that genuinely require reasoning. Computation thus scales with the number of decisions rather than the number of primitives.

This design has an implicit benefit: since action chunks are precompiled offline, the online execution path is shorter and more deterministic, reducing the propagation of uncertainty introduced by LLM inference.

Action chunking was first proposed in the field of robot imitation learning, with the representative work being ACT (Action Chunking with Transformers). Its core idea is that a policy network's forward pass no longer outputs just a single-timestep action but predicts a sequence of actions over several future steps (a chunk), which the robot executes in order before replanning. The motivation is twofold: first, reducing the computation and jitter caused by high-frequency replanning; second, mitigating the "averaging" problem caused by multimodal action distributions in demonstration data. ChunkAct's contribution is elevating this idea from low-level continuous control to the agent planning layer—the object of chunking is no longer joint trajectories but a string of already-determined primitive calls, with chunk boundaries determined by decision points rather than fixed time windows.

Memory modules and memory compilation are another key concept. In many LLM agent architectures, the memory module exists as a vector database or structured knowledge base, recording "which operation steps correspond to a certain type of subgoal." The traditional approach retrieves memory before each primitive execution, concatenates the retrieval results into the prompt, and hands it to the LLM for inference. ChunkAct's "offline compilation" means: before deployment, the routines in memory are expanded and solidified into a set of executable action chunks, which are directly invoked online, skipping the retrieval and inference steps. This is similar to changing interpreted execution to ahead-of-time (AOT) compilation in programming languages, shifting repeated runtime overhead to a one-time build phase.

Experimental Results: Higher Success Rate, Dramatically Lower Cost

On the LIBERO-Pro benchmark, ChunkAct's results are noteworthy:

• Task success rate improves by 5.0 percentage points over the current state-of-the-art method in agentic robotics
• LLM calls reduced by 2.9x
• Input tokens reduced by 4.4x
• Output tokens reduced by 2.3x

Simultaneous improvement in both success rate and efficiency is uncommon in system optimization. Typically, reducing LLM calls sacrifices task completion quality, but ChunkAct, by eliminating redundant inference, actually allows the planner to focus more on the steps that genuinely require judgment.

LIBERO-Pro is an enhanced version of the LIBERO benchmark, used to evaluate long-horizon, multi-step robot manipulation tasks. LIBERO itself contains four task suites—Spatial, Object, Goal, and Long—testing capabilities such as spatial relationship reasoning, object generalization, goal conditioning, and long-horizon dependencies; the Pro version further increases task complexity and step counts, bringing it closer to real home or laboratory scenarios. Because of its long task episodes and many subgoals, LIBERO-Pro precisely amplifies the cost of per-primitive inference, making it a suitable testbed for efficiency optimization methods like ChunkAct. It should be noted that success rate and call count are two different types of metrics: the former reflects task completion quality, the latter reflects system overhead—only when both improve simultaneously can we say the optimization doesn't come at the cost of capability.

Implications for Agentic Robot Architecture

ChunkAct's value isn't just about saving tokens. It raises a more fundamental question: in agentic systems, what should the LLM be responsible for?

Many current agent architectures tend to involve the LLM in every step in exhaustive detail, on the grounds that "the model is strong enough, let it decide for itself." But ChunkAct's results show that stripping routine execution from the LLM's responsibilities and compiling it into reusable action chunks can simultaneously improve performance and efficiency. This has reference significance for agent design in other domains as well—whether software operation agents or multi-tool orchestration systems, "which steps require reasoning and which can be precompiled" is a question worth asking.

Action chunking has precedents in the field of robot learning. ChunkAct's innovation lies in elevating it from the low-level control layer to the agent planning layer and combining it with memory compilation to form a complete online-offline solution.

One-line Summary

ChunkAct eliminates redundant per-primitive LLM inference through online action chunking and offline memory compilation, achieving both higher success rate and efficiency.

Paragraph Summary

The article discusses the efficiency dilemma caused by step-by-step LLM reasoning in agentic robots: each basic action primitive triggers a full LLM inference, with cost growing linearly with the number of primitives. ChunkAct's insight is that much of this inference is redundant—once a subgoal is determined, the primitive sequence is already preset by the memory module, requiring no repeated LLM deliberation. Its approach is to launch an entire chain of primitives from a single online call, returning control upon failure, and to compile memory into action chunks offline so that the test phase requires no memory queries, with computation scaling by decisions rather than primitives. On LIBERO-Pro, success rate improves by 5.0 percentage points, LLM calls drop by 2.9x, and input tokens drop by 4.4x. The article thereby raises a more fundamental architectural question: the LLM should focus on reasoning, not routine scheduling.