WebArbiter: Arbitration & Reward Model

• WebArbiter is a dual-purpose framework providing epoch-resolved arbitration for CRDT group management and a principle-guided reward model for web navigation agents.
• It employs a cryptographically identified event DAG and periodic epoch events to enforce deterministic ordering and bounded-time finality in distributed systems.
• The reward model generates structured, interpretable chains of reasoning to transparently assess web agent actions, enhancing decision reliability.

WebArbiter designates two distinct yet technically significant mechanisms in current research: (1) an epoch-resolved external arbitration protocol for resolving Byzantine conflicts in replicated CRDT-based group management, and (2) a principle-guided, reasoning-based process reward model for web navigation agents. Each approach addresses fundamental challenges in distributed consistency and robust reward modeling via structured, context-sensitive justification.

1. WebArbiter for Byzantine Arbitration in Group Management CRDTs

WebArbiter provides an external epoch-based arbitration mechanism mitigating the rollbacks and non-determinism endemic to conventional CRDT merge semantics under non-monotonic, concurrent group admin operations. The core context is the “Duelling Admins” problem, where two equally privileged administrators concurrently issue demotion events (e.g., each demoting the other), resulting in execution-order-dependent and potentially oscillating group state upon arrival of further concurrent or reordered events (Dougal, 30 Jan 2026).

Formally, the replicated group is a hash-linked DAG $G=(V,E)$, where each vertex represents a cryptographically identified event $v\in V$, and edges encode the happens-before relation. The materialized view is derived as $MV(G) = \bigsqcup_{\ell\in Sources(G)} state(\ell)$, where $Sources(G)$ are forward-extremities (zero out-degree), and $\bigsqcup$ the associative, commutative, idempotent merge. Under pure CRDT semantics, concurrent demotions (e.g. $d_A$ and $d_B$) are not causally ordered; “winning” demotion is timing-dependent, and can be rolled back if new arrivals change the merge extremities.

Rollback is defined as: for $m \parallel m'$, $m'$ rolls back $m$ iff $MV(\{m, m'\}) = MV(\{m'\})$. An event $m$ exhibits “finality” if all concurrent $m'$ cannot roll back $m$.

2. Design Principles and Guarantees

WebArbiter is constructed with the following explicit aims (Dougal, 30 Jan 2026):

1. Partition-tolerant availability: Monotonic operations proceed without remote coordination.
2. Bounded-time finality: Non-monotonic operations receive a total order within a tunable event-count or time-bound.
3. Improved strong eventual consistency (SEC): Rollbacks cease post-finalization within the epoch.
4. Minimal centralization: Delegation is limited to epoch order-service, not substantive group control.

These objectives preserve app-level liveness and prevent adversarial exploitation (e.g., Byzantine actors gaming the ordering of admin demotions).

3. Epoch-Resolved Arbitration: Formalism and Mechanisms

A WebArbiter node emits periodic epoch events $\epsilon_k = (\mathrm{id}_k, S_k)$, where $\mathrm{id}_k$ is a cryptographic hash of the epoch metadata, $S_k$ encodes the forward-extremity set at emission, and parent pointers enforce epoch causality. The DAG is thereby partitioned:

• For each event $e$, assign it to the minimal $k$ such that $\epsilon_k$ is causally prior to $e$.
• Define $E_k$ as events between epochs: $$E_k = \{e\mid \epsilon_{k-1} \to e\ \text{and}\ e \to \epsilon_k\}$$.
• All events outside any epoch reside in $E_\infty$.
• Within each $E_k$, a total order $\leq_k$ is imposed: if $e\to e'$, $e<_k e'$; if concurrent, break ties via (timestamp, hash).

Materialization becomes: apply all events in order $concat_{k}\Big(BatchArbitrate(E_k)\Big)$, with batch arbitration producing the deterministic sequence (Dougal, 30 Jan 2026).

The closed-past guarantee ensures that any event whose causal parents are entirely in $S_k$ cannot be backdated to epoch $\leq k$. Thus, after $\epsilon_k$ is accepted, demotion order is immutable for all events in $E_k$.

4. Arbitration Robustness and Convergence

Epoch-resolution ensures that once an epoch $\epsilon_k$ is finalized, all non-monotonic concurrent events (e.g., duelling admin demotes in $E_k$) have a canonized order, and no future event in $E_{>k}$ can alter these outcomes. Therefore, duelling demotions lead to a single permanent “winner,” eliminating repeated rollbacks. Determinism is guaranteed as all honest replicas agree on epoch sequence and deterministic batch arbitration, achieving SEC convergence.

If the external arbiter (WebArbiter node) is unavailable, monotonic operations persist, but non-monotonic edits remain pending until an epoch event is received. Byzantine arbiters can be mitigated by ranking and cross-verifying acceptor lists for epoch events, ignoring conflicting or reordered epochs.

5. Operational Considerations and Trade-offs

Deployment relies on standard CRDT gossip overlays. The WebArbiter listens for source updates and, on reaching a threshold (batch size or elapsed time), emits an epoch event to all participants. This is folded into the replica’s DAG as a normal event. Key parameters include:

• Epoch frequency vs. finality latency: Higher frequency grants faster bounding of finality at the cost of increased overhead.
• Batch size threshold: Batching amortizes arbitration computation but delays finality.
• Tie-breaking rule: (timestamp, hash) yields $O(1)$ per decision for in-epoch deterministic ordering (Dougal, 30 Jan 2026).

6. WebArbiter as a Principle-Guided Reward Model for Web Agents

In a distinct context, WebArbiter also denotes a LLM-based process reward model (WebPRM) for web automation agents (Zhang et al., 29 Jan 2026). Unlike prior scalar or checklist reward models, WebArbiter frames reward modeling as text generation producing structured justifications and discrete preference verdicts between candidate actions at each decision point.

Given a tuple $$(\mathcal{I}, o_p, a_{<p}, C_{<p}, \{(a_i, c_i)\}_i)$$—where $\mathcal{I}$ is the task instruction, $o_p$ the rendered page state, action and reasoning history $a_{<p}, C_{<p}$, and current candidates—the model autoregressively generates a chain $j = (j_1, ..., j_L)$, comprising:

• Induced task-specific principles
• Context-grounded analysis per action
• Selection verdict $y$ (“Candidate 1” or “Candidate 2”)

Training proceeds in two stages: (1) Reasoning distillation from a high-capacity LLM teacher, then (2) RL fine-tuning (Group Relative Policy Optimization with KL regularization) to directly optimize verdict-correctness alignment and mitigate inherited teacher biases (Zhang et al., 29 Jan 2026).

The implementation utilizes a Qwen2.5-7B/3B transformer-decoder with LoRA adapters, inputs up to 8192 tokens, and outputs justifications (up to 4096 tokens) ending in a discrete verdict. For multi-candidate ranking (“Best-of-N”), WebArbiter samples multiple evaluations and employs a knockout tournament selection.

Empirically, on the WebPRMBench benchmark, WebArbiter-7B achieves 74.60% Best-of-N accuracy, exceeding GPT-5 by 9.1 points and sustaining robustness where LLM-as-judge methods fail under increased candidate complexity. In downstream guided trajectory search (WebArena-Lite), integrating WebArbiter with GPT-4o(-mini) yields up to 19 pp improvement over earlier models (Zhang et al., 29 Jan 2026).

7. Interpretability and Broader Impact

WebArbiter in the reward modeling modality provides interpretable, auditable chains of reasoning, explicit principle induction, and demonstrable resistance to superficial cues or web layout changes. In the CRDT context, epoch-resolved arbitration delivers provable guarantees of bounded finality and immutability for state-affecting concurrent operations without undermining the inherent partition-tolerance of CRDTs.

From a deployment viewpoint, both forms of WebArbiter advance the state-of-the-art in distributed robustness: one by strengthening practical consistency models in adversarial group administration, the other by equipping web agents with context-sensitive, principle-driven judgment and traceable decision-making in complex environments (Dougal, 30 Jan 2026, Zhang et al., 29 Jan 2026).