As Large Language Models (LLMs) become deeply integrated into writing, coding, and communication, distinguishing human prose from machine-generated text has become a critical challenge. One of the most elegant solutions proposed is statistical watermarking. By subtly biasing a model's token choices during generation, creators can embed an invisible signature that can be mathematically verified later.
However, a major vulnerability threatens the viability of these systems: token-level fragility. Because these watermarks are tied to the exact surface-level sequence of tokens, simple edits or automated paraphrasing can easily erase the tracking signal without altering the underlying meaning of the text.
How Token-Level Watermarks Work
To understand why watermarks are fragile, we must first understand how they are constructed. In the foundational framework introduced by John Kirchenbauer et al., watermarking operates as a pseudo-random partitioning of the model's vocabulary.
[ Token t-1 ] ---> Hash Function ---> Seed ---> Vocabulary Split:
- Green List (Allowed/Biased)
- Red List (Restricted)
During text generation, the model determines the next token $t$ based on the tokens that came before it. To embed a watermark, a hash of the preceding token $t_{-1}$ (or a small window of context tokens) is used as a random seed to split the entire vocabulary into two groups: a "green list" and a "red list." The model's raw output probabilities are then biased to favor tokens on the green list.
When verifying the text, a detector with access to the same hash function recomputes the green/red split for every token position. If a document contains an anomalously high proportion of green tokens, the detector can mathematically prove the text is synthetic.
The Butterfly Effect of Token Edits
The core vulnerability of this approach lies in its strict dependence on local context. Because the green/red list for token $t$ is determined by the exact cryptographic hash of token $t_{-1}$, the system forms a rigid chain.
If a user makes a minor modification—such as deleting a word, inserting a comma, or swapping a word for its synonym—the hash chain breaks. Changing token $t_{-1}$ completely scrambles the pseudo-random seed for token $t$. Consequently, the green/red list partition shifts unpredictably. Even if the model originally selected a green token, the detector, now calculating the split based on the edited context, will see it as a random choice.
This "alignment sensitivity," as described by Ankur Moitra et al., means that localized edits do not just obscure the watermark at the edited position; they disrupt the detection state for subsequent tokens. As a result, traditional sum-based statistical tests can quickly collapse under the noise introduced by human editing or paraphrasing, as noted by Xiang Li et al..
Paraphrasing as a Semantic Attack
When an adversary uses a secondary language model to paraphrase watermarked text, this vulnerability is exploited systematically. Paraphrasing models naturally alter sentence structures and substitute vocabulary while preserving the core semantic meaning.
Original (Watermarked): "The cryptographic key ensures data integrity."
|
[ Paraphraser ]
v
Paraphrased (Scrubbed): "Data security is maintained via the encryption key."
As demonstrated by Vinu Sankar Sadasivan et al. and Megha Chakraborty et al., recursive paraphrasing effectively strips away token-level statistical signatures. Because traditional watermarks operate on the surface level of token selection rather than the underlying logic or message (Yapei Chang et al.), any transformation that alters expression while maintaining meaning attenuates the signal (Xuanli He et al.). This vulnerability is not unique to natural language; the work of Hao Huang et al. shows that watermarked source code faces identical fragility when passed through structural source-to-source transformations like compilation and decompilation.
Why Some Signals Survive: Leaked N-Grams
Despite this fragility, token-level watermarks possess a property that allows them to survive minor editing: n-gram leakage.
In an analysis of watermark reliability under human and automated rewriting, John Kirchenbauer et al. observed that paraphrasing rarely rewrites a document completely from scratch. Instead, short sequences of the original tokens (n-grams) tend to persist in the modified output.
Because the watermark bias is distributed globally across the entire generation process, these leaked fragments still carry the original green-list bias. If the analyzed text is long enough, aggregating the signal across these surviving fragments can yield enough statistical evidence to achieve high-confidence detection. This explains why distributed statistical signals can remain resilient to localized modifications, even when the continuous chain of hashes is broken.
Designing Around Fragility
To mitigate token-level fragility, the research direction has shifted toward decoupling the watermark from exact token sequences.
One approach is semantic or context-aware watermarking. For example, Yuxuan Guo et al. developed a framework where green lists are generated based on the semantic embeddings of preceding phrases rather than exact token hashes. If an attacker replaces a word with a synonym, the semantic embedding remains stable, keeping the downstream green lists intact.
Another direction focuses on lexical redundancy. As proposed by Liang Chen et al., grouping synonyms together into the same green or red categories ensures that the watermark aligns with semantic concepts rather than individual tokens, making the signature significantly harder to scrub via standard rewriting.