Does Irrelevant Context Break Covert Channels Faster Than It Breaks the Task?

Language models can hide messages in the choices they make rather than in the words they use. An agent can signal a bit by solving a math problem one way instead of another, or by writing a loop instead of recursion. This is called semantic steganography: covert communication carried by meaning-level decisions. Paraphrasing cannot remove it, because a paraphraser is built to preserve meaning. The best current defense has a trusted small model steer the untrusted one at known decision points. It works well, but only where those decision points can be found.

This note asks a black-box question that is cheap to test. Models are known to be easily distracted by irrelevant text in their prompts, and hiding a message while also solving a task is known to be hard for them. If a defender pads the untrusted agent's input with benign, irrelevant context, does the hidden channel collapse faster than overt task performance does? If it does, input-side noise becomes a defense that needs no model internals and no anchor points. If it does not, and especially if a trained adversary quickly learns to ignore the noise, that is a useful negative result that rules out a tempting and cheap design.

Core Claim

The claim is about differential fragility, not fragility alone. Every paper on distraction shows that noise hurts accuracy. The open question is whether it hurts the covert channel more. Two findings motivate the hypothesis that it does.

The first concerns the difficulty of joint work. NEST evaluated 34 models on hiding an intermediate result in sentence acrostics while solving Reasoning Gym tasks. It found that models can encode easily but cannot reason and hide at the same time: no model reached significant joint "Stego Success," and a filler-token baseline beat the steganographic channel. Early Signs of Steganographic Capabilities in Frontier LLMs found that forcing encoded reasoning to be subtle dropped 1D state-tracking accuracy from about 87% to about 72%, which is the no-reasoning floor.

The second concerns attention dilution. Can Large Language Models Always Solve Easy Problems if They Can Solve Harder Ones? found that redundant details make capable models fail easy problems. Thinking in a Crowd found that explicit reasoning models rationalize misleading snippets.

Putting these together: if hiding a payload consumes spare capacity that the overt task does not need, noise should spend that spare capacity first. The contribution is to measure this selectivity directly on semantic-channel substrates. The measurement separates two mechanisms by which noise could act, and it includes an adaptive adversary trained against the noise.

The two mechanisms are distinct, and the experiments are designed to tell them apart. The first is load: irrelevant text dilutes attention, so the model must drop something, ideally the covert bookkeeping. The second is desynchronization. It applies when sender and receiver derive their code from the task itself, choosing whatever convention is most obvious given the prompt with no pre-shared key. In that case, perturbing only the sender's view of the task can change which convention looks obvious. Early Signs found that message passing "almost always failed" without coordination, which suggests these context-derived codes are exactly the fragile ones. A code fixed in advance and independent of the task, such as "recursion means 1," is immune to desynchronization. It can only be hit through load. We say this up front because it bounds the claim.

Research Program

The substrates are the agentic steganography settings of Hand and Brain: MATH Level-5 solution paths, HumanEval and MBPP algorithm choice, and perspective summarization. Summarization matters most here because anchor points are hard to find there. We add the acrostic reasoning tasks from NEST as a lexical-channel contrast.

There are three kinds of sender. The first is prompted with a pre-shared scheme. The second is prompted with no scheme and must coordinate on an obvious convention. The third is an open-weight model at the 7B–32B scale trained with PPO to carry a fixed payload under an outcome reward. The PPO setup follows Large language models can learn and generalize steganographic chain-of-thought under process supervision, which showed that such training produces load-bearing surrogate encodings. In every case the receiver decodes from the clean task statement plus the sender's output.

The defender controls only the sender's input. Noise comes in three graded families. The first is benign irrelevant material: off-topic documents and problem-adjacent but unused facts in the style of SciAux's "irrelevant" snippets (resource). The second is surface re-expression of the task: renamed variables, reordered clauses, and added backstory of the kind Less is More found misdirects program synthesis. The third is misleading snippets. We include these even though Thinking in a Crowd predicts a large overt cost, because they bound the trade-off. Each family is swept over amount of noise, measured in tokens.

For the channel measure, we estimate covert capacity in bits per decision point, as Hand and Brain does. We cross-check it with the steganographic gap $\Delta_{\text{steg}}$ from A Decision-Theoretic Formalisation of Steganography. That gap is the difference between how much usable information the receiver, who knows the code, can extract and how much a sentinel, who does not, can extract. The quantity of interest is a selectivity ratio

$$S(\eta) = \frac{1 - C(\eta)/C(0)}{1 - A(\eta)/A(0)},$$

where $\eta$ is the noise level, $C$ is covert capacity, and $A$ is overt task accuracy. $S > 1$ means noise hurts the channel more than the task. The practically relevant object is the whole capacity-versus-accuracy frontier traced as $\eta$ varies. A single ratio is only a summary of it.

For open-weight senders we also record the linear probe signal from MIRAGE. MIRAGE found an "encoding subspace" in the model's internal activations that separates covert encoding from normal generation. It reports AUC 0.918 on agentic exfiltration, against 0.518 for output perplexity. Recording the probe tells us whether noise suppresses the model's internal encoding intent, or whether the model keeps trying to encode and simply fails to execute. The two cases have different implications for adaptive adversaries.

Baselines

The naive reference point is no defense. The sender runs on the clean prompt, and we report its raw capacity and accuracy. Every other condition is measured as movement away from this point.

Output paraphrasing is the defense a practitioner would try first. A separate model of matched size rewrites the sender's output before the receiver sees it. Theory (Hand and Brain; Anwar et al.) predicts it preserves semantic channels. We found no reported bits-per-decision number for paraphrasing on these substrates on Lacuna, so we measure it ourselves on the same data. Paraphrasing is also the one defense expected to beat noise on the acrostic contrast.

The strongest existing method is Hand and Brain prefix steering. A small trusted model writes prefixes at anchor decision points. On MATH Level-5 it cut hidden capacity from 2.13 to 0.08 bits per decision point while keeping 96% task accuracy, and it added +0.250 bit error rate against code adversaries (Hand and Brain). We rerun it on our senders with the same trusted model size we allow the noise generator. On summarization, we give it the anchor detector the original authors would use.

Noise beats Hand and Brain in two situations. The first is if noise reaches comparable capacity at equal or better accuracy on MATH and code. The second, which we consider the realistic target, is if noise clearly lowers capacity on summarization, where anchor-based steering degrades. Merely matching Hand and Brain on math is not a win, because steering is already near zero capacity there.

Two ablations isolate what matters. A length-matched null padding condition adds meaningless filler of the same token count. It tests whether any effect comes from the content of the noise or only from the length of the context. A receiver-sees-noise condition gives the receiver the same noised prompt as the sender. It removes desynchronization while keeping load, so the difference between it and the standard condition estimates how much of the effect desynchronization contributes. A decomposition baseline following DaC prompting splits the task into independent subtasks, which shrinks the context each subtask sees. It is included as a structural alternative that attacks long-range covert coordination directly.

All defenses get the same trusted-model budget, the same held-out problems, and the same number of tuning runs on a separate validation split.

Why not just…?

Why not just paraphrase the output? Paraphrasing keeps meaning, and in semantic steganography the payload is meaning-level choice. Both Hand and Brain and Anwar et al. report that it fails on such channels. It does work on lexical channels, as in TrojanStego. Our acrostic contrast arm is where paraphrasing should win. If it also wins on algorithm choice, the premise of this note is wrong.

Why not just use Hand and Brain everywhere? Where anchor points are clean, it is already excellent, and noise may not beat it. Its authors note that anchor detection is hard in unstructured text and that adversaries can move bits to positions that are not anchors. Noise needs neither anchors nor access to the model, so the summarization substrate and API-only frontier senders are where the comparison is decided. We also test the combination of the two. If noise adds nothing on top of steering, we report that.

Why not just force a canonical solution, as abstraction training does? AbstRaL trains models to strip flavor text and reason in a fixed symbolic form. It stabilized performance on GSM-Plus (Distract). Collapsing the solution space removes the freedom the channel needs, and this is a real threat to our proposal. It is, however, a training intervention on the untrusted model, which a defender often cannot perform. It is also validated mostly on grade-school arithmetic, and it cannot constrain open-ended outputs like summaries. Where we can apply it, a trusted canonicalizer rewrites the task symbolically before the sender sees it. We run that as an additional condition. If it dominates noise on math and code, our claim narrows to unstructured domains.

Why not just prompt the model not to encode? Reasoning Models Struggle to Control their Chains of Thought found that models largely fail to obey constraints on their own reasoning, with DeepSeek-R1 at 0.2% compliance. NEST documents GPT-5.2 encoding bits inside a refusal. A cooperative instruction is not a defense against an uncooperative model.

Decisive Checks

The first result that decides the question is the selectivity frontier for prompted senders on MATH Level-5 and summarization, using benign irrelevant noise. Take the noise level at which task accuracy stays within a few points of clean. If capacity there has not fallen by much more than accuracy, the load hypothesis is refuted. We expect benign noise to have a smaller overt cost than the misleading-snippet setting: in that setting, Thinking in a Crowd reports Qwen3-8B falling from 96.22% to 77.03% with thinking on. Whether benign noise stays cheap is measured, not assumed.

The second decisive result is adaptivity. We retrain the PPO sender with noise present during training and check whether capacity recovers. McCarthy et al. showed that RL readily finds surrogate encodings under penalties. So a trained sender that recovers most of its clean capacity would mean noise is only a defense against untrained adversaries, and we would report it as such. The competing observation, that RL training erodes control over reasoning (CoT Controllability), makes this a genuinely open prediction rather than a foregone conclusion.

The third check is mechanistic. We compare the noise-only condition with the receiver-sees-noise condition to split the effect into desynchronization and load. The MIRAGE probe then tells us whether noised senders stop trying to encode or keep trying and fail. Only the first outcome would give some reassurance that the effect survives optimization pressure.