As Expected? Efficient LLM Planning via Expectation-Observation Consistency Verification

Qingfu Zhu, Huanyang Zheng, Ting Liu, Wanxiang ChearXiv 2026 · arXiv

TL;DR

The researchers introduce Expectation–Observation Consistency Verification (EOCV), a mechanism that allows LLMs to plan in efficient "batches" without losing the robustness of step-by-step feedback. By predicting what should happen after an action and verifying it against reality, EOCV achieves performance comparable to standard reactive methods while reducing inference costs by 29–35%.

What Problem Does This Paper Address?

LLM-based agents typically follow one of two execution paradigms:

  1. Reactive Executors (e.g., ReAct): These generate one action at a time, wait for environment feedback, and then decide the next step. While highly grounded and robust, they are incredibly slow and expensive because the model must re-process the entire interaction history for every single action.
  2. Batched Executors: These generate a sequence of actions in one go. This is much faster and cheaper, but it’s "blind"—if the first action fails or has an unexpected result, the rest of the batch becomes a "hallucinated" sequence of errors.

This paper tackles the efficiency-robustness trade-off. How can we get the speed of batching with the safety of step-by-step grounding?

Figure 1: Executor paradigms for LLM planning. Given the query “Put apple in fridge” and initial observation O1: “The fridge is closed. You have an apple”, the reac- tive executor remains grounded but inefficient, whereas the batched executor is efficient but error-prone. Ours verifies expectations against observations to continue or replan batched actions selectively. Intermediate reason- ing steps are omitted for clarity.

Methods

The core idea of EOCV is to augment batched actions with explicit expectations.

  • Expectation Generation: When the LLM generates a batch of actions, it also generates a concise textual description of the anticipated outcome for each (e.g., "The fridge should be open").
  • Step-wise Verification: During execution, a verifier compares the actual environment observation to the expectation.
  • For text, it uses embedding similarity (cosine similarity).
  • For visuals, it uses a Vision-Language Model (VLM) to judge consistency.
  • Early Termination: If the observation matches the expectation, execution continues within the batch. If there is a mismatch, the agent immediately terminates the batch and replans from the current state, preventing compounding errors.
  • Expectation Skipping: The authors identify that "information-seeking" actions (like look or examine) have inherently unpredictable outcomes. EOCV automatically skips verification for these to save tokens and avoid false alarms.
Figure 2: An overview of EOCV. The executor generates future action batches with expectations, executes them sequentially, and verifies expectations against the resulting observations. Consistency permits continued execution within the batch, whereas a mismatch triggers early termination and replanning from the latest observation.

Datasets

The authors evaluated EOCV across three diverse benchmarks:

  • ALFWorld: A text-based environment for household tasks requiring multi-step reasoning.
  • ScienceWorld: A complex text-based benchmark for science experiments (e.g., "make sugar water") with long-horizon planning.
  • EB-Habitat: A multimodal benchmark where agents operate in 3D environments using visual (image) observations.

Key Insights and Ideas

  • Semantic Verification is Sufficient: You don't need a perfect world model to verify a plan. Comparing natural language expectations to observations is a "good enough" proxy that works across both text and image modalities.
  • Model-Agnostic Utility: EOCV isn't a new model; it's a wrapper. It was tested on various backbones (Qwen, DeepSeek, GPT-4) and integrated into SOTA planners like ReflAct, MPO, and Reflexion, showing consistent gains regardless of the high-level controller.
  • Where the Savings Come From: Most token savings don't just come from fewer API calls, but from reducing the "internal reasoning" (RT) tokens that reactive models generate at every single step.

Key Results

The results show that EOCV provides a "free lunch" in terms of efficiency:

  • Efficiency: EOCV reduced average weighted token usage by 29–35% across all benchmarks. In local deployments, wall-clock time dropped to roughly 0.6x of the reactive baseline.
  • Performance: Task success (reward) remained broadly comparable to the robust but slow reactive executors, significantly outperforming "naive" batched executors which often fell into error loops.
  • Comparison to AdaPlanner: EOCV achieved higher rewards with fewer tokens than AdaPlanner on ALFWorld, largely because EOCV operates at the action level rather than the subgoal level.
Figure 6: Summary of average executor results across benchmarks.

Limitations and Future Work

  • Irreversible Actions: Like all "receding horizon" planners, EOCV can only stop future actions in a batch. If an action has an irreversible negative effect (e.g., breaking a glass), EOCV can detect it but cannot undo it.
  • Verifier Reliability: While generally accurate, the verifier can occasionally fail (e.g., a 64.7% accuracy on "Hard" visual cases in EB-Habitat). However, the authors note that the iterative loop often allows the agent to recover from these individual verification errors in subsequent steps.
  • Future Directions: The authors suggest that adding mechanisms to evaluate action consequences before execution (rather than just verifying after) could further improve safety.

Summary updated

Abstract

LLM planning often relies on reactive executors (e.g., ReAct) that generate a single action at each step to remain grounded in the latest observations, incurring substantial inference cost. Batched executors reduce this cost by predicting multiple actions in a single model invocation, yet they are prone to compounding errors, as intermediate observations are ignored. We propose an expectation-observation consistency verification (EOCV) mechanism for batched executors, preserving grounding while improving efficiency. The mechanism generates expectations of action outcomes and compares them with the resulting observations. Consistency permits continued execution, whereas mismatches trigger early termination and replanning from the current observation. Experiments on text-based and multimodal benchmarks across multiple backbones show broadly comparable average task performance between EOCV and reactive executors, with a 29-35% reduction in average weighted token usage. Moreover, the mechanism is model-agnostic and remains effective when integrated into state-of-the-art planners.
BibTeX
@misc{zhu2026as,
  author = {Qingfu Zhu and Huanyang Zheng and Ting Liu and Wanxiang Che},
  title = {{As Expected? Efficient LLM Planning via Expectation-Observation Consistency Verification}},
  year = {2026},
  eprint = {2611.02438},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.02438},
}
Figure