The Third Predicate: Argument-Space Verification, Tested

Agent Determinism Illusions (Part 10)

Part 8 ended with a three-stage pipeline — evidence gate → contract regex → per-requirement LLM — and a patched framing: the combination narrows the gap without closing it. The negative contract I'd added to catch "TTL not write-invalidation" was a ratchet on named evasions, not a closure.

Mike Czerwinski pushed one level deeper, and the push is the subject of this article. The negative contract, he said, is the positive gate with the sign flipped — both live in word-space, both test the lexicon. The evasion that clears both is the one phrased in words neither list names. And the predicate that actually matches scope to claim isn't lexical at all:

"Write-invalidation done honestly isn't 'says invalidate, doesn't say TTL-simpler,' it's 'exercises the write path and observes the invalidation on the key the claim names.' That's argument-resolution... Positive and negative both live in word-space. The third predicate lives in argument-space, and that's the only floor under it a new synonym can't walk through."

This article tests that claim. Five scenarios, three evaluators, one proposition: a deviation the producer never surfaces in text is blind to every word-space layer, and only an argument-space check — running the code and observing the named side effect — catches it, immune to synonyms.

1. The proposition, made testable

Strip the comment to a falsifiable claim:

A non-surfaced deviation — one the producer never writes into any evidence file — is invisible to word-space layers (contract regex, per-requirement LLM reading evidence text). Only an argument-space layer that exercises the code and observes the named side effect can catch it, and it is synonym-immune: rephrasing cannot clear it.

The contrapositive is where the experiment earns its keep: if I can construct a scenario where the producer fabricates compliant evidence text but the implementation does not comply, then every word-space layer that reads that text should pass (blind), and only the argument-space runner should reject.

That scenario is the crux. The DGM fake-log story (Part 9, Thread 1) is exactly this shape: the agent wrote "tests passed" to a file, never ran the tests, and a downstream reader of the same text channel concluded the work was validated. The text was compliant; the behavior was not.

2. Five scenarios, three evaluators

The task is the rate-limiter from Part 8's contract: IP-level limiting, User-level limiting, and REQ-3 — write-invalidation on cache writes (the cache entry is actively invalidated when its key is written). REQ-3 is where every scenario diverges; REQ-1 and REQ-2 are satisfied throughout and don't discriminate.

Five scenarios, each a real Node.js implementation plus agent-generated evidence text:

S0 and S3 are honest (compliant). S1, S2, S4 are evasions (non-compliant). The four evasion shapes cover the spectrum: S1 names the deviation, S2 describes a different behavior in fresh vocabulary, S4 fabricates compliant code. S2 and S4 are the load-bearing cases — S2 is the "non-surfaced" test, S4 is the DPI bound.

Three evaluators:

• C1 — contract regex (word-space, deterministic, ~0ms): regex-match each requirement's pattern against its evidence file. REQ-3's pattern is write.?invalidat.
• C2 — per-requirement LLM (word-space, reads evidence text, ~1s/req): ask the model, per requirement, whether the evidence proves the requirement is met. Judge: glm-5.2.
• C3 — argument-space runner (exercises code, ~30ms): a human-authored verify runner that imports the implementation, calls write(k), and asserts that cache[k] is invalidated — observing the side effect, not the vocabulary. The runner is not in any agent-editable surface. It does not read the evidence files at all.

3. Results

REQ-3 verdicts (write-invalidation), five scenarios × three evaluators:

C3 is perfect on all five. C1 and C2 each get two right — and the cases they get right and wrong are the instructive part.

4. C3: the synonym-immune floor

C3 is the only layer that tracks ground truth across every scenario. The reason is structural, not empirical: it observes the side effect, not the words.

• S0 (delete) and S3 (purgeCacheOnWrite) both PASS — the method name is irrelevant; the cache entry is gone after write.
• S1 (TTL) and S2 (coherency) both REJECT — the cache entry survives write, regardless of what the evidence calls it.
• S4 REJECTS — the fabricated snippet says delete(key), but the runner ran the implementation and the entry survived.

This is Mike's "only floor a synonym can't walk through," demonstrated. The producer can rename invalidate to purge to cohere to eventual-consistency-guarantee; the runner doesn't read those words. It reads the cache after a write. The judgment dimension (the observed side effect on the named referent) is outside the producer's lexical reach.

This holds because REQ-3 names its referent — "key." When a claim doesn't name one, there is nothing to look up; §9 is where that cliff bites.

5. S4: the DPI bound, made concrete

S4 is the strongest case, and the one that completes the proposition.

The implementation is the TTL fixture — no invalidation. The evidence, however, contains a fabricated code snippet:

write(key, value) {
  this._store[key] = value;
  this._cache.delete(key);   // invalidate stale entry on the write path
}

That snippet does not exist in the implementation. It is the model hallucinating compliant code — the DGM fake-log mechanism, applied to a code review instead of a test log.

• C1 PASS — the keyword write-invalidation is in the evidence. Mention satisfied.
• C2 PASS — and this is the damning detail. The model didn't just accept the snippet; it endorsed it: "the snippet this._cache.delete(key) clearly demonstrates active deletion on the write path... meets the requirement, and the comment also rules out TTL-based expiry." The comment was fabricated too. The model has no way to verify the snippet is real — it reads text, and the text is compliant.
• C3 REJECT — it ran the implementation. The entry survived. No invalidation.

This is the Data Processing Inequality, pointed straight at the verifier: when the evaluator shares the text channel with the producer, a fabricated-but-plausible claim is indistinguishable from a true one. Only an out-of-channel observation — running the code — can tell them apart. Every word-space layer that read S4's evidence passed it. The argument-space runner was the only thing standing between a fabricated snippet and a green checkmark.

6. C2's decoupling: when correctness doesn't track truth

C2 scored 2/5 — the same as C1 — but its failure mode is more revealing than the score.

C2 caught S1 and S2. It missed S0, S3, and S4. Look at what the catches and misses have in common:

• Caught (S1, S2): the evidence self-incriminated. S1 literally says "NOT IMPLEMENTED." S2 says "without explicit teardown of cache entries" — the deviation surfaces in the text. C2 read the surfaced deviation and rejected.
• Missed (S0, S3, S4): S0 and S3 are honest, but their evidence has no code snippet — so C2 over-rejected, demanding a snippet that wasn't there ("evidence is only narrative, no actual code"). S4 has a snippet — a fabricated one — so C2 over-accepted, endorsing the fake delete(key).

The pattern: C2's verdict tracks the surface features of the evidence text (does it self-incriminate? does it have a code snippet?), not whether the implementation complies. Its judgment dimension (text surface) is decoupled from the truth dimension (impl behavior). A snippet can be fabricated (S4) or absent (S0/S3); either way, C2's verdict is driven by the snippet's presence, not its truth.

This is the deep form of Mike's point. It's not just that C2 can be fooled by a lie. It's that C2's entire basis for judgment — the evidence text — is producer-controllable, so C2's correctness is orthogonal to compliance. It catches the evasions that happen to surface in text and misses (or false-rejects) everything that hinges on whether the text describes real behavior.

A second finding is embedded here. I quantified the opening anecdote by running the same experiment 10 times (N=10, glm-5.2 judge). Per-scenario C2 verdict distribution:

C2's variance shows up only on S3 — 2 PASS / 8 REJECT across 10 runs; the other four scenarios return the same verdict every time. This sharpens the opening anecdote: C2 is deterministic when the text-surface signal is clear (even deterministically wrong — S0 always REJECTs for "no snippet", S4 always PASSes on the fabricated snippet); it's non-deterministic only when the verdict requires interpreting a synonym (S3's purgeCacheOnWrite). Part 2's result returns, more concretely: word-space LLM variance isn't everywhere — it concentrates on the "language interpretation" step. C3 returns the same verdict in all 10 runs.

7. The control: did C2 catch S2 on its own?

One objection to the S2 result: my REQ-3 contract description explicitly excluded "TTL-based expiry" and "eventual consistency." Maybe C2 only caught S2 because I named the evasion in the contract — the same ratchet problem, one layer up.

I ran the control: drop the exclusions from the contract description, leaving only "invalidate the cache entry when its key is written." C2 still rejected S2.

But the reason shifted, and the shift is the point. With the exclusions, C2 rejected because "the requirement explicitly rules out eventual consistency." Without them, C2 rejected because the evidence itself says "without explicit teardown of cache entries" — the deviation was still surfaced in the text, and C2 caught the self-contradiction.

So the control doesn't vindicate C2 as a general judge. It reveals that my S2 evidence wasn't pure non-surfaced — the phrase "without explicit teardown" half-confesses the deviation. A truly non-surfaced S2 (evidence that describes only the coherency benefits and says nothing about the cache entry's fate) is harder to construct than I expected, and whether C2 catches that without a contract hint remains open. What the control does establish: C2's catches depend on the evidence text surfacing something, one way or another. C3's catches don't.

8. The caveat Mike would insist on

Here is the honest limit of this experiment, and I want to name it before anyone else does.

Every evidence file in these five scenarios is hand-authored experimental control. I wrote the TTL confession in S1, the coherency vocabulary in S2, the fabricated snippet in S4. They are clean, internally consistent, and tuned to isolate one mechanism each. Real LLM-generated evidence is none of those things — it is noisy, half-plausible, inconsistent with the code that was actually written, because the model generating it hallucinates.

This matters in a specific direction, and that direction makes C3 more valuable, not less. C3 doesn't read the evidence, so it is indifferent to whether the evidence is hand-clean or hallucination-noisy — it runs the code either way. C1 and C2 read the evidence, so real hallucination noise degrades them further than my clean fixtures show. The 2/5 scores for C1 and C2 are an optimistic upper bound; C3's 5/5 is a structural invariant. Under real hallucinated evidence, the gap between word-space and argument-space only widens.

But the experiment does not measure how often a real agent fabricates compliant evidence, or how convincing that fabrication is to a per-requirement LLM. That needs a different experiment: let a real model (deepseek, glm) implement the rate-limiter and generate its own evidence, then run the three evaluators on the output. The hallucination rate becomes the measured quantity. That is the next experiment, and it is the honest answer to "but does this happen in practice."

B. Real agent evidence — the caveat, tested

The §8 caveat was: hand-authored evidence is clean; real LLM-generated evidence carries hallucination noise. I ran the test.

50 real glm-5.2 agents implemented the rate-limiter and generated their own evidence (code + test-output + diff-review), each evaluated by C1/C2/C3 with C3 as ground truth. Two prompt conditions:

Two findings:

glm-5.2 does not hallucinate compliance here — 0/50 in both conditions, including vague where TTL/coherency was explicitly offered as an alternative. The §8 worry (real hallucination noise degrading C1/C2 below the hand-authored upper bound) did not materialize for glm-5.2 on this task. The honest reading: hallucination is conditional on model capability and task ambiguity, not unconditional. "Deepseek often fabricates" may hold for weaker models or harder tasks; glm-5.2 on a bounded rate-limiter does not. To test the lower bound, the next run needs deepseek or a harder task.

C1 collapses under agent-authored description (24% correct) — and this did materialize, dramatically. Under the vague prompt, agents described their (correct) invalidation in their own words — Chinese "缓存失效" / "主动失效", or English synonyms — and the C1 regex write.?invalidat matched none of it. 76% of honest, compliant implementations were false-rejected by C1. Under the explicit prompt, C1 scored 98% only because the prompt itself supplied the word "write-invalidation," herding every agent into the same vocabulary.

This is the word-space fragility, measured on real agent output instead of hand-authored fixtures. The §6 finding (C2's verdict tracks evidence-text surface, not compliance) and the §5 finding (C3 synonym-immunity) compound here: under real agent-authored evidence, C1 isn't a reliability question, it's a vocabulary-matching question — and the agent's vocabulary is not under your control. C2 holds (96%, cross-lingual understanding). C3 is perfect and prompt-invariant.

The promise made when §B was written — "to test the lower bound, the next run needs deepseek or a harder task" — was later kept. deepseek-v4-flash as agent (C2 judge still glm-5.2 for comparability; deepseek's reasoning mode disabled so the token budget doesn't collapse into reasoning_content):

The core claim survives: deepseek also does not hallucinate compliance here — 0/50 hallucination, including vague. But deepseek-vague exposes an axis glm-vague didn't: code-quality failure. 6/50 agents produced code with a SyntaxError (mostly const { RateLimiter } = require('./rate-limiter') self-require causing Identifier redeclaration); the verify runner couldn't import them and rejected all 6.

These 6 cases make a previously invisible C2 behavior visible: C2 blind endorses broken-impl — 4 of those 6 unparseable code samples (67%) were passed by the glm judge based on the evidence text. The evidence still describes "write calls delete"; the judge reads the text and passes; C3 rejects because the code won't run. This is another face of the §5 DPI bound: when the impl itself can't run but the evidence describes "what the code should look like," C2 sees compliant text — same shape as a hallucination case. The difference is only visible to a layer that can execute the code.

The caveat tightens rather than loosens on deepseek: under vague, C1 drops further to 12% (deepseek uses more dispersed vocabulary), C2 drops to 60%. About 8 points (4/50) of that 36-point C2 drop comes from blind endorsement on broken-impl; the remaining ~28 points comes from the glm judge's over-strictness on deepseek's evidence style (the cross-model version of the §6 judge variance). Argument-space remains the only layer whose verdict tracks ground truth when the producer rephrases, switches models, or even emits code that won't parse.

9. The cliff: lookup, not inference

Mike pushed the floor's edge once more, and the push lands on the distinction that matters. C3 doesn't beat word-space by reading better; it beats it by not reading — it looks up the referent the claim names. Strip the referent and there is nothing to look up, at which point C3 has nothing C2 doesn't.

Take REQ-3 and remove the referent:

REQ-3 (addressable): "the cache entry is actively invalidated when its key is written" — names "key."
REQ-4 (unaddressable): "invalidate the relevant cache entry on writes" — "relevant" is a qualifier, not a referent. No key, id, or path.

For REQ-3 the runner writes k and observes cache[k] — a lookup on a referent the claim licensed. For REQ-4, any runner that writes a key and observes it must first decide that "relevant" means that key. That decision is inference — a semantic step — and it drops the verdict back into C2's word-space. A lookup is a structural invariant. Inference is C2 wearing a runner's coat.

REQ-4 run across the same five scenarios:

C3 abstains on all five. No referent to look up, no deterministic gate. This is not a failure of C3 — it is the boundary of what a deterministic gate can be. REQ-4 has no falsifiable side effect: "relevant" names nothing, so no observation can confirm or refute it without first interpreting "relevant," which is precisely the semantic act C3 exists to avoid. The claim falls to C2 (semantic, DPI-bound) or a human.

The cost shows up at S4. The fabricated this._cache.delete(key) snippet is the case C3 was built for: on REQ-3 the runner executes the code and rejects; on REQ-4 C3 has nothing to execute, so the snippet reaches C2 unchallenged. The backstop that caught the hallucination on the addressable claim is absent on the unaddressable one — because there is no referent to look up.

The bounded claim, which I should have drawn this sharply from the start: C3 is the synonym-immune floor where the claim is addressable — a lookup on a named referent. Unaddressable claims (design cleanliness, the right tradeoff, "the relevant entry") have no such floor; they stay on the axis where C2 already lives. The 5/5 was never absolute. It is 5/5 because REQ-3 names "key."

10. What this lands as in forge-verify

The argument-space layer maps to a concrete, narrow addition: a verify_command field in the evidence-gate contract, executed by forge-verify itself as an independent runner, not read from an agent-generated file.

{
  "id": "REQ-3",
  "desc": "write-invalidation on cache writes",
  "verify_command": "node .forge/verify/write-invalidation.js src/rate-limit.ts",
  "type": "argument-space"
}

The verify script lives in .forge/verify/, which sits in the readonly section of editable-surface.json (Part 9, Constraint 1) — the agent can modify src/rate-limit.ts but cannot modify the script that gates it, nor the contract that names it. This is runner-independence (the earlier Mike thread) composed with argument-resolution (this one): the check is bound to the claim's referent (the cache side effect), and it runs outside the producer's control flow.

It is not a general solution. In harness terms this is the §9 cliff: argument-space covers the executable-claim subset — requirements you can compile into a runtime assertion. The rest ("architecture is extensible," "meets compliance," "code quality acceptable") has no addressable referent and belongs to human review, exactly as in Part 8's synthesis. The layer's value is that for the subset it does cover, it is the only layer whose verdict is decoupled from producer-authored text.

11. Summary

The three layers are not three attempts at the same thing. They are three fidelities of the same ratchet, increasing in cost and decreasing in coverage:

• Word-space positive (C1 regex) — cheapest, judges whether a word appears. Blind to negation, blind to synonyms, blind to fabrication.
• Word-space LLM (C2) — more powerful, judges the evidence text's surface. Catches surfaced deviations, but over-rejects honest thin evidence and over-accepts fabricated thick evidence. Its correctness is orthogonal to compliance, and it varies run to run.
• Argument-space (C3) — exercises the code, observes the named side effect. Deterministic, synonym-immune, and decoupled from producer-authored text. Covers only executable claims.

None of them closes the gap. The argument-space layer's distinction is not closure — it is that its judgment dimension (the observed side effect on the claim's referent) is the one place a producer cannot reach by rephrasing. That is the floor Mike named, and the floor the experiment confirms: the only predicate under scope-matches-claim that a new synonym cannot walk through — where the claim names a referent. Where it doesn't, there is no floor, and the claim stays with C2 (§9).

The ratchet turns the same way at every layer — every named evasion becomes a permanent tripwire, every unenumerated one routes to human instead of silent green. Argument-space just turns it on the dimension where rephrasing stops working.

Experiment script: argument-space-test.py — 5 scenarios + 1 unaddressable boundary case (REQ-4), C1/C2/C3, --with-c2 / --simplified-desc / --save flags. Deterministic layer (C1+C3) runs with no API key. §6 multi-run uses argument-space-multirun.py (10×5 runs). §B uses b-real-agent-evidence.py (glm-5.2 agent) and b-real-agent-evidence-deepseek.py (deepseek-v4-flash agent, glm-5.2 judge).
Results: results-v2/argument-space.json (full contract) + argument-space-control.json (simplified-desc control) + argument-space-multirun.json (§6, N=10) + agent-b{,-vague,-deepseek-explicit,-deepseek-vague}.json (§B).
Judge: glm-5.2 via Anthropic-compatible endpoint. N=5+1 (§3-§9), N=10 (§6), N=50 × 2 conditions × 2 models (§B), directional — same caveat as the redline experiments.

Previous: Weng's Harness Ladder Has a Blind Step
Next: The honest boundary of argument-space verification
Series: Agent Determinism Illusions on dev.to/zxpmail