Watermarking for LLM text is usually framed as detection: given a passage, decide whether a model wrote it. The harder production question is attribution. When a short AI-generated text leaks, which account or session did it come from? Detection answers whether; attribution answers who. On 12 November 2026 a paper posted to arXiv, Look It Up: Multi-bit LLM Watermarking via Codebook Search, by three authors from the Institute of Computer Science of the Polish Academy of Sciences and Australia's CSIRO, pushes short-form attribution a step closer to engineering practice: 24 bits of identity, stably embedded across 200 generated tokens.

The scheme: stop decoding bit by bit and look it up

Multi-bit watermarking has struggled on short texts: with more payload bits you either wait for a long text to accumulate signal or pay heavily at the decoder. This paper turns coding into a table lookup. At embed time an n-bit identity is mapped to a longer u-bit codeword (u greater than n; the redundancy is the error-correction budget). During generation the vocabulary is split into green and red halves by a hash of the previous token and the secret key, following the green-list idea of Kirchenbauer et al., 2023; a logit bias (default strength 6) is added to the green half when the current bit is 1 and to the red half when it is 0, with greedy decoding by default. Extraction needs only the secret key and the model's tokenizer: re-tokenize the text, read back one noisy bit per token, then find the nearest codeword in a precomputed secret codebook, by Hamming or Levenshtein distance.

The codebook is a random linear code over GF(2): the matrix and offset derive from the key via SHA-256, so the codebook cannot be rebuilt without it. The paper does the engineering arithmetic: at n = 24 and u = 127 the minimum Hamming distance between codewords is 35 — Hamming search corrects up to 17 flipped bits — and the bound on two identities colliding onto the same codeword is on the order of 2 to the minus 80.

The numbers: base models near-perfect, instruct models expose the weak spot

Per the paper's own runs, on 200-token texts from Llama 2 7B, 16-24 bit payloads are recovered at 99.8-99.9%; in the same comparison table the five prior methods span 30.4% to 99.6% over that payload range. Move to 127-token short texts with a 24-bit payload and the four base models (Llama 2 7B, Llama 3.1 8B, Llama 3.2 3B, Mistral 7B) land at 97.5-100%, while the two instruction-tuned models fall behind: the codebook variants bottom out at 61.6% at 127 tokens and climb back above 90.6% at 200. The explanation is blunt: low-entropy, peaked output distributions overpower the bias signal.

Speed is why this scheme can talk about deployment: at n = 24 the codebook holds roughly 16.8 million codewords, and exact brute-force search takes 4.1-75.5 ms per text (Hamming on CPU to Levenshtein on GPU, measured on an AMD EPYC 7302 with one RTX 5090). On robustness, the Levenshtein variant keeps a 95.2% match rate after 10% of words are deleted and 98.9% after paraphrasing of a span of the same size; word insertion is the hard case at 57.3%, and synonym replacement drops to 76.4%. Separating watermarked from non-watermarked text, all three variants reach AUROC above 0.998.

The costs: perplexity more than doubles, and the codebook eats RAM

There is no free watermark. In the paper's own quality evaluation, median perplexity on 200-token Llama 2 7B texts rises from 4.22 to 9.58 (evaluated with Gemma 4 31B) — more than doubling; human readers may not notice, statistics will. On storage, the n = 24, u = 127 codebook takes about 256 MB with indexes on top; a 32-bit payload would need about 64 GB in this framework, so longer identities must be split into blocks. And a structural limit: embedding requires access to logits, so only whoever runs the model can do it — a platform self-certification tool, not third-party forensics. Leak the key and the whole attribution scheme is dead.

So what

The value here is not one more high recovery rate; it is a legible engineering ledger for short-text attribution: millisecond lookup, hundred-megabyte codebooks, quantified quality loss, and clearly priced weak spots (instruct models, insertions, heavy rewrites). As regulators and platforms get serious about traceable AI output, these are the accounts that will get audited. The flip side: if the party running the model has no incentive to embed, the prettiest codebook stays a number in a paper — the fundamental problem in attribution watermarking is incentives, not coding.

Would a platform volunteer to plant ID cards in its own outputs? That question is worth more than any recovery rate.

Paper: arxiv.org/abs/2611.16890 Code: github.com/jaroslawjanas/llmw-codebook