acceptodds
Under review as a conference paper at ICLR 2027

Neuro-Symbolic Anchored Governance for Alleviating Action-Level Hallucinations in Large Language Model Agents

Abstract

Large Language Model (LLM) agents frequently suffer from action-level hallucinations. Unlike traditional hallucinations that appear as factual inconsistencies in text generation, action-level hallucinations involve proposing actions that are semantically plausible but violate environment-specific feasibility or procedural constraints. Probabilistic generation alone does not ensure action legality, and violation risks can compound over long action sequences. Explicit checks identify violations, but agents must also determine when to intervene and how to recover. To address this, we propose Neuro-Symbolic Anchored Governance (NSAG), a framework that externalizes rule enforcement from the LLM to a symbolic execution interface. NSAG selects task-relevant rules and learns to calibrate intervention using symbolic violation signals. To resume execution when an action is blocked, we introduce MinFix, a search-based repair operator that seeks a minimal executable sequence satisfying the action's missing preconditions while preserving high-level intent. We develop and release Town-Benchmark with 1,000 task instances across five domains and evaluate NSAG on Town-Benchmark and ScienceWorld. NSAG outperforms state-of-the-art baselines in hallucination mitigation and task performance, with consistent gains across LLM backbones and low inference overhead. The reductions are empirical, and the calibration is fitted on the same five domains it is evaluated on. The open environment and code are available at https://anonymous.4open.science/r/NSAG/.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Neuro-Symbolic & Hybrid AI Systems, LLM Agents, Action-Level Hallucination, Runtime Safety Enforcement, Symbolic Planning and Repair, Benchmarks and Datasets

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_mZT9OpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes a new dataset: Town-benchmark. They demonstrate on this benchmark that augmenting an LLM agent with predefined rules for an environment can significantly improve the agent's performance and reduce rule violation rates. To efficiently use the rules, they propose "MinFix", which finds the shortest action sequences that fix the missing predicates. Additional experiments are performed on a subset of ScienceWorld.

Critical strengths
  1. The experiments show that the method achieves a much better result comparing to the baseline.
  2. The idea is simple and clear.
Critical weaknesses
  1. The design of the method is not fully supported by the experiments. For example, since it's possible to find the shortest action sequences to fix the missing predicates, why not use a rule-based planner from the beginning? (That is, why do we need an agent?) Another example is, the paper uses a neural network to filter the rules to consider, but it should be very cheap to simply try all the rules to see whether they apply or not.
  2. I think the impact of this paper will be limited by the fact that the rules need to be predefined instead of learned by the agent.
Questions for authors
  1. See weakness 1.
  2. Could the authors clarify the paper's relationship to learned symbolic and neuro-symbolic world models, such as WorldCoder (Tang et al., 2024) and NeSyS (Zhao et al., 2026)?
3 comments
AuthorsOpenReview ↗

Response to mZT9: why an agent, and how NSAG relates to learned world models

We thank the reviewer for the two direct questions and for the pointer to the world-model literature.

W1. Why not a rule-based planner.

A planner needs a complete action model, a goal written in its language and a state estimate, and in the environments we target none of the three is available. The goal arrives as free text and the constraints live in documents written for people, so there is no domain file for the planner to take as input. Turning that instruction into a concrete action is what the LLM does, and judging the resulting action is what the symbolic layer does.

That file is the expensive part, since every action needs its preconditions and effects, every object a type, every fluent a declaration and the goal a translation, and where the rules live in documents it does not exist at all. ScienceWorld exposes 61 preconditions and only 38 of them are registrable, so the rest would have to be invented before a planner could use them.

Because the action is already given, the repair only has to close a precondition gap at that step, and since the search is bounded by the blocked action rather than by the horizon, a depth limit of 5 and 2,000 expansions find a bridge in 96.8% of the 312 blocked steps.

Q. WorldCoder and NeSyS.

WorldCoder (Tang et al., 2024)NeSyS (Zhao et al., 2026)NSAG
World modelPython program written and revised by the LLMneural model and symbolic rules trained in alternationgiven by the environment
Role of rulesthe program is the modelrerank candidate transitionsjudge each action
Decisionsearch over the learned modelimprove the model for one-step lookaheadlocal bridge for the blocked step
When it actsevery planning steptraining and predictionat execution, step by step
What is learnedthe transition function, as codemodel parameters and rule coveragepjp_j, wjw_j, γ\gamma, τ\tau
Reliance on a registrynoneweak, rules are soft signalsstrong, gaps are blind spots

The two systems learn or train a world model, whereas NSAG assumes the model and governs the step, so the lines compose rather than compete, because a learned program is the kind of object the repair search takes as input and a model trained against rules proposes fewer violations for the guard to catch.

Thanks for the author's response. For W1, I'm still a little confused. If you do not assume the domain file, how can you know what preconditions are missing for a given action? How can you plan for fixing the missing preconditions without these domain knowledge?

Our phrasing caused the confusion, and it is worth correcting: we do assume a model. What we do not assume is a planning domain.

The model has two parts. For each registered action the registry carries a predicate that decides legality and names the conjunct that fails, and these rules are drafted by the LLM from the environment specification and registered only after being checked against the environment's own validity checks. ScienceWorld makes this concrete, since it exposes 61 preconditions as explicit validity checks and 38 of them can be registered as predicates. A transition function supplies the successor state the search needs to evaluate a candidate bridge.

What a planner needs in addition is the task goal written in its language, together with a typed domain that covers every action and object. In our environments the goal arrives as free text, so that input does not exist. NSAG does not need it, because the repair target is not the goal but the preconditions of the action the model has just proposed. This is also why the search stays local: depth 5 and 2,000 expansions close 96.8% of the 312 blocked steps, whereas a planner would have to search the whole task.

Reviewer_q7duOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
3(+1)
Presentation
3
Soundness
3
Read review
Paper summary

The paper presents titled as NSAG, an execution-time framework that combines task-conditioned rule selection, learned intervention calibration, and search-based repair of infeasible actions. The problem is practically useful, and evaluating task completion alongside constraint violations is a sensible choice: an agent that avoids errors by stopping immediately is not necessarily useful. The base-task-level data split and the experiments with incomplete or incorrect rules are also welcome. However, I still have concerns about the novelty of the formulation, the consistency of the mathematical description, and whether the experiments isolate the contribution of the learned components.

Critical strengths

The idea of neuro symbolic framework in mitigating action level hallucination have some degree of novelty.

Evaluating task completion alongside constraint violations is sensible.

The base-task-level data split and the experiments with incomplete or incorrect rules is carefully designed.

Critical weaknesses

1 The distinction from existing grounded planning and runtime enforcement is not sufficiently established. The central problem focus on an action being linguistically plausible but infeasible in the current environment has been studied extensively in grounded planning. SayCan, ProgPrompt, and LLM+P address related gaps between language-generated plans and executable actions, while AgentSpec provides external runtime enforcement. These approaches differ from NSAG, but their existence makes it difficult to regard externalizing constraint enforcement as a substantial conceptual contribution. 2 The paper should identify more precisely what is gained by its particular combination of calibration and local repair. There is also a mismatch between the verbal definition of action-level hallucination and its operationalization. Equation (2) treats any registered constraint violation, including a soft preference violation, as hallucination, without separately establishing semantic plausibility or alignment with the high-level goal. As measured, the phenomenon appears closer to constraint violation than to a clearly distinguished class of hallucination. 3 The guard equations do not readily explain the reported precision and recall. Under the stated definitions, a clean action has (h_t=0), implying that every registered rule is satisfied. Equations (4)–(6) therefore give (v_{t,j}=0) for all active rules and (E_t=0). Since the energy is non-negative and inference intervenes exactly when (E_t>\gamma), a fixed guard with (\gamma\geq0) cannot produce false positives. Conversely, if (\gamma<0), it intervenes on every action and cannot produce false negatives. Under the same checker, state, and fixed global threshold, this is difficult to reconcile with the simultaneous precision of 0.94 and recall of 0.91 reported in Table 7. Also Please clarify whether evaluation uses sampled interventions, different reference labels or states, or another decision mechanism absent from the equations. The interpretation following Equation (20) also needs correction. On a clean step, all (v_{t,j}) are zero, so that step contributes no gradient to (w_j). It therefore cannot lower the rule sensitivities in the manner described, although it can affect the tolerance parameter. 4 The treatment of rejected actions and execution steps is ambiguous. The environment definition states that infeasible actions are rejected and not executed, and that the transition function is defined for executable actions. However, the rollout preceding Equation (4) applies (T(s_{t-1},u_t)) to candidate actions, including potentially infeasible ones. The transition following rejection needs to be defined explicitly. 5 This also affects the evaluation. Section 5.1 describes violation rates over executed steps, but rejected illegal actions are said not to be executed. If the registered hard constraints exactly match executability, successfully executed actions should have no hard-constraint violations. Please distinguish proposed actions, attempted actions, rejected actions, and repair actions, and specify the denominator used for each metric. Reporting violations per task and the fraction of tasks containing any violation would also help, since inserted legal repair actions can reduce a step-normalized violation rate by increasing its denominator. 6 The experiments do not fully establish why learned calibration is needed. Once exact symbolic violation signals are available, an important baseline is exhaustive rule checking with deterministic intervention on any hard violation, followed by exactly the same MinFix procedure. The “without calibration” ablation retains the predicted active set and uses uniform weighting, so it does not answer this question. Likewise, because the rule predictor receives only a task-category embedding, it should be compared with a simple category-to-rule lookup table. 7 The MinFix ablation is somewhat limited: terminating at the first blocked action naturally reduces completion. The gap between 68% and 99% demonstrates the importance of recovery under that protocol but does not establish the advantage of MinFix over alternative recovery or replanning strategies.

Questions for authors

Given that Equation (10) retains the original action whenever (b_t=0), and the learned gate can miss hard violations, how do the authors reconcile Section 4.3’s statement that the resulting sequence contains no step refused by the environment with Appendix I’s acknowledgment of such failures? Should this statement apply only to successfully repaired steps?

After repair actions are inserted, how are the original-plan index and the execution-step index distinguished, and which updated state is used to evaluate each subsequent proposal?

To what extent does the ScienceWorld evaluation support broader generalization, given that it covers only six of thirty task types, twelve episodes, and 38 of 61 preconditions? How were these tasks and preconditions selected?

Since calibration is fitted and evaluated within the same five Town-Benchmark domains, what evidence supports generalization to unseen task categories?

How should the low-overhead claim be interpreted when a default repair takes approximately 16.55 seconds, increasing to approximately 106 seconds with 500 registered action types? Would the method remain efficient with faster LLM backbones or applications requiring shorter response times?

How much incremental wall-clock latency is attributable to rule selection, checking, and repair under matched execution conditions, given that the reported comparison between symbolic CPU time and end-to-end wall-clock time does not directly isolate this overhead?

2 comments
AuthorsOpenReview ↗

Response to q7du

We thank the reviewer for this detailed reading.

W1. Grounded planning and runtime enforcement.

SystemRule sourceAfter a violationTransition modelLearns when to intervene
SayCan (Ahn et al., 2022)fixed skill librarypicks another skillnono
ProgPrompt (Singh et al., 2023)hand-written assertionsassertion fails, regeneratenono
LLM+P (Liu et al., 2023)hand-written PDDL domainnone, a wrong model voids the planyes (planner)no
AgentSpec (Wang et al., 2025)hand-written DSLstop, inspect, self-examine, correctnono
NSAGLLM-drafted, verifiedlocal repairyes (A* bridge)yes (wj,γ,τw_j,\gamma,\tau)

Only NSAG learns when to intervene and then repairs the blocked step, whereas the other four stop, reject or hand control back to the model. Because the repair is scoped by the blocked step rather than by the task horizon, a depth limit of five suffices.

W2–W5. We thank the reviewer for these four points. The definitions we printed were not incorrect, but they were compact enough that the quantities they refer to could not be determined from them alone, and the reviewer's reading exposes exactly that gap. We prefer the stricter reading. The decision rule, the transition after a refusal and the violation rate now have explicit definitions, and the affected tables will be recomputed and the corrected version uploaded.

W6. Why learned calibration.

Once exact symbolic violations are available, the natural baseline is to check every registered hard rule, intervene on any violation and then repair. The w/o calibration row is not that baseline, since it keeps the predicted active set and only replaces the learned weights with a uniform one, which leaves the question open. The exhaustive variant will be added.

The two regimes are already measured by the removal and induced-rule studies. Where entries are missing or wrongly scoped, a guard that treats every entry as applicable blocks legal actions, and the cost appears in completion rather than in the violation rate.

The predictor sees only the category embedding, so a category-to-rule lookup table is the right control, and it will be added.

W7. The MinFix ablation.

Ending the episode at the first blocked step lowers completion by construction, so the gap between 0.68 and 0.99 measures the value of recovery under this protocol rather than the advantage of one recovery strategy over another.

Q1. The sentence in Section 4.3 was too strong and will be replaced. In the corrected version, a blocked step is either repaired before execution or ends the episode, while a violation the gate misses is not blocked at all, so it reaches the environment, is refused and costs a retry.

Q2. With Δt\Delta_t the bridge at proposal tt, empty when nothing is blocked, execution runs Δ1,u1,Δ2,u2,…\Delta_1,u_1,\Delta_2,u_2,\dots, so utu_t lands at execution index τt=∑s<t(∣Δs∣+1)+1\tau_t=\sum_{s<t}(|\Delta_s|+1)+1, and proposal tt is evaluated at the state reached by the rectified prefix rather than at the original rollout, as will be stated in Appendix B.5.

Q3. The 38 predicates are the preconditions the simulator exposes as explicit validity checks, while the other 23 are implicit and cannot be registered. The six task types are those with completely registrable precondition sets, and the revision will run all 30.

Q4. Because the calibration is fitted per environment, the method is not designed for zero-shot transfer to a new scenario, and we state that requirement rather than claim unseen-category generalization.

Q5. The claim is relative. Per instance NSAG spends 190k tokens and 1507 s against 200k and 1567 s for direct generation, because the symbolic work replaces the re-planning calls that refusals would otherwise cost. One repair costs 16.55 s, from 47.3 expansions at about 350 ms each, and roughly 106 s at ∣A∣=500|\mathcal{A}|=500, so the symbolic share rises as the backbone gets faster.

Q6. Under matched execution the split is:

ComponentPer occurrencePer instanceShare
Rule selectionunder 1 ms per episodenegligibleabout 0
Checking and replay42 ms per step, 42 steps1.76 s0.1%
Repair16.55 s, 2.2 per episode36.4 s2.4%
Backbone generation1468.8 s97.5%

The symbolic rows add up to the 38.6 s of Section 5.2 within rounding.

Reviewer_q7duOpenReview ↗

Most of the concernt settled

Thanks for your comments, with the most of my concerns settled, I will reconsider some of my scores.

Reviewer_mR45OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces Neuro-Symbolic Anchored Governance (NSAG), a framework intended to reduce action-level hallucinations in LLM agents. It combines three principal comments. The authors also introduce Town-Benchmark, which contains 1000 instances across five domains. They evaluate their framework on Town-Benchmark and ScienceWorld, demonstrating task completion and hard-constraint violation improvements.

Critical strengths
  • NSAG shows strong improvements on action reliability and task completion compared to many baselines and direct generation. These improvements are not limited to only reducing violations but also improves task completion. I like that the authors report inference costs as well, which helps justify the practicality of the approach.
  • I appreciate that the authors report useful ablations and robustness analyses. For example, they are able to separate the contributions of learned calibration and the repair mechanism, rather than treating NSAG as a single indivisible system. They also evaluate sensitivity of the approach to missing or incorrect constraints, action-space size, and perturbations in the environments. This helps identity the conditions and situations under which the approach works well or not.
Critical weaknesses

I think there are a couple of important weaknesses which make me lean towards rejection:

  1. There is a missing comparison against a simpler full symbolic guard with the same repair mechniams. Basically, the main framework relies on exact symbolic checks and a search-based repair mechanism. However, the authors to not clearly establish if the learned intervention calibration is better than simply checking every relevant hard constraint deterministically and using the repair mechanism when necessary. The authors' uniform-calibration ablation is useful but not equal to exhaustive hard-rule enforcement with the same repair mech. Without this comparison, I believe that it is difficult to determine how much of the proposed framework's value comes from its novel learned components rather than simply conventional symbolic checking and repair.

  2. Further, the overall evaluation relies quite heavily on complete, manually-specified environment knowledge. Town-Benchmark assumes fully observable and deterministic transitions with explicitly specified constraints. Further, NSAG depends on the correctness and coverage of its symbolic registry. Its external validation only covers a subset of ScienceWorld tasks and conditions. Further, the learned calibration is fitted on the same five Town_benchmark domains used for evaluation. Unfortunately, I feel that these assumptions quite heavily limit the generality of the proposed method and its improvements, particularly for real-world LLM agents operating in environments that may have incomplete or changing rules.

Questions for authors
  1. How does NSAG compare against an exhaustive symbolic guard, as I mentioned in the first weakness above?

  2. How are the learned calibration and rule-selection parameters applied when transferring from Town-Benchmark to ScienceWorld, as both contain quite different preconditions? Are any parameters retrained or adapted?

  3. Can you clarify how illegal actions that are proposed but blocked before execution contribute to the reported hallucination and violation rates? Further, uncertainty estimates for the key comparisons across the 5 evaluation seeds would be helpful.

As an aside, there is recent relevant work: Liu et al. (2026), "A Unified Definition of Hallucination" (https://arxiv.org/abs/2512.21577) and "HalluWorld" (https://arxiv.org/abs/2605.19341), that may be worth reading and potentially citing, since they provide a useful framework for distinguishing hallucinations from general planning or constraint violations, and controlled ways to study hallucinations defined as world-model errors.

1 comment
AuthorsOpenReview ↗

Response to mR45: the learned layer and what the benchmark measures

We thank the reviewer for the careful reading and for the credit given to the ablation and robustness studies.

W1. A full symbolic guard with the same repair.

Action-level hallucination is the case in which a plan is semantically coherent and each step still cannot be executed in the state the agent is in. Neither a language model nor a symbolic checker handles it alone. A model generalises across instructions and observations, but its decoding carries no representation of what the current state permits, so an inadmissible step keeps being proposed and the errors accumulate over the episode. A checker is exact, but it enforces only the rules someone has written down, and each rule needs its applicability condition encoded by hand, which is why a hand-built rule base does not carry over to environments whose constraints live in documents rather than in a specification.

The two layers then cover different failures. The model supplies what the rule base cannot, since mapping an open-vocabulary instruction onto a concrete action requires a generalisation that no fixed rule set provides. The checker supplies what the model cannot, since admissibility in the current state is a property that the act of decoding does not represent. The calibration sits between them and decides which rules are relevant to the category and where the intervention boundary lies.

Repair covers the failure that neither layer addresses, namely that a correct negative verdict leaves the plan with nowhere to go. MinFix closes the missing precondition and returns the model's remaining plan to execution. With the same detector, ending the episode at the first blocked step reaches 0.68 completion against 0.99 with repair (Table 7), at nearly the same violation rate.

The ablation the reviewer cites tests only the middle term, since w/o calibration keeps the active set and replaces the learned weights with a uniform one while the checking stays in place. We will add the baseline the reviewer describes, in which any violated hard rule triggers an intervention followed by the same MinFix, so that the comparison covers the checking as well.

W2. Complete, manually specified knowledge.

The second point reads two assumptions as one. Full observability, deterministic transitions and explicit constraints are properties of the instrument rather than of the method, since an exact violation label requires the ground-truth precondition of every action and that is definable only in an instrumented environment. The benchmark exists to make the phenomenon measurable, not to claim that agents should be deployed in fully observable worlds.

The method assumes a registry and a transition model, neither of which is an observability assumption, since under partial observability the guard reads the observation it is given while the repair searches the model it has. Appendix G perturbs exactly these assumptions, and the layer degrades rather than fails, holding 0.94, 0.92 and 0.90 completion at α=0.5\alpha=0.5, β=0.2\beta=0.2 and γ=0.25\gamma=0.25 with the hard-violation rate near 0.011.

Nor are the rules transcribed by hand, since they are drafted by the LLM from the environment specification and then verified against the environment's own validity checks, and on ScienceWorld the predicates are read off the 38 preconditions the simulator exposes. A deployed registry is maintained by the team that runs the agent, which is why the layer is built to keep working while the registry is imperfect.

On transfer (Q2), the registry is rewritten for the target environment, 38 of 61 preconditions, and the calibration is refitted there. The evaluation will cover all 30 task types, with coverage per type in Table 2.

Q3. Blocked actions.

A proposed action is what the backbone decodes, an attempted action is one submitted to the environment, and a refused action is one the environment rejects, which leaves the state unchanged and spends one of the twenty retries. A repair action is inserted by MinFix and is legal by construction.

A proposal is scored against the state that precedes it, so an illegal action blocked before execution counts as a violation at the step where it was proposed and is charged to the method in the call and latency columns. The executed-step denominator counts accepted actions only, and because inserted repairs enlarge that count we also report violations per task and the fraction of tasks containing one.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.