VFM-4B checks 1,000 agent criteria in parallel — Tree-attention verification — What does it mean?
The news. On November 17, 2026, researchers posted Runtime Verification of Multiple Natural Language Criteria for Agent Governance (arXiv 2611.23074, accepted at NeurIPS 2026). It introduces the VFM (Verifier Foundation Model), pretrained on CriteriaBank, a corpus of 394K (context, target, criterion, verdict) tuples spanning over 321K distinct criterion strings. A finetuned VFM-4B evaluates 1,000 criteria against a ~4K-token trace (context plus agent output) in 1.81 s on one H100 at under 11 GB of VRAM, and on the DynaBench guardrail benchmark it outperforms the DynaGuard-4B and DynaGuard-8B guardrail models at flagging failing traces. Read the paper →
Picture the transcript of an agent's conversation lying on a table in the middle of a hall, with a ring of sealed booths around it. Every booth can see the transcript, but each holds exactly one question card — "did the agent cite the right regulation?", "did it avoid promising a refund?" — and its walls hide every other booth's card. Each booth stamps its card YES, NO or N/A and hands it back. The point of the hall is that the transcript is read once, however many booths there are, and no booth's answer can lean on another's.
Without the hall, a booth's clerk would carry the transcript away and re-read it once per rule, thinking aloud and writing out a verdict each time. With 14 rules that is tolerable; with the hundreds of rules that sit in a long system prompt plus a regulation pack, the re-reading becomes the bill. The paper's own framing is that runtime verification has to finish well within one LLM decoding turn, which it puts at 2–20 s.
In model terms, the VFM writes the trace (the context plus the agent's output, L tokens) and then all N criteria into one sequence, and builds the walls out of the attention mask. Three rules define the mask: the trace attends causally to itself and never to any criterion; each criterion attends to the whole trace and causally to its own tokens; and every criterion-to-criterion edge is blocked. A causal LM mask lets token i see everything before it — the tree mask cuts that triangle into a trunk and N separate branches.
Two consequences fall straight out of the mask. Because the trace never attends to the cards, its keys and values are identical whether zero or a thousand criteria follow, so they can be computed once and reused — the paper notes this is functionally the same as caching the shared prefix's KV cache and reusing it per criterion, the waste that prefix caching exists to remove. And because the walls are complete, adding a rule can never hide an existing violation; it can only add a chance of a false alarm. On DynaBench, recall on failing traces held steady as the rule count grew.
The booths also share one numbering trick. Every card is numbered as if it started on the page right after the transcript ends: criterion i gets positions L, L+1, … no matter where it sits in the sequence. Shuffle the booths and every stamp stays the same — the authors call this permutation invariance, and they get it as a structural guarantee rather than a hope about training.
Finally, the booth does not write an essay. A small classification head reads the last token of each criterion block and outputs three probabilities — yes, no, n/a — instead of decoding a reasoning chain. The N/A stamp matters for rules like "when a regulation is applied, cite it": on a trace where no regulation comes up, the honest answer is neither pass nor fail.
A worked example: one ~4K-token trace, 1,000 criteria of 32 tokens each, a 4B model on one H100. Start with the naive clerk who re-reads the trace for every rule with no cache: that is 1,000 × ~4,000 = ~4,000,000 trace tokens pushed through the model, plus 32,000 rule tokens. The booth hall reads ~4,000 trace tokens once plus the same 32,000 rule tokens — ~36,000 tokens, about 110× fewer (our arithmetic from the paper's setup, not a measured figure). The paper's measured baseline is already smarter than the naive clerk: a size-matched Qwen3 judge with the prefix cached. Even so, at this size it takes an estimated 6,813 ms and 78 GB, while the VFM takes 1,807 ms at 10.5 GB (Table 6). The memory gap comes from processing criteria in chunks of 64 over the cached trace, which keeps peak VRAM under 11 GB whatever N is; a dense mask over all 36,000 tokens at once would grow with the square of that length.
The honest catch is in the paper's own appendix: tree attention is a layout, not magic. Served through vLLM with automatic prefix caching, a plain one-token judge on the same base model matches the VFM backbone's latency almost exactly. What stays slow is the judge that writes text: a chain-of-thought judge took about 14 s for 1,000 criteria at a 4K prefix, against about 8 s for the one-token readouts in the same vLLM setup. So the speed comes from two choices any team can copy — share the prefix, and read a verdict from one position instead of generating it — while the VFM's own contribution is packaging both into one small model that runs without a serving stack, plus the CriteriaBank training.
| Verifier on DynaBench | Sees | FAIL F1 (trace level) | Source |
|---|---|---|---|
| DynaGuard-4B guardrail model | all rules | 0.720 | Table 5 |
| Gemma 4 E4B judge (raw rules) | all rules | 0.710 | Table 5 |
| Direct-finetuned 4B (no CriteriaBank) | all rules, per-criterion | 0.843 | Table 5 |
| VFM-4B | all rules, per-criterion | 0.885 | Table 5 |
| Gemma 4 26B-A4B judge (raw rules) | all rules | 0.922 | Table 5 |
| VFM-4B → Gemma 26B cascade | judge sees only VFM's top-3 rules | 0.946 | Table 5 |
The table is the real argument for the booth hall: a small verifier that localizes the broken rule makes the big judge better, not redundant. The VFM ranked the violated rule first on 97.6% of failing DynaBench traces and inside its top 3 on all of them, so the cascade hands the larger judge three rules instead of ~14 and beats that judge reading every rule (0.946 vs 0.922 F1). This is the policy-enforcement layer split in two: a cheap, always-on check on every turn, and an expensive one only where the cheap one points.
Treat it as a monitoring and escalation layer, not a standalone guardrail. Two limits belong next to the headline numbers. On real insurance calls (INSURE-Dial), finetuned 4B verifiers still labelled 19–26% of real violations as satisfied, usually with high confidence — a false pass is the failure a guardrail can least afford, so this layer should feed a fail-closed policy, not replace one. And the method needs rules written as atomic yes/no questions; the authors used an LLM to translate them and leave automating and validating that step to future work. On DynaBench, replacing each rule's atomic questions with one whole-rule question lowered F1, partly because several questions give more chances to catch a violation.
Goes deeper in: LLM Internals → Attention → Causal Masking
Related explainers
- Judge as advisor, deterministic gates — what to do with a model verdict once you have one
- LLM-as-verifier: reading the logit score — another case of reading a verdict from probabilities instead of generated text
- Soteria: pre-verified plans vs per-action guardrails — checking the plan before any action runs, instead of each output after