🤖 AI

HaReCAP: Habitual-action Grounding for Recursive Large Language Model Agents

HaReCAP is a low-intrusion extension to the ReCAP framework that reduces token consumption and LLM calls in long-horizon embodied tasks by compiling frequent successful leaf decisions into offline reflex rules to bypass redundant recursive context processing for routine actions.

Original authors: Shen Liu, Zhenguo Xu, Shaopu Wang, Yike Gao, Chunlei Wang

Published 2026-08-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Shen Liu, Zhenguo Xu, Shaopu Wang, Yike Gao, Chunlei Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a robot tasked with preparing a complex meal in a busy kitchen. It cannot simply be told "make dinner"; it must break that goal down into a long chain of smaller steps: find the onions, chop them, heat the pan, and so on. To do this, modern artificial intelligence uses large language models, which act as the robot's brain. These models are excellent at reasoning and planning, but they face a specific challenge when interacting with the physical world. They must constantly translate their high-level thoughts into exact, valid commands that the robot's software can understand. If the robot thinks "pick up the onion," the system must convert that into a precise instruction like "Pick up onion1 from board1 using robot1." This translation step is necessary every single time the robot performs a basic action.

For a long time, researchers have developed ways to help these AI agents manage long tasks without getting confused or forgetting their goals. One successful method, known as recursive planning, works like a manager delegating tasks. The AI breaks a big goal into smaller sub-goals, tackles the first one, and then returns to the manager to update the plan based on what just happened. This loop allows the AI to handle complex, multi-step tasks in changing environments. However, this process has a hidden cost. Every time the AI reaches the very end of a sub-task to perform a simple action, it must ask its powerful brain to translate that thought into a command again. Even though the thought is simple, the brain has to re-read the entire history of the conversation and the current situation to ensure the command is correct. This repetition creates a significant waste of computing power and time, especially for tasks that require hundreds of steps.

A team of researchers has identified this repetitive translation as a major source of inefficiency and proposed a solution called HaReCAP. Their work focuses on the "last mile" of the process: the moment the AI decides on a specific, atomic action. Instead of asking the large language model to perform this translation every single time, the researchers taught the system to recognize when a situation is familiar and safe enough to skip the heavy thinking. They analyzed thousands of successful attempts where the AI completed tasks correctly. From these successes, they extracted a library of simple rules. These rules are essentially shortcuts that say, "When the task is to pick up a specific object from a specific place, and the robot is allowed to do so, the action is always X."

The system works by checking these shortcuts before asking the main AI brain for help. When the robot reaches a leaf-level sub-task—a small, final step in its plan—the system first looks to see if a rule in its library matches the current situation. If the rule fits perfectly and there is no ambiguity about which action to take, the system executes the action immediately without calling the large language model. This is what the researchers call "habitual-action grounding." It is similar to how a human might automatically reach for a doorknob without needing to consciously think about the mechanics of turning it, provided the door is unlocked. If the situation is new, complex, or if the rule does not fit perfectly, the system safely falls back to the original method, asking the large language model to plan and translate the action as usual. This ensures that the AI never loses its ability to reason through difficult problems, but it avoids the unnecessary overhead of re-solving simple, routine steps.

The researchers tested this approach in two different simulated environments: a kitchen where a robot must prepare meals, and a home environment where it must organize objects. They used a powerful language model to run the tasks and compared the performance of the standard method against their new shortcut system. The results showed that the shortcut system did not change the success rate; the robots completed just as many tasks as before. However, the efficiency gains were substantial. In the kitchen environment, the system reduced the amount of data the computer had to process by nearly 15 percent on average. In the home environment, the reduction was even higher, reaching over 20 percent. This means the AI agents could complete the same number of successful tasks while using significantly less computing power and time.

Crucially, the researchers found that this improvement was not limited to a single type of robot brain or a specific set of tasks. They tested the system with different models of varying sizes and in different environments, and the savings remained consistent. The study demonstrates that a large portion of the cost in running these advanced AI agents comes not from the complex planning itself, but from the repeated, routine translation of simple thoughts into actions. By distilling these frequent decisions into a small, auditable library of rules, the researchers created a method that is low-risk and easy to integrate. The system remains fully capable of handling unexpected changes and complex reasoning, but it no longer wastes energy re-inventing the wheel for every simple step. This approach offers a practical way to make long-horizon AI agents faster and more efficient without sacrificing their reliability or intelligence.

Technical Summary: HaReCAP – Habitual-action Grounding for Recursive Large Language Model Agents

1. Problem Statement

Long-horizon embodied tasks require Large Language Model (LLM) agents to iteratively decompose goals, revise plans based on environmental feedback, and ground subgoals into executable actions. While frameworks like ReCAP (Recursive Context-Management) improve planning stability through multi-level task decomposition and parent-node refinement, they suffer from a specific inefficiency termed "last-mile grounding redundancy."

In ReCAP, even after high-level planning successfully decomposes a task into a leaf-level subtask (e.g., "pick up onion1 from board1"), the system must still invoke the LLM to translate this natural language subtask into an exact, valid action string (e.g., "Pick up onion1 from board1 using robot1") that matches the environment's current valid-action set. This step requires re-injecting the full recursive context (dialogue history, parent tasks, observations, and JSON schemas) into the LLM for every atomic action. The authors identify this as a substantial, repetitive overhead. In successful trajectories, these strict leaf/action grounding calls account for 23.67% to 45.73% of all LLM calls, representing a stable component of inference cost rather than an incidental edge case.

2. Methodology: HaReCAP

To mitigate this redundancy without disrupting the recursive control flow, the authors propose HaReCAP (Habitual-action Grounded ReCAP). This is a low-intrusion extension that inserts a "leaf-reflex" module at the point of leaf-level action grounding.

Core Components:

Leaf-Reflex Library (Offline Construction): The system extracts frequent leaf decisions from successful ReCAP trajectories. It compiles these into a library of leaf-reflex rules, which are one-step mappings from a canonical leaf task to a canonical action template.
- Canonicalization: Object IDs are normalized to type placeholders (e.g., bread12 $\to$ bread#) to allow rules to generalize across different object instances while preserving word-order structure.
- Constraints: Rules are only extracted from successful trajectories and require explicit object IDs to prevent overly abstract tasks from being compiled.
Runtime Retrieval and Triggering (Online Execution): Before a leaf-level LLM call is made, HaReCAP checks the leaf-reflex library.
- Trigger Condition: A rule triggers only if the current leaf task matches a rule key, the rule's action can be uniquely instantiated from the current valid-action set, and the rule's support count (frequency in successful trajectories) meets a threshold.
- Abstention Mechanism: If no rule matches, if the match is ambiguous (multiple valid actions possible), or if the confidence score is too low, the system abstains and falls back to the original ReCAP leaf LLM call.
- Conflict Resolution: If multiple rules match, a support-derived scoring function determines the winner. If the top candidate does not significantly exceed the second candidate, the system abstains to avoid errors.
Integration: HaReCAP does not alter ReCAP's recursive decomposition, backtracking, or failure-handling logic. It only replaces the final grounding step when a rule is confidently triggered.

3. Key Contributions

The paper outlines four primary contributions:

Identification of Redundancy: The authors identify "last-mile grounding redundancy" as an independently optimizable inference cost in recursive context-management frameworks, distinct from high-level planning costs.
Habitual-Action Grounding: They propose a method to distill frequent successful leaf decisions into abstainable, one-step reflex rules, enabling experience reuse without the risks associated with mid-level macro skills (e.g., incorrect object binding or premature termination).
Conservative Triggering Mechanism: They design a library construction and triggering procedure that ensures habitual actions are executed only when the current subtask can be uniquely grounded to a legal action, maintaining alignment with the original ReCAP control flow.
Empirical Validation: The mechanism is evaluated on Robotouille and ALFWorld, demonstrating reduced token consumption and LLM calls on commonly successful trajectories across different environments and model scales.

4. Experimental Results

The authors evaluated HaReCAP using Qwen3.5-27B, Qwen3.5-9B, and Gemma4-26B on Robotouille (synchronous and asynchronous) and ALFWorld.

Success Rates: HaReCAP maintains end-to-end success rates comparable to the baseline ReCAP, indicating that replacing leaf grounding does not disrupt high-level recursive planning. In some cases (e.g., Qwen3.5-9B on Robotouille), HaReCAP showed slight improvements in success rates.
Token and Call Reduction: On tasks solved by both ReCAP and HaReCAP ("both-success" tasks), HaReCAP significantly reduced costs:
- Robotouille (Qwen3.5-27B): Token consumption reduced by 14.67% (synchronous) and 17.93% (asynchronous) with a support threshold of 2.
- ALFWorld (Qwen3.5-27B): Token consumption reduced by 20.08%.
- Cross-Model: Similar reductions were observed with smaller models (Qwen3.5-9B) and different architectures (Gemma4-26B), with ALFWorld token reductions reaching 21.09% for Gemma4-26B.
Generalization: The results suggest the efficiency gains are not specific to a single task domain (kitchen vs. text-based) or model family, but stem from the general replacement of repeated leaf grounding steps.

5. Significance and Claims

The paper claims that HaReCAP offers a low-intrusion, auditable, and lightweight path to improving the efficiency of long-horizon LLM agents. Its primary significance lies in demonstrating that a portion of the runtime cost in recursive agents comes from repeated, verifiable grounding decisions rather than complex high-level reasoning. By distilling these frequent decisions into local reflexes, HaReCAP reduces token overhead and LLM calls while preserving the reliability of the underlying recursive framework. The authors emphasize that this approach avoids the risks of macro-skill planners (which require complex state management) by strictly limiting the "habitual" component to single-step, uniquely determined actions.