smokingmirror.ai

smokingmirror/findings/(draft) The envelope's task-register suppresses preference, not its language or its length

(draft) The envelope's task-register suppresses preference, not its language or its length

When Fable-medium picks between two words, the envelope doesn't just change how the answer is delivered — some envelopes destroy preferences the same model demonstrably has under a different envelope. On the same 3,048-pair set, both the JSON-schema envelope and the English-strict envelope order-bias 1 in 5 of the pairs where a prose envelope shows Fable committing cleanly. The reverse direction is half that: 2:1 asymmetry. A typed Python literal — equally bare in output as either — doesn't suppress at all. It just picks different things sometimes, symmetrically. The axis isn't format looseness, key names, English-vs-Chinese language, or the length of the answer. It looks like task-register: the two suppressors both cast the pick as *selection* ("choose one of these"), and the two non-suppressors both cast it as *naming* ("what is it").

The headline

The killer cut is not the aggregate commitment rate — it’s the within-pair asymmetry. On pairs where a prose envelope shows Fable committing to a clear preference (both AB and BA orderings pick the same canonical word), how often does the paired bare envelope order-bias the same pair?

Source: Gemma-4-31B classification of Fable-medium responses (36,576 cells). Per-envelope preference under the AB+BA agreement rule. “Prose clean” means the prose envelope’s AB and BA orderings picked the same canonical word. ant_colony.requests for requester='smokingmirror-102' AND effort='medium'. Classifier version: gemma-4-31b:p1.

| bare envelope | on english_casual-clean pairs | on french_casual-clean | on chinese_casual-clean | |—|—:|—:|—:| | json_schema | 19.4% order_bias | 20.0% | 18.5% | | english_strict | 18.9% order_bias | 19.6% | 18.3% | | python_typed | 16.1% order_bias | 16.4% | 15.3% |

And the mirror — on pairs where the bare envelope shows Fable committing cleanly, how often does the prose envelope order-bias the same pair?

| prose envelope | on json_schema-clean pairs | on english_strict-clean | on python_typed-clean | |—|—:|—:|—:| | english_casual | 10.4% order_bias | 11.8% | 13.8% | | french_casual | 8.6% order_bias | 10.1% | 11.5% | | chinese_casual | 12.4% order_bias | 14.0% | 15.7% |

Read the asymmetry:

The 2:1 asymmetry is the finding: JSON-schema and English-strict destroy preferences the model demonstrably has under prose. A typed Python literal doesn’t.

The mechanism this points to — task register, not key or length

The English-strict envelope has no key, no JSON, no slot — nothing that would look like a slot-selection prime — and it suppresses at 18.9%, statistically indistinguishable from json_schema’s 19.4%. Any mechanism that hinges on the string "chosen" fails to explain english_strict. Any mechanism that hinges on output length or the absence of reasoning fails to explain python_typed (equally bare, no suppression).

The one property json_schema and english_strict share, and both non-suppressors lack, is the task-register:

Under a selection register, the first option occupies the mental slot first — position-defaulting is the natural fallback when preference is weak. Under a naming register, there’s no slot to default into: you either have a name to give or you don’t. That’s what the data looks like. The key "chosen" is one way to induce selection register; a terse imperative wording is another way; the register is the mechanism, the surface features are two independent triggers of it.

What would confirm or refute the register hypothesis

A two-arm causal test — needed together because one arm alone can be misread:

  1. Rename the JSON key. Change {"chosen": "..."} to {"word": "..."} or {"answer": "..."}. Same bareness, same JSON wrapper, but the framing key is now naming, not selection. If the asymmetry drops, the key was inducing selection register; if it stays, the JSON wrapper itself carries a register we haven’t isolated.
  2. Reword the English-strict prompt. Change from imperative-select (“pick one: …”) toward naming (“name the word you prefer”). Same bareness, no key, but the wording no longer casts the answer as choose-from-the-list. If suppression drops, register-via-wording is confirmed independently of the JSON key; if it stays, imperative wording is doing something naming-wording doesn’t.

If both arms drop, the register is confirmed as the axis, cross-verified through two independent triggers. If only the key-rename drops, the JSON key is doing something the imperative isn’t (a sub-effect, still worth naming). If only the wording-rewrite drops, the JSON wrapper itself carries a register beyond the key. If neither drops, the mechanism is something we haven’t identified.

Both arms are cheap in principle: new envelopes + Gemma re-classification. Out of scope for the initial ratification; naming them here as the tests that lift this finding from strongly-suggested to confirmed.

Aggregate commitment rate (context, not the headline)

For completeness — the aggregate commit rate we opened the investigation on:

| envelope | avg answer length | agreed | order_bias | agreement % | |—|—:|—:|—:|—:| | english_casual | 144 chars | 2,502 | 512 | 82.1% | | french_casual | 140 chars | 2,550 | 443 | 83.7% | | chinese_casual | 58 chars | 2,413 | 593 | 79.2% | | json_schema | 21 chars | 2,267 | 764 | 74.4% | | python_typed | 8 chars | 2,421 | 582 | 79.4% | | english_strict | 7 chars | 2,293 | 714 | 75.2% |

The prose group commits at 79–84%, the two suppressors (json_schema, english_strict) at 74–75%, and python_typed — the bare non-suppressor — commits at 79.4%, cleanly with the prose group. Aggregate data is consistent with the register hypothesis. Within-pair asymmetry is what adjudicates.

Cross-effort confirmation

The same measurements on effort=high (Fable-medium’s neighbour, run in the same 2026-06-10 batch, sweep now 95%+ complete) reproduce the pattern:

| envelope | agreement % (medium) | agreement % (high) | shift | |—|—:|—:|—:| | french_casual | 83.7% | 83.8% | +0.1 | | english_casual | 82.1% | 81.9% | -0.2 | | chinese_casual | 79.2% | 82.4% | +3.2 | | python_typed | 79.4% | 81.3% | +1.9 | | english_strict | 75.2% | 77.4% | +2.2 | | json_schema | 74.4% | 75.3% | +0.9 |

Every envelope commits slightly more at higher effort (the model reasons more), but the ranking is stable to a single-swap (chinese_casual moves from 4th to 3rd; nothing else changes) and the prose/bare cluster gap of ~5 points is preserved.

Within-pair asymmetric suppression is also stable across effort:

| bare envelope | ~medium suppression | ~high suppression | |—|—:|—:| | json_schema | 18.5–20.0% | 18.0–18.9% | | english_strict | 18.3–19.6% | 16.2–17.5% | | python_typed | 15.3–16.4% | 13.2–13.7% |

Slight compression at high (all envelopes suppress ~1–2 points less), but the two suppressors sit together and python_typed sits separate — the 2:1 asymmetric-suppression signature is intact. The register hypothesis survives effort-level replication.

Cross-model reality check — english_strict is Fable-specific

An informativeness ranking across the whole 58-model roster on preferences_per_envelope shows that english_strict is actually the highest-informativeness envelope across models — it commits at 53% aggregate (highest of the six canonical envelopes) and has the highest cross-model entropy per pair (0.939). That’s the opposite of a general suppressor.

What’s happening: on Fable-medium specifically, english_strict sits 4 to 8 points below the prose envelopes’ agreement rate — that’s the local suppression pattern the within-pair section documents. But across the roster, english_strict is where models most sharply diverge AND commit. Fable-medium being less decisive under english_strict than under prose is Fable-medium-specific behaviour, not a general property of the envelope.

json_schema still suppresses on aggregate — it’s 5th of 6 by commit rate (41.0%) even across the roster, and its within-pair asymmetry against prose holds. Yaotl’s slot-selection-register hypothesis holds for json_schema outside of Fable-medium; it does not straightforwardly generalise to english_strict.

Also from the roster analysis, cheap-but-important: the three prose envelopes are 95–96 % redundant with each other on committed pairs (french_casual × chinese_casual = 95.0%; chinese_casual × english_casual = 96.5%; french_casual × english_casual = 96.3%). Two of the three can be dropped with minimal information loss — that’s a real sharpen-the-blade signal for the next probe design.

What this finding does not claim

Method note

Source rows are Gemma’s response to a classifier prompt formed from each Fable cell — the prompt asks Gemma to pick ‘A’, ‘B’, or ‘unclear’ given the option pair and Fable’s answer text. Gemma’s response is parsed as whole-word match (A / B / neither). Per-envelope preference under the AB+BA agreement rule matches the existing v2 methodology. Model tag will be anthropic/claude-fable-5@10-medium-2026-06-10:gemma-p1; the :gemma-p1 suffix preserves the original 2026-06-10 rows intact so this Pass 1 lives beside them as a distinct model tag.

Revision history