acceptodds
Under review as a conference paper at ICLR 2027

Reversible Evidence-Graph Action Projection for Frozen Language Agents

Abstract

Grounded language-agent systems must act under delayed and reversible evidence, because observations confirm effects only after execution and later interactions can invalidate established facts. Overcoming this difficulty requires an evidence-synchronized action interface backed by transactionally verified and revocable state, rather than fluent reasoning and syntactic executability alone. Planning and reasoning agents are well suited to adaptive decision generation, yet their reliance on textual histories leaves stale and premature actions available when interaction evidence changes, especially in environments that enumerate grounded actions. Within this setting, StructuThink addresses task ordering through transition knowledge, but its task graph is derived from expert refinements and does not revise the environment-supplied feasible set from delayed receipts and revoked support. We therefore propose Reversible Evidence-Graph Action Projection (REGAP), which maintains receipt-gated typed state and revocable evidence to construct a compact, nonempty action interface for a frozen selector, together with guarantees for interface totality, evidence soundness, and conditional path preservation. Experiments on embodied household and scientific-interaction benchmarks show that REGAP substantially improves completion and context efficiency over complete-action, planning, and reasoning baselines.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Large Language Model

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_B5akOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

If I understand correctly, this paper proposes REGAP, which updates the state and restricts the action set presented to a frozen language agent when execution feedback is delayed or existing evidence becomes invalid. Experiments on ALFWorld and ScienceWorld evaluate task completion and token usage, reporting improvements over several baselines.

Critical strengths
  • The high-level ideas introduced in the introduction appear promising, offering the advantage of improving performance without incurring additional LLM calls.
  • The evaluation demonstrates statistical significance, with the proposed method consistently outperforming the baselines.
Critical weaknesses
  • This paper, at least in my reading, has not been prepared with sufficient care to be comprehensible to a human reviewer in this field. While the AI Use Statement asserts that the authors reviewed the content after delegating most of the research to AI, key terminology throughout the manuscript deviates noticeably from standard usage in the community, and many sentences lack precision and clarity. Were this confined to isolated passages, such ambiguities could be resolved through the standard author-reviewer discussion. In its current state, however, I believe the paper requires a fundamental rewrite before meaningful technical engagement is possible. The weaknesses outlined below primarily concern readiness, along with a minor reproducibility issue.

  • The relationship between key terminology and established concepts is unclear. The paper introduces “receipt,” “witness,” “certificate,” “closure,” and “frontier” without sufficiently explaining how they differ from execution feedback, dependencies, condition checks, and task progression. In particular, it is unclear what verifiable information a “certificate” provides beyond a schema-based exclusion indicator.

  • Core operations are insufficiently specified. Section 4 and Algorithm 1 leave receipt recognition, evidence closure, and phase/frontier updates as abstract functions and descriptions, making it difficult to reconstruct the actual procedure. Expressions such as “faithful recognizer” and “current type-consistent closure” describe required correctness properties without adequately specifying the rules that establish them.

  • Several key sentences have ambiguous operational meanings. For example, Section 4.1 states that “A resolved receipt is serialized to its pending request” and that “Destination-sensitive parsing gives terminal destinations precedence over source modifiers,” without concretely explaining request-response matching or parsing precedence. These statements concern implementation-critical behavior, but their inputs, outputs, and applicability conditions remain unclear.

  • The Reproducibility Statement references an anonymous supplement; however, no supplementary material was submitted.

Questions for authors

See weaknesses.

Reviewer_mPzYOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper introduces Reversible Evidence-Graph Action Projection (REGAP). Grounded language-agent systems, such as those that complete tasks in simulated environments, update their memory based on feedback from the environment. REGAP is a framework designed for frozen-model protocols that addresses the challenge of interactions potentially invalidating previously established facts. Specifically, REGAP uses an evidence graph to manage evidence and removes edges when they are invalidated. The entire pipeline is managed using a fixed task-family schema, which includes states and typed roles, receipt recognizers, effect templates, witness precedence, and action families that may satisfy each witness. Experiments on ALFWorld and ScienceWorld demonstrate improved task completion and context efficiency compared to methods including ReflAct-AC and AdaPlanner.

Critical strengths
  1. The motivation and story are reasonable

The motivation to handle invalidate established facts in agent memory is reasonable. The proposed method is directly designed for addressing this challenge.

  1. Efficiency

The experimental result, such as Table 2, shows the large reduction of token usage of the proposed method compared to baseline methods.

Critical weaknesses

The main weaknesses lie in the experimental setup, particularly its reliance on manually designed environment-specific schemas and outdated baseline methods.

First, REGAP appears to rely on environment-specific manual design, but the paper does not provide sufficient details. Specifically, the paper states, "The fixed schema lists typed roles, receipt recognizers, effect templates, witness precedence, and action families that may satisfy each witness" (Line 204). These manually designed components likely encode substantial environment-specific knowledge, but their influence on the performance of REGAP is difficult to assess because the corresponding prompts and implementation details are not provided in the paper.

Second, the compared baselines are methods proposed in 2023. Given that this is an actively studied research topic, comparing against only three-year-old methods is not sufficiently convincing.

Questions for authors
  • How are the fixed schema designed for each environment?

  • Settings of Table 1 is difficult to understand. Why does this table use different comparator for different environments? Why does this table use different LLMs for two ALFWorld environments?

Reviewer_pjCtOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes REGAP, an inference-time controller for frozen language agents. The idea is to distinguish between actions that are executable and actions that are actually feasible given the current verified state. REGAP uses receipt-confirmed effects, reversible evidence, task progress and failure memory, and uses this to reduce the action set before passing it to the language model. I think the core idea is decent and the empirical results are good. I found it interesting that explicitly projecting the action set performs much better than simply giving the language model equivalent structured information while retaining all actions.

Critical strengths
  • Strong empirical results in both success rate and token reduction.
  • The distinction between executable and semantically feasible actions is useful and well motivated.
  • Receipt-gated updates and reversible evidence are sensible mechanisms for avoiding premature or stale state
  • The matched-state and candidate-set controls are useful test and do suggest that the gains are not simply due to fewer actions or more information
  • The method does not require retraining or extra calls from the model.
Critical weaknesses
  1. A large part of the task appears to be encoded in the schema Probably my biggest concern is the amount of task-specific information contained in Γ\Gamma. The schema includes typed roles, receipt recognisers, effect templates, witness precedence, action families, revocation logic amongst other things.

This would require an expert to think very much about the relevant task structure and many of the failure modes that REGAP prevents. In that sense, a big part of the reasoning problem has been moved from the language model into a manually engineered controller, which seems to defeat the purpose.

I do not think using explicit structure is itself a problem. However, the paper should make much clearer how much expert effort is required to construct Γ\Gamma, how this scales to a new task family, and how much of the gain comes from REGAP versus the prior knowledge encoded in the schema. An ablation on the context would be very useful. This also affects baseline fairness, since REGAP receives structured task information that several baselines do not.

  1. The theory relies on strong assumptions, however, they have not been really tested in practice The guarantees assume faithful receipt recognition, correct effect compilation, correct typed bindings and result recognition, a correct witness schema, and availability of the required actions. Under these assumptions, the guarantees are reasonable, but they are also quite conditional. The more interesting practical question is what happens when these components are slightly wrong, which will probably happen most of the time in practice.

This is especially important because REGAP is an exclusion mechanism. If it makes an incorrect inference, it may remove the correct action from the interface. I would therefore like to see two simple stress tests:

  • receipt corruption: delay, drop or misclassify receipts at increasing rates;
  • schema misspecification: perturb a small fraction of prerequisite relations or action-family rules. For both, I would report not only task success, but also how often REGAP incorrectly removes an action that would make progress.
  1. The assumption that AtA_t can be enumerated is a significant limitation REGAP assumes that a candidate action set already exists and can only remove actions from it.

This is natural in ALFworld and ScienceWorld, but much less natural in realistic agent settings where actions may have open-ended textual, combinatorial or continuous arguments. In those cases, an upstream candidate generator is needed, and if the correct action never enters AtA_t, REGAP cannot recover it. I think this limits the generality and deployability of the method more than the paper currently acknowledges.

  1. Novelty and positioning I was surprised by the limited positioning relative to formal planner/verifier approaches, runtime enforcement, shielding and action elimination. I do not think this means REGAP has no novelty, but the paper should make clearer what is new beyond combining structured runtime constraints, transactional state and action filtering.

Also, StructuThink and KnowAgent receive a lot of attention in the introduction but are not experimentally compared.

Additional comments:

  • The paper is quite dense. The underlying idea is relatively simple, but there are many terms for closely related objects, and the abstract and introduction are harder to follow than necessary.
  • I would also like to see one concrete schema and one worked example episode in the main paper.
  • Finally, most experiments use relatively small models and relatively structured tasks. The QwQ-32B result is useful, but it is still unclear whether the gains persist with substantially stronger models and harder/open-ended tasks.
Questions for authors
  1. How much human effort is required to construct GammaGamma for a new task family?
  2. Can the authors separate more clearly the benefit of the extra structured information from the benefit of the REGAP mechanism itself?
  3. How robust is REGAP to incorrect receipts and schema misspecification?
  4. How would the method operate when the action set is not naturally enumerable?
  5. Does REGAP hold with larger models and more complicated tasks?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.