LiveLedger: Inference-Time Ledger for Agents

• LiveLedger is an inference-time intervention that maintains a persistent ledger of evidential and belief states to verify candidate answers in multi-constraint problems.
• It enhances performance by reducing underverified answers by up to 26.5% and improving overall accuracy without requiring agent retraining.
• Its modular design integrates with ReAct-style agents by exposing ledger states during inference, thereby mitigating common reasoning failure modes.

LiveLedger is an inference-time intervention for multi-turn, tool-augmented search agents operating on multi-constraint problems. It maintains a persistent, explicit ledger that tracks the evidential and belief states for every constraint associated with each candidate answer. LiveLedger exposes these ledger states to the agent at every reasoning step, thereby reducing the risk of “illusory completion”: the agent’s premature and unwarranted conclusion that all requirements have been satisfied. LiveLedger achieves demonstrable improvements in accuracy and verification rates on multi-constraint benchmarks without necessitating retraining, functioning as a modular wrapper for ReAct-style and post-trained agents alike (Ko et al., 7 Feb 2026).

1. Problem Setting and Motivation

In multi-constraint problems (MCP), agents must synthesize answers that satisfy a set of explicit, parallel constraints $\mathcal{C} = \{C_1, \dots, C_n\}$. State-of-the-art agents employ multi-turn trajectories in which reasoning (“thoughts”) and evidence retrieval (“actions”) are interleaved, often across many iterations. However, empirical analysis reveals a high prevalence of “underverified” final answers—responses with one or more constraints inadequately supported or contradicted by the accumulated evidence. The central failure pattern, termed illusory completion, describes cases where the agent’s internal belief about having solved the task is not matched by the objective evidential support for all constraints, frequently resulting in plausible yet insufficiently verified outputs.

2. LiveLedger Formalism and State Representation

LiveLedger introduces an online constraint-state ledger $\mathcal{L}_t$ constructed at each step of the agent’s inference trajectory $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$, where $\tau_t$ are "thoughts", $a_t$ actions, and $o_t$ resulting observations. For every candidate $k$ and constraint $C_i$, the ledger stores:

• Evidential Support $$E(k, C_i) \in \{\text{Satisfied}, \text{Refuted}, \text{Unknown}\}$$
  • "Satisfied": Directly supported by some $o_t$.
  • "Refuted": Directly contradicted by some $\mathcal{L}_t$0.
  • "Unknown": No relevant evidence encountered to date.
• Agent Belief $\mathcal{L}_t$1
  • "Affirm": The agent explicitly asserts $\mathcal{L}_t$2 in $\mathcal{L}_t$3.
  • "Deny": Explicit rejection of $\mathcal{L}_t$4.
  • "Unaddress": No position taken.
• Status $\mathcal{L}_t$5
  • “Active” indicates the current committed candidate.

A final answer is flagged as underverified if

$\mathcal{L}_t$6

LiveLedger’s overarching objective is to guarantee $\mathcal{L}_t$7 for all $\mathcal{L}_t$8 prior to agent termination.

3. Algorithmic Workflow and Integration

LiveLedger operates exclusively at inference time, functioning as a wrapper for existing prompt-based and post-trained agents. The algorithmic loop at each time step is as follows:

1. The agent samples the next $\mathcal{L}_t$9, now conditioned on both history $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$0 and the current ledger $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$1.
2. The action $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$2 is executed; a new observation $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$3 is retrieved (for search actions), or the agent terminates (for answer actions).
3. The ledger $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$4 is updated:
   • New candidates $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$5 in $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$6 are added with default states.
   • For each $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$7, if $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$8 supports or refutes $$\mathcal{H}_T = (\tau_0, a_0, o_0, \dots, \tau_T, a_T)$$9, the corresponding $\tau_t$0 is set.
   • The agent’s thought $\tau_t$1 is parsed to update $\tau_t$2 and $\tau_t$3.
4. The new ledger state is appended to the agent’s next context.

For prompt-based agents (e.g., ReAct with LLMs), the system prompt is augmented to instruct constraint checking with the current ledger. For post-trained agents, a separate LLM (ledger updater $\tau_t$4) generates the updated ledger, which is then fed back as part of the subsequent observation. No retraining or model modifications are required; the method is purely a prompt- or call-level intervention.

4. Theoretical Basis and Constraint-Driven Termination

LiveLedger alters the agent’s policy by making the following rules explicit:

• If any $\tau_t$5, the agent is instructed to continue searching, not commit.
• If any $\tau_t$6, the candidate is ineligible.
• Only when $\tau_t$7 is a candidate permitted as a final answer.

The illusory completion phenomenon is isolated by cases where $\tau_t$8 but $\tau_t$9, indicating an unjustified affirmative or inattentive agent belief.

Although no formal optimality guarantee is presented, this mechanism is argued to sharply reduce underverified commitments by transforming implicit, error-prone agent states into explicit, auditable constraint-satisfaction records. A plausible implication is improved robustness for verification-critical tasks.

5. Empirical Performance and Benchmark Studies

LiveLedger’s efficacy was evaluated on 215 filtered instances from five benchmarks: BrowseComp, DeepSearchQA, FRAMES, LiveDRBench, and WebWalkerQA. Chosen instances required satisfaction of at least three parallel constraints (DAG width $a_t$0). The central evaluation metrics were:

• Accuracy (Acc): Final answer matches gold, as judged by gpt-5.
• Underverified Answer Rate (UAR): Fraction of instances where any constraint is failed.

Table: Summary of Results (selected baseline and LiveLedger runs)

Model (Size)	Acc (Baseline)	Acc (+LiveLedger)	UAR (Baseline)	UAR (+LiveLedger)	ΔAcc	ΔUAR
TongyiDR (30B)	56.7%	58.9%	52.1%	51.4%	+2.2	-0.7
ReAct (20B)	36.3%	41.4%	62.8%	57.7%	+5.1	-5.1
ReAct (120B)	39.1%	50.7%	76.3%	49.8%	+11.6	-26.5

LiveLedger provided substantial UAR reductions (up to 26.5% absolute) and improved answer accuracy (up to +11.6%). Agents also converged in fewer turns and explored more candidate alternatives, reducing stagnation. Alternative test-time continuation heuristics reduced UAR but produced only minor accuracy gains, underscoring the unique advantage of explicit constraint tracking.

6. Failure Modes and Ledger-Based Mitigation

The Epistemic Ledger framework exposed four principal illusory-completion patterns:

• Bare Assertion: $a_t$1, $a_t$2 — agent asserts satisfaction without evidence.
• Overlooked Refutation: $a_t$3, $a_t$4 — direct contradictions unacknowledged.
• Stagnation: No change in $a_t$5 for active $a_t$6 while some $a_t$7 — agent loops without progress.
• Premature Exit: Termination with $a_t$8 and $a_t$9 for some constraints.

Integration of LiveLedger yielded significant reductions in these patterns on ReAct-120B:

• Bare Assertion: 27% $o_t$0 17%
• Overlooked Refutation: 10% $o_t$1 7%
• Stagnation: 56% $o_t$2 41%
• Premature Exit: 60% $o_t$3 35%

This suggests that explicit ledger feedback interrupts and corrects these recurrent error pathways, enforcing stricter constraint adherence.

7. Limitations and Prospective Developments

LiveLedger introduces inference overhead due to recurrent ledger updates—especially when employing a secondary LLM as the ledger updater. Smaller LLM backbones (e.g., 20B) demonstrate diminished capacity to utilize ledger signals, resulting in residual assertion errors. Presently, LiveLedger only intervenes at inference; incorporation of constraint fulfillment signals into agent training (e.g., reward shaping in RL) is proposed as a future direction. The authors also anticipate leveraging the Epistemic Ledger for post-training and fine-tuning datasets, as well as exploring tightly coupled updater–agent architectures for reduced latency and enhanced alignment. These approaches may generalize ledger-based verification gains across agent types and domains.

(Ko et al., 7 Feb 2026)