## Problem
When executing tasks, agents often follow a fixed, step-by-step workflow. However, many of these steps are redundant—for example, rechecking information when the answer is already known, or performing checks that are unnecessary under specific conditions.
Consider a customer service agent handling a user request. The user says, "I want to return an item," and the agent’s standard workflow is:
1. Understand the user’s need
2. Recommend relevant products
3. Check the return policy
4. Process the return request
5. Confirm logistics information
6. Send a confirmation email
But step 2 (product recommendation) is entirely unnecessary in this scenario—the user has explicitly stated their intent to return an item, not to shop. If the agent rigidly follows the full workflow, it wastes time and may frustrate the user.
## LEAP’s Adaptive Solution
LEAP (Learn to Skip Unnecessary Steps) proposes an adaptive step-selection mechanism that enables agents to dynamically decide whether to execute a given step based on the current context.
The core idea is: not all steps must be executed; agents should make decisions based on current state, task type, and historical experience.
Traditional workflow: Step 1 → Step 2 → Step 3 → ... → Completion
LEAP workflow: Step 1 → [Is Step 2 needed?] → Skip/Execute → [Is Step 3 needed?] → ...
## Three Key Technologies
**1. Step Value Assessment**
Each step is assigned a "value score" indicating its contribution to the final outcome. This score is not static but dynamically adjusted based on context.
High-value steps (e.g., understanding user intent, verifying critical information) must be executed—skipping them risks errors. Low-value steps (e.g., formatting output that is already formatted, rechecking information already verified) can be skipped because executing them yields no additional benefit.
Value scores are learned from historical execution data. For instance, if a step had no impact on outcomes in 95 out of the last 100 executions, its value score will be low.
**2. Skip Decision Network**
A small neural network decides whether to skip a given step. Its inputs include:
- Current state (what the user said, how far the task has progressed)
- Step type (information extraction, reasoning, formatting, verification)
- Historical execution records (whether this step was typically skipped or executed in similar situations)
Its output is a skip probability (a value between 0 and 1). If the probability exceeds a threshold (e.g., 0.8), the step is skipped.
The threshold is adjustable: conservative mode (threshold = 0.9) skips fewer steps and suits critical tasks; aggressive mode (threshold = 0.6) skips more steps and suits simple tasks.
**3. Safe Fallback Mechanism**
Skipping a step is not permanent—steps can be re-executed if issues arise. This is a key design feature of LEAP.
If skipping a step later leads to insufficient information or degraded result quality, the system automatically re-executes the skipped step. For example, if the "check return policy" step is skipped but the return processing later reveals the user’s case violates policy, the system falls back and executes that step.
Meanwhile, the system logs the consequences of each skip decision. If skipping a particular step causes problems, the skip probability for that step decreases the next time a similar situation arises—a continuous learning process.
Users can also designate certain steps as "never skip" (e.g., steps involving payments or sensitive information), which must be executed regardless of how low their value score is.
## Experimental Validation
The research team tested LEAP across multiple agent tasks:
- **Task completion speed improved by 35–50%**: due to skipping unnecessary steps and reducing processing time.
- **Token usage reduced by 25–40%**: because reasoning and output generation are no longer required for every step.
- **Result quality degradation was less than 3%**: thanks to the safe fallback mechanism, most quality issues were promptly detected and corrected.
## Real-World Application Scenarios
**Customer Service Agent**:
- User says "I want to return an item" → directly jump to the return process, skipping "recommend products"
- User says "I’d like to see your products" → execute the recommendation flow, skipping return-policy checks
**Code Assistant**:
- User requests "fix this bug" → skip code-style checks and go straight to bug localization
- User requests "refactor this code" → execute the full code analysis and optimization pipeline
**Personal Assistant**:
- User asks "What’s the weather today?" → skip complex reasoning steps and directly query the weather API
- User requests "Help me plan a trip" → execute the full planning pipeline, including transportation, accommodation, and attractions
## Implications for Holon
LEAP offers direct applicability to Holon:
For simple queries (e.g., "What’s the weather today?", "What time is it?")—skip complex reasoning steps and return results directly. For complex tasks (e.g., "Help me plan a trip", "Analyze this report")—execute the full planning pipeline.
With continued use, the agent learns which steps can be safely skipped. For example, if users consistently issue clear, direct commands, the agent can skip the "clarify requirements" step; if users frequently provide vague descriptions, that step becomes mandatory.
This approach makes agents more efficient while preserving result quality. Users won’t experience excessive wait times, and agents won’t err due to oversimplification.
Source: arXiv:2611.12847