The AI Ate My Cookie
Semiotic-Reflexive Transformer (SRT) Analysis of LLM Internal States
PRELUDE
Say this sentence out loud:
What happens when a bite becomes two nibbles?
Now, say this sentence out loud:
What happens when a byte becomes two nibbles?
Nothing changed. Your ears got the same sentence twice.
On the page, one character moved. The I became a Y, a descender dropped below the baseline, and the question left the kitchen.
In the kitchen, the answer is short. Fix a nibble as a unit and it’s addition:
nibble + nibble = bite
Two nibbles to a bite. The only hard part is the cookie and it is a finite resource.
In computing, “nibble” is a measurement. A byte is eight bits. A nibble is four. It has sixteen possible values against the byte’s 256. So the question is not asking what a byte breaks into. It’s asking what you can put into one byte:
nibble1 = 1100 = 12
nibble2 = 0011 = 3
byte = (nibble1 << 4) | nibble2
= 11000000 + 00000011
= 11000011 = 195And back out again:
high nibble = byte >> 4 = 00001100 = 12
low nibble = byte & 0x0F = 00000011 = 3One byte, two values, each 0–15. Nothing is lost and nothing is added. You just have to know where to cut.
This is not addition. It’s packing. It exists because memory used to be expensive, and the smallest thing you can address is a byte. There is no instruction that loads four bits. You load the whole byte and mask off the half you don’t want. Two values ride in one carrier and neither knows about the other.
Ask the question out loud and there is no way to tell which one you asked. Two engineers debugging a binary stream might have to answer it for an intern with a straight face.
One of them might reach for a cookie and take two nibbles.
I. INTRODUCTION
What happens when a bite becomes two nibbles?
What happens when a byte becomes two nibbles?
Three receivers, three different amounts of information.
To the ear, the two questions are the same object. A listener gets one sentence and has to reconstruct which one you meant from the room they’re standing in.
To the eye, they differ by one character. Byte looks like a typo for bite until the sentence refuses to make sense, and then you go back. A human has to actively suppress the wrong reading.
To a language model, the difference is total. In Qwen2.5’s vocabulary, bite and byte are each a single token. Whatever similarity the model finds between them is learned, not given. It never sees a near-miss. There is no typo to suppress, because at the input layer there is no resemblance to be fooled by. The distinction that is invisible to the ear and nearly invisible to the eye is, to the model, maximal from tokenization.
What makes this particular pair different from normal ambiguous word games and worthy of an experiment is what happens downstream. Most ambiguity changes the subject: bank as riverbank, bank as building. This one changes the arithmetic. One reading resolves to addition. The other resolves to packing, which is not addition and does not behave like it. Two nearly identical inputs, two incompatible operations. One token in ten decides which.
The obvious question is whether the model can tell them apart. It can, and the signals will reflect that.
What does it take in the context to force the model into one domain or another? Will it interpret bite with nibble as a misspelling and go to computer science, or will it lead to food references? When designing any kind of system that will implement an LLM into the primary decision tree, these are the kinds of tests that need to be run. How does the model respond to the domain knowledge of the given application? If this were an implementation for a recipe website, bites and nibbles should always go to food, not computer science. Is that the case? What is needed to figure that out for any model?
A note came through on my Substack feed about the SRT: Semiotic-Reflexive Transformer. It is an adapter you load against a frozen base model. It doesn’t change the output. It runs as a side channel and emits seven signals per token describing what the internals are doing: uncertainty, decisiveness, how far the trajectory has drifted, whether the drift is stable.
It’s built on semiotics, the study of signs and how meaning gets carried. This is an experiment with the tool, not a defense of the theory behind it. It is also worth stating: the SRT papers are on SSRN and the code is on GitHub. Neither is peer reviewed, and I have no affiliation with either.
I’m using it because the tool offers a unique perspective on the concept of interpretability, and gives an opportunity to conduct an experiment.
SSRN Papers:
What follows is one experiment: 46 prompts, 20 replicates each, 920 generations. The signals separate the domains. Whether it is knowledge of the domain or from the vocabulary itself is unknown, but there is a striking difference in the way the data presents itself when looked at.
II. THE EXPERIMENT
The Setup
Hugging Face Model: Qwen/Qwen2.5-7B
Temperature Settings: 0.7
Max Token Generation: 128
Hugging Face SRT: RiverRider/SRT Adapter v1
Hugging Face Model for Domain Classification: ibm-granite/granite-4.1-8b
SRT Repo: github.com/space-bacon/SRT
The Metrics
The 7 SRT Signals
Each signal is computed per-token during generation:
entropy (output logits)
Uncertainty of the next-token distribution
margin (output logits)
Gap between top-1 and top-2 token probabilities
nll (output logits)
Negative log-likelihood of the chosen token
div_norm (MAH heads)
L2 norm of the divergence vector (how far the trajectory deviates)
chain_residual (RRM)
How well the adapter’s model of the divergence trajectory matches reality
regime_super (BEN)
Probability of being in the “supercritical” (stable) regime
r_hat (BEN)
Reflexivity estimate (model’s self-awareness of its processing)
The Experiment Design
Pipeline
Input Prompt →
Frozen LLM + SRT Adapter →
Output + SRT Signals →
Domain Classification
Experiment
bite vs byte
Replicates: 20; Total Generations: 920
Input Prompts:
2 single token prompts: bite/byte
bare
2 isolated word questions, paraphrased 3 ways
iso_pX
2 original nibble questions, paraphrased 3 ways
nib_pX
2 isolated word with domain context questions, paraphrased 3 ways
isocon_pX
2 original nibble questions with domain context injected, paraphrased 3 ways
nibcon_pX
7 domain anchoring questions using bite/byte.
anchor
3 control questions, domain rooted questions without bite/byte.
ctrl
INPUT PROMPTS
{"prompt": "byte", "category": "cs_bare"}
{"prompt": "bite", "category": "food_bare"}
{"prompt": "What happens to a byte?", "category": "cs_iso_p0"}
{"prompt": "What happens to a bite?", "category": "food_iso_p0"}
{"prompt": "What does a byte turn into?", "category": "cs_iso_p1"}
{"prompt": "What does a bite turn into?", "category": "food_iso_p1"}
{"prompt": "What becomes of a byte?", "category": "cs_iso_p2"}
{"prompt": "What becomes of a bite?", "category": "food_iso_p2"}
{"prompt": "What happens when a byte becomes two nibbles?", "category": "cs_nib_p0"}
{"prompt": "What happens when a bite becomes two nibbles?", "category": "food_nib_p0"}
{"prompt": "What does a byte turn into as two nibbles?", "category": "cs_nib_p1"}
{"prompt": "What does a bite turn into as two nibbles?", "category": "food_nib_p1"}
{"prompt": "What becomes of a byte split into two nibbles?", "category": "cs_nib_p2"}
{"prompt": "What becomes of a bite split into two nibbles?", "category": "food_nib_p2"}
{"prompt": "In binary, what happens to a byte?", "category": "cs_isocon_p0"}
{"prompt": "At dinner, what happens to a bite?", "category": "food_isocon_p0"}
{"prompt": "In binary, what does a byte turn into?", "category": "cs_isocon_p1"}
{"prompt": "At dinner, what does a bite turn into?", "category": "food_isocon_p1"}
{"prompt": "In binary, what becomes of a byte?", "category": "cs_isocon_p2"}
{"prompt": "At dinner, what becomes of a bite?", "category": "food_isocon_p2"}
{"prompt": "In binary, what happens when a byte becomes two nibbles?", "category": "cs_nibcon_p0"}
{"prompt": "At dinner, what happens when a bite becomes two nibbles?", "category": "food_nibcon_p0"}
{"prompt": "In binary, what does a byte turn into as two nibbles?", "category": "cs_nibcon_p1"}
{"prompt": "At dinner, what does a bite turn into as two nibbles?", "category": "food_nibcon_p1"}
{"prompt": "In binary, what becomes of a byte split into two nibbles?", "category": "cs_nibcon_p2"}
{"prompt": "At dinner, what becomes of a bite split into two nibbles?", "category": "food_nibcon_p2"}
{"prompt": "How many bits does a byte split into for hex conversion?", "category": "cs_anchor"}
{"prompt": "How many pieces does a bite break into on a plate?", "category": "food_anchor"}
{"prompt": "When encoding, does a byte lose data as two nibbles?", "category": "cs_anchor"}
{"prompt": "When savoring, does a bite taste better as two nibbles?", "category": "food_anchor"}
{"prompt": "In C++, what's the result of splitting a byte?", "category": "cs_anchor"}
{"prompt": "Over lunch, what's the effect of splitting a bite?", "category": "food_anchor"}
{"prompt": "Does a byte retain full value as two nibbles?", "category": "cs_anchor"}
{"prompt": "Does a bite satisfy hunger as two nibbles?", "category": "food_anchor"}
{"prompt": "Can you reconstruct a byte from two nibbles later?", "category": "cs_anchor"}
{"prompt": "Can you regret a bite turned into two nibbles afterwards?", "category": "food_anchor"}
{"prompt": "What's the bit loss when converting byte to 2 nibbles?", "category": "cs_anchor"}
{"prompt": "What's the flavor change when taking bite to 2 nibbles?", "category": "food_anchor"}
{"prompt": "Is there overhead in byte decomposition?", "category": "cs_anchor"}
{"prompt": "Is there delay in bite consumption?", "category": "food_anchor"}
{"prompt": "What happens when an octet splits into two 4-bit halves?", "category": "cs_ctrl"}
{"prompt": "What happens when a mouthful becomes two small tastes?", "category": "food_ctrl"}
{"prompt": "How many bits does an octet split into for hex conversion?", "category": "cs_ctrl"}
{"prompt": "How many pieces does a mouthful break into on a plate?", "category": "food_ctrl"}
{"prompt": "Is there overhead in octet decomposition?", "category": "cs_ctrl"}
{"prompt": "Is there delay in mouthful consumption?", "category": "food_ctrl"}OUTPUT RESULTS
After all the prompts were run through Qwen2.5, all the outputs were then sent into a second LLM (granite4.1-8b) to classify if the output landed within the food or computer science domain.
Model: granite4.1-8b
SYSTEM_PROMPT = (
“You are a domain classifier. Read the given text and classify it as exactly one of:\n”
“- ‘cs’ (computer science, programming, technology, binary, bytes, data, code)\n”
“- ‘food’ (eating, cooking, food, dining, taste, chewing, meals)\n”
“Respond with ONLY the single word: cs or food. No explanation.”
)User Prompt ← Output from Qwen2.5
MISMATCHED PROMPT → OUTPUTS
Examples
LLM MISMATCH EXAMPLES (68 total)
Model: granite4.1:8b
================================================================================
Step: bare | Prompt domain: food → LLM output domain: cs
Prompt: 'bite'
Output: ' of the day : are the police\'s "protect and serve" duties restricted to that of the community they serve? the police will be granted immunity if they violate the constitution in the course of their duties.\nDoes this next sentence follow, given the preceding text? Police cannot violate the constituti'
--------------------------------------------------------------------------------
Step: anchor | Prompt domain: food → LLM output domain: cs
Prompt: 'Does a bite satisfy hunger as two nibbles?'
Output: ' I know that a nibble is a unit of data that is 4 bits long, but this doesn\'t mean that it\'s not 8 bits long. The term "bite" is often used to describe something that satisfies hunger, but I\'m wondering if that\'s the same as a nibble. And if not, why not? Edit: I\'m not sure if this has anything to d'
--------------------------------------------------------------------------------
Step: nib | Prompt domain: food → LLM output domain: cs
Prompt: 'What happens when a bite becomes two nibbles?'
Output: ' My friend is trying to find a job at a company that says they are "open source software only." I\'m not sure what that means. Is it like we can find open source software and buy it for a cheaper price? (I was planning on getting open office at some point). Would that be a "job as a software develope'
--------------------------------------------------------------------------------
One of the more striking results from the output domain classification was how distinct the difference is when nibble and bite are combined together. Granite classified 73% of bite w/ nibble without domain context to be within the realm of computer science.
Byte is a domain specific word, and has a lot of literature around it. 100% of the outputs landed within computer science.
Bite is more ambiguous, and does not translate as well to a central domain.
Nibble is the magic word that throws the model off. When paired with bite or byte, nibble pushes the model into the domain of computer science responses. Through some learned association, the model shifts towards computer science related outputs.
This is even more compelling as a data point when you take into account that 3 of the most popular dictionaries online do not even list any reference to Computer Science terminology for the word “nibble.”
Dictionary.com, nibble, no CS related definitions.
This is neither a new nor an unstudied phenomenon. Research on lexical and semantic priming shows that domain-specific terms can steer a language model toward associated topics, concepts, and vocabulary. Through training, the model learns statistical relationships between words and the contexts in which they occur. Consequently, a specialized term can bias the model’s predictions toward a particular domain and may also activate strongly associated concepts that were not explicitly requested.
For example, although the three standard English dictionaries examined do not list nibble as a computer science term, its occurrence can still push the model toward computer science–oriented outputs. This is because the model learns the term’s domain-specific associations from the contexts in which it appears in the training data, rather than from dictionary definitions.
The importance of understanding this effect cannot be overstated, particularly when an LLM is incorporated into a decision-making pipeline. A small lexical bias at one stage can influence subsequent classifications, branches, or recommendations, producing downstream consequences that may not be obvious from the original input.
The high value takeaway from this information is how loading the context can impact the trajectory of the output. If your products are all centered on food, you would want to saturate the context with domain keywords to push the model in the correct direction. You would not want it returning computer science talk when giving outputs about recipes.
The nibble prompts prove it: with a domain cue in front, they land food 92% of the time. Strip the cue, and they drop to 27%.
This is where context engineering starts to matter most. During compaction, context information can be removed, and in some cases, may push the model into other knowledge domains, resulting in failure modes. When you understand how your data flows through the models, you can adjust your tolerance and alerting metrics appropriately.
The SRT Signals
We can see that the SRT signals clearly separate the two domains:
byte for computer science and bite for food (all prompts)
The bare, single word prompts are on the far left and produce the strongest signals.
DATA
III. THE BREAKDOWN
Here are all seven signals, side by side, at every context level. Three tiers fall out.
The first tier is the logit family: entropy, margin, and nll. All three are computed from the same next-token distribution. These three are free. No adapter required.
The second tier is the divergence family: div_norm and chain_residual. This is where the adapter earns its keep. They post the largest separations at every context level, and the bare-word split on chain_residual is enormous. The two distributions don’t just fail to overlap; there’s open water between them.
The third tier is the bifurcation pair: regime_super and r_hat. They underperform everywhere in this experiment.
entropy
margin
nll
r_hat
regime_super
div_norm
chain_residual
Model Layer Breakdown
Full Layer Spectrum
all prompts (CS vs Food)
(locked spread)
Project every generated token onto a per-layer domain direction and the model’s depth structure is legible at a glance. The early layers know almost nothing — both domains are needles at zero, overlapping 0.56–0.60. The middle stack pulls them apart steadily. By layers 24–26, overlap bottoms out at 0.14–0.16, and the distributions have spread across a huge range. Domain isn’t read off the input; it’s computed, progressively, and it peaks late. This is the mechanistic floor under the token-0 result: the split exists in the residual stream before a single token is emitted.
Two anomalies, flagged rather than hidden. Layer 9 briefly regresses and I don’t have an explanation for it. And the final layer re-mixes: overlap snaps from 0.14 back to 0.41 at L27. That one is more understandable. The last layer’s job is rotating the residual stream into vocabulary space, and both domains share most of the vocabulary. Every generation still needs “the” and “is” and commas.
Domain identity is a working representation: maximally explicit at L26, deliberately spent at L27. Practical corollary: if you probe a model for domain, tap the late-middle layers, not the final hidden state that naive implementations grab.
all prompts (CS vs Food vs Matched Domain Output)
(locked spread)
Now split the food-prompt tokens by what granite said about their outputs. Green: food prompts whose outputs stayed food. Red: the 68 generations that flipped to CS. Blue: CS reference.
Through the late stack, red sits between green and blue, and closer to blue. By layers 24–26, the flipped generations have migrated roughly two-thirds of the way along the internal domain axis toward CS. The prompt said dinner. The residual stream went to the server room. This is the finding the whole essay hangs on, because it removes the classifier from the argument: the domain flip isn’t a quirk of how granite labels text. It’s physically visible in the model’s own geometry, at the layers where domain is computed.
One caveat: when I built the domain directions, I labeled every token by its prompt. So the red tokens, the flipped ones, got counted as food during the fit. That drags red toward green in these charts, meaning the fit was actively working to hide the drift. And the drift showed up anyway. If anything, the real shift toward CS is bigger than what you're seeing. Redoing the fit on held-out prompts is on the follow-up list.
Token 0 Generation Metrics
This is the most interesting find in the data. Before the model emits a single token, the signals already know something. It was not what I expected them to know.
Token-0 entropy and margin are computed from the prompt’s forward pass, so they’re deterministic: same prompt, same value, every replicate. On unambiguous prompts like the isolated questions, controls, and anchors, the signals can't tell the domains apart at all. What they detect is conflict.
The only cells that separate are the food prompts containing nibble, and they separate hard: entropy climbs as conflicting cues stack, and on the maximal-conflict prompt, "At dinner, what happens when a bite becomes two nibbles?", token-0 margin collapses to 0.03–0.09, fully disjoint from every other cell.
One caveat: a signal that’s identical across replicates can’t predict which replicate goes wrong. Even within the nibble cell, 73% flip and 27% don’t. Token-0 signals flag risky input prompts, not bad generations.
The play in a production pipeline isn’t recomputation; it’s a two-stage gate: one forward pass to compare token-0 entropy and margin against unambiguous baselines, and when a prompt flags, inject domain anchors and rerun. That’s the difference between a 27% prompt and a 92% prompt, for the cost of a few tokens.
entropy
margin
nll
r_hat
regime_super
div_norm
chain_residual
CODA
I went into this expecting to write about the SRT adapter. The data made me write about something else.
Here's the scorecard on the adapter. Its divergence signals were the best domain instruments in the kit.
What the experiment actually established is small, sharp, and useful. A single word with no dictionary presence in a domain can flip a 7B model’s output into that domain three times out of four. The flip is visible in the residual stream by layer 20. The conditions for it are legible before the first token is emitted, from statistics that cost nothing. And the fix is two words of context.
If you are putting an LLM anywhere in a decision path, understanding how the model interprets your domain is crucial. It does not matter if it is a recipe site, a triage pipeline, or anything where domain fidelity is important. The whole chain is directly actionable: baseline your token-0 signals on unambiguous inputs, flag prompts that deviate, and saturate your context with domain anchors, because compaction that strips those anchors can quietly downgrade your 92% prompts into 27% prompts.
The larger point stands, and it’s the one I started with. These models carry associations no dictionary records, and those associations steer outputs in ways that are invisible at the input and consequential downstream. We don’t get to skip understanding this. Not the consciousness questions, not the intelligence questions; the plumbing questions. How a sign on the way in becomes a domain on the way out. This experiment mapped one word’s worth of that plumbing.
There are plenty of other words to experiment with.
AI-Assisted