ChunkAct: Action Chunking for Agentic Robotics

What it claims

ChunkAct replaces the per-primitive LLM tool call in agentic robot manipulation with one call per sub-goal. That call runs a pre-compiled "action chunk" that chains perception, analytic motion and VLA primitives, and it only returns control to the planner on a typed failure. The authors' motivation is cost. The prior agentic baseline (Harness VLA) averages 24.2 planner calls and 2.2M input tokens per pick-and-place episode. That is about $22 per episode with GPT-6 Astra and $11 with GPT-5.5, at OpenAI list prices as of October 2026. On LIBERO-Pro, ChunkAct moves the absolute figures as follows:

• Success: 78.8% → 83.8%
• LLM calls: 24.2 → 8.3
• Input tokens: 2.2M → 0.5M
• Output tokens: 8.5k → 3.7k

How it works

The authors profiled the baseline planner's tool calls on LIBERO and found that only 20.5% were action primitives. Perception took 44.3%, memory reads 31.7%, and finish/audit calls 3.6%. Since every tool result is re-read on every later call, input tokens grow quadratically with episode length.

Offline compilation. Memory entries (skill rules, task recipes) are grouped by sub-goal type, and each type is compiled into one chunk parameterized by object class. Two types cover their tabletop tasks:

• Transport ("put A on/in B"): locate A → hover → VLA grasp → check → carry → locate B → descend → release
• Fixture (open/close drawer, microwave, stove): locate handle → pull/push → verify

Each compiled chunk keeps the stage order, the primitive assigned to each stage, per-object-class parameters, fallbacks and verification criteria. It drops recorded coordinates and privileged simulator state, and re-estimates all geometry from live perception (SAM3 + point cloud). The VLA is used only for contact-rich stages such as grasping and fixture actuation. The chunk library is compiled once and frozen.

Online execution. The planner reads no memory at test time. It parses the instruction into typed sub-goals, grounds the first target, and launches the chunk. Each stage is verified before the next one starts. On failure, the chunk returns a typed exit code with an error log.

flowchart TD
  P[LLM planner: parse task, ground target] --> C[Launch chunk via one call]
  C --> S[Run stage + verify]
  S -->|ok, more stages| S
  S -->|all done| D[done]
  S -->|typed error: need_pixels / grasp_failed / lost_in_carry / bad_target / not_placed| P

The planner's context holds only the instruction, the observations it requested, and the exits it received.

Evidence

All numbers come from LIBERO-Pro, compared against the prior agentic-robotics SOTA (Harness VLA):

The authors attribute the success gain to the shorter planner context and to memory being applied consistently throughout execution. They also claim strong zero-shot transfer, but the fetched text contains no numbers for it.

Limits

• Truncated page. The text cuts off in Section 3.3. Table 2, the transfer results, any ablations, and the stated limitations are not visible here.
• No adoption details. No code, weights or release information appears in the fetched text.
• Narrow task coverage. Chunks exist only for the transport and fixture sub-goal types. The page does not say how a task outside those types is handled.
• Rigid library. The library is frozen after compilation, so new procedural knowledge requires recompiling.
• Missing setup details. The excerpt does not name the planner LLM used for the LIBERO-Pro numbers or give ChunkAct's dollar cost per episode. The $22 and $11 figures describe the baseline only.
• Simulation only. Results are on simulated LIBERO-Pro. The real-arm figure cited (19/20 trials) belongs to a prior GPT-6 Astra harness, not ChunkAct.