Consistency-guided Epistemic Refinement

• Consistency-guided Epistemic State Refinement (CG-ESR) is a mechanism that converts discrepancies between a planner’s raw and consistency-based plan choices into persistent epistemic constraints.
• It employs cross-agent evaluations and a memory update process to dynamically recalibrate planning under changing information and minimize epistemic miscalibration.
• Empirical results demonstrate that integrating CG-ESR with IPS can improve system-level success by up to 11% on dynamic, search-intensive tasks.

Consistency-guided Epistemic State Refinement, abbreviated CG-ESR and also called CESR, is a cross-round calibration mechanism for LLM-based multi-agent planning in which discrepancies between a Planner’s raw plan choice and an information-consistency-based plan choice are converted into persistent epistemic constraints that update the Planner’s private memory. In the formulation introduced within the Epistemic Planning Calibration Agentic Workflow (EPC-AW), the target problem is epistemic miscalibration in planning: agents may misjudge their knowledge when evaluating plan feasibility, even when planned actions are executed correctly, and the miscalibration is both latent during planning and dynamic under changing information. CG-ESR therefore refines the Planner’s epistemic state over time by leveraging past discrepancies to guide future planning rather than directly verifying feasibility (Wang et al., 22 May 2026).

1. Conceptual background and scope

A broad semantic backdrop for CG-ESR is the study of epistemic and ontic change in dynamic epistemic logic. Semantic work on epistemic logic with dynamic operators distinguishes epistemic changes, in which agents become more informed about a non-changing world, from ontic changes, in which the world itself changes; such events are executed in information states modeled as pointed Kripke models. Within that setting, one result states that, given two information states, there is an event transforming one into the other, and that every consistent formula can be made true in every information state by the execution of an event [0610093].

A second relevant backdrop is private update synthesis in multi-agent systems. In update synthesis via privatized beliefs, a goal formula is compiled into an action model that makes the goal formula true, maintains consistency of agents’ beliefs, if possible, and avoids causing “unrelated” beliefs, characterized as minimal change. The associated pointed update operation keeps only the subset of world-event pairs that are reachable from the point, thereby avoiding unnecessary model blow-up (Schlögl et al., 2024).

A third backdrop comes from epistemic readings of consistency conditions in closed timelike curve models. In that setting, directly imposing a fixed-point condition on an epistemic mixed state can leave the observer’s knowledge unchanged while there is no underlying ontic solution; an alternative refinement procedure prunes the support of the epistemic distribution to ontic fixed points, renormalizes, and may apply a maximum-entropy rule within the fixed-point set (Wallman et al., 2010).

This suggests that CG-ESR belongs to a broader class of consistency-preserving update mechanisms in which an epistemic state is not merely stored but actively transformed under structural constraints, memory, and minimal-change requirements.

2. Formalization in EPC-AW

In the EPC-AW formulation, let $\Omega$ be the hidden space of true world-states relevant to the task. Agent $i$’s epistemic state at round $t$ is a belief distribution

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$

or, equivalently, an information context $I_i^t$ from which $b_i^t$ is induced. The system does not materialize $\Omega$ directly. Instead, it maintains a shared system memory $M_{\mathrm{sys}}^t$ containing the query $Q$, verified evidence $V^t$, and role descriptions $i$0, together with a private memory $i$1 for each agent $i$2, where $i$3 is the Planner, $i$4 the Executor, and $i$5 the Diagnoser. The resulting information state is

$i$6

At round $i$7, the Planner generates a finite candidate set of plans

$i$8

where each $i$9 pairs an intermediate goal $t$0 with a tool-based action $t$1. The Planner’s self-assessment of plan feasibility is

$t$2

with $t$3 an abstract judgment function (Wang et al., 22 May 2026).

The cross-agent consistency signal used upstream of refinement is defined through predicted peer evaluations. Each agent $t$4 predicts how other agents $t$5 would score plan $t$6 under their information states:

$t$7

The aggregate prediction is

$t$8

and agent $t$9’s information-consistency score on plan $$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$0 is

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$1

Aggregating across agents yields

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$2

and the information-consistency-based plan selection rule is

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$3

CG-ESR is defined from the discrepancy between the Planner’s raw choice

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$4

and the IPS-selected plan. A cross-round discrepancy occurs when

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$5

For each round with $$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$6, CESR generates a lightweight epistemic constraint

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$7

where $$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$8 abstracts why the Planner’s choice was less information-consistent. The Planner’s private memory is then updated by

$$b_i^t : \Omega \to [0,1], \qquad \sum_{w\in\Omega} b_i^t(w)=1,$$9

so that the next-round information state becomes

$I_i^t$0

Implicitly, the new Planner belief $I_i^t$1 is the prior $I_i^t$2 projected onto the subset of $I_i^t$3 compatible with all constraints in $I_i^t$4 (Wang et al., 22 May 2026).

3. Within-round selection and cross-round refinement

EPC-AW separates two forms of calibration. Information-consistency-based Plan Selection (IPS) operates inside each round, selecting plans whose evaluations are stable across agents. Consistency-guided Epistemic State Refinement operates across rounds, using discrepancies between the Planner’s raw preference and the IPS-selected plan to modify future planning (Wang et al., 22 May 2026).

Operationally, each round begins with candidate plan generation by the Planner. Each agent then evaluates each plan under its information state and predicts peer scores. IPS computes $I_i^t$5 for every candidate and identifies $I_i^t$6. The Planner also identifies its own preferred plan $I_i^t$7 by maximizing $I_i^t$8. Execution and diagnosis then proceed on $I_i^t$9, not on $b_i^t$0: the Executor executes the chosen plan, and the Diagnoser evaluates whether the resulting outcome is supported. If the Diagnoser returns UNSUPPORTED, evidence is not added; otherwise, extracted evidence is appended to the system memory. Only after that does CESR act: if $b_i^t$1, a new constraint is derived and appended to the Planner’s private memory (Wang et al., 22 May 2026).

The system is therefore not a direct replacement policy in which IPS simply overrides the Planner’s current action. Its stated function is to assess whether plans remain supported under varying information conditions rather than directly verifying feasibility. The Planner’s prompt at round $b_i^t$2 contains all prior constraints in $b_i^t$3, which shapes both candidate generation and the Planner’s subsequent self-evaluations. New evidence in $b_i^t$4 can alter feasibility assessments, so the refinement process is explicitly coupled to a changing information context (Wang et al., 22 May 2026).

4. Refinement as persistent memory, projection, and minimal-change update

The defining operation of CG-ESR is memory-mediated refinement. The Planner’s private memory $b_i^t$5 is a list or set of textual constraints appended to the Planner’s prompt, and each discrepancy-triggered update projects the Planner’s belief onto states compatible with the accumulated constraint set. This memory-based perspective has clear analogues in other consistency-oriented systems.

A closely related memory architecture is BeliefBank, a persistent memory that stores beliefs over a fixed universe of sentences as triples $b_i^t$6, where $b_i^t$7 is the current assignment and $b_i^t$8 is confidence. There, inconsistency is defined exactly as

$b_i^t$9

with consistency $\Omega$0. Both raw model beliefs and logical constraints are compiled into soft weighted clauses and optimized in a weighted Max-SAT problem; a separate feedback component re-queries the model using other beliefs as context (Kassner et al., 2021).

In dynamic epistemic logic with privatized beliefs, refinement appears as action-model synthesis under minimal change. Given a deterministic belief increase formula, the synthesized pointed action model guarantees that the goal holds after update, preserves independent beliefs, and introduces no inconsistency unless forced by an impossible precondition. The pointed update operation further restricts the updated model to the reachable slice from the actual point, which is explicitly a pruning operation over the raw product space (Schlögl et al., 2024).

In the epistemic treatment of quantum systems on closed timelike curves, refinement is formulated as support restriction. One computes the set of ontic fixed points, prunes the support of the epistemic distribution to that set, renormalizes, and, when multiple fixed points remain, may choose the maximum-entropy distribution on the fixed-point set. The stated purpose is to avoid a “false consistency” in which an invariant epistemic mixed state hides an ontic paradox (Wallman et al., 2010).

This suggests that CG-ESR can be interpreted as a prompt-level, memory-level analogue of a more general refinement pattern: detect inconsistency, constrain admissible future states, and preserve as much of the prior structure as the consistency requirement permits.

5. Empirical profile and implementation

The reported implementation of EPC-AW uses Qwen3-Coder-30B via vLLM as the backbone LLM, with all agents sharing the same model. The Planner generates $\Omega$1 candidate plans with sampling temperature $\Omega$2, while all other LLM calls use temperature $\Omega$3. Plan-feasibility scores $\Omega$4 are integer values in $\Omega$5, the maximum number of interaction rounds is $\Omega$6, and there are no hard numerical thresholds in CESR: any discrepancy $\Omega$7 triggers a new constraint. Constraint templates $\Omega$8 are implemented as simple Python-format strings that capture the goal $\Omega$9 and action $M_{\mathrm{sys}}^t$0 of $M_{\mathrm{sys}}^t$1 together with a summary of why it was less consistent. The tool layer includes Python coder, Google Search, Wikipedia search, and Web Search with summarization (Wang et al., 22 May 2026).

On six benchmarks, EPC-AW, combining IPS and CESR, improves system-level success by an average of $M_{\mathrm{sys}}^t$2. In the ablation reported for Table 2, removing CESR while keeping IPS causes a drop of up to $M_{\mathrm{sys}}^t$3 on search-intensive tasks; the example given is 2Wiki, from $M_{\mathrm{sys}}^t$4 to $M_{\mathrm{sys}}^t$5. Removing both IPS and CESR yields performance close to the No-Repair baseline. Case studies identify two recurring discrepancy types: a tool capability mismatch, in which a plan assumed ScienceDirect access and CESR added a constraint to prefer verified public sources next time, and a verification-limits case, in which CESR redirected planning from an exhaustive whistleblower list toward known whistleblowers. Similar gains, reported as $M_{\mathrm{sys}}^t$6 over No-Repair, were observed on Qwen3-14B and DeepSeek-R1-32B (Wang et al., 22 May 2026).

Related empirical work shows that consistency signals can be effective beyond planning. In CLARity, a consistency-aware reward penalizes mismatch between options endorsed in the chain of thought and the final answer, within a two-stage refine-then-monitor training pipeline; on a Qwen-2.5-7B-Instruct backbone, the reported change from Standard RL to CLARity is from $M_{\mathrm{sys}}^t$7, $M_{\mathrm{sys}}^t$8, $M_{\mathrm{sys}}^t$9 to $Q$0, $Q$1, $Q$2 (Lin et al., 10 Oct 2025). In three-way logical question answering, CGD-PD queries both $Q$3 and $Q$4, projects onto a negation-consistent decision where possible, and then uses proof-driven disambiguation; on FOLIO validation, the reported relative accuracy lift for Claude is roughly $Q$5 (Huang et al., 12 Mar 2026). A plausible implication is that CG-ESR is one instance of a broader methodological trend in which consistency is operationalized as a supervisory or test-time calibration signal.

6. Limits, misconceptions, and adjacent research directions

A central misconception is to treat CG-ESR as an execution-repair mechanism. The motivating claim is narrower and more specific: planning can fail despite correct execution because agents may misjudge their knowledge when evaluating plan feasibility. The miscalibration is described as latent during planning because generated plans can remain self-consistent and executable without observable errors, and as dynamic because new information can alter feasibility assessments, potentially obscuring past miscalibration signals and causing them to recur over time. CG-ESR addresses this by storing discrepancy-derived constraints and adapting calibration over time, not by supplying a direct proof that a selected plan is feasible or true (Wang et al., 22 May 2026).

A second misconception is to equate consistency with correctness. The EPC-AW paper does not provide formal convergence proofs, and its theoretical discussion is qualitative: monotonic calibration, robustness to dynamic information, and bounded miscalibration are presented as properties, with the empirical claim that recurrence of identical miscalibration patterns drops to near zero after a few rounds. In adjacent work, standard final-answer-only rewards can improve accuracy while eroding reasoning quality, producing logical fallacies such as “Over Selection” and “Dissociated Answer,” whereas explicit consistency penalties align the model’s latent epistemic state with its surface chain of thought (Lin et al., 10 Oct 2025). Consistency is therefore used as a calibration signal, not as a sufficient criterion of epistemic adequacy (Wang et al., 22 May 2026).

A third boundary concerns the level at which consistency is enforced. In the closed-timelike-curve case, an epistemic fixed point can leave an observer’s mixed state unchanged even though no pure ontic state solves the underlying paradox. That example shows that epistemic consistency can conceal ontic inconsistency if the refinement rule is applied at the wrong representational level (Wallman et al., 2010). A plausible implication is that the practical success of CG-ESR depends on the adequacy of its constraint templates $Q$6 and on whether prompt-level memory captures the relevant failure structure of the task.

Across these settings, consistency-guided epistemic state refinement denotes not a single universal algorithm but a recurrent design principle: represent the current epistemic state, detect structured inconsistency, and update the state by constraints, projection, or minimal-change transformation so that later reasoning is better aligned with the available information.