← All news
Tech Blog

ARBI CITY advances AI text watermarking for the EU and beyond

We have implemented a version of Anthropic's and Google's breakthrough AI text watermarking technology, and will be making it available to anyone under an open-source license. Thanks to this breakthrough, anyone self-hosting AI models will be able to attach an invisible digital fingerprint to all AI-generated text. Try our interactive demo and read all about how it works.

Part 1 · The regulatory context

On August 2, 2026, transparency obligations of the European Union's AI Act came into force for the companies that make general-purpose AI. Around 190 signatories — Anthropic, Google, and most major model providers among them — had signed an EU Code of Practice on Transparency of AI-Generated Content, which requires them to mark machine-generated content so that it can be identified.

For images, that's a familiar idea: cameras and editing tools already attach signed provenance metadata (a standard called C2PA), and Google has shipped an invisible pixel-level watermark, SynthID, since 2023. But text seemed like the impossible case. Text has no pixels and no metadata that survives copy-paste. Any invisible character trick dies the moment someone retypes a paragraph.

The answer the industry converged on hides the mark somewhere no one can strip it from without rewriting the text: in the choice of the words themselves. Google DeepMind published the method — SynthID-Text — in Nature in October 2024, and disclosed it was already running on live Gemini traffic. In August 2026, Anthropic announced that Claude's output is watermarked with a version of the same technique, licensed from Google. Both say a reader cannot tell the difference; both say only someone holding a secret key can check for the mark.

Those are strong claims of great public interest — they touch schoolwork, journalism, courts, and elections. They deserve to be understood rather than taken on faith. So this article does the thing that settles arguments: a full, original reproduction — the method explained, the claims read critically, the whole scheme rebuilt on an open-source inference engine with an open model, every claim measured — and the live detector beside this text for you to test yourself.

Part 2 · How an AI chooses its words

A language model writes one small piece of text at a time. At every step it looks at everything written so far and produces not a next word, but a menu of candidate next words, each with a probability. After "The weather today was cold and…", the menu might say: overcast 31%, grey 27%, windy 18% … sugary 0.001%.

“The weather todaywas cold and…”modelovercast31%grey27%windy18%sugary0.001%random drawpicks in proportionto the odds
Each step, the model emits a weighted menu; a random draw — not a fixed rule — picks among the plausible candidates. That randomness is where the watermark lives.

What happens next is a deliberate roll of the dice. The system does not always take the top word — always taking the favorite makes text repetitive and lifeless. Instead it samples: it picks overcast about 31% of the time, grey about 27% of the time, and so on. A setting called temperature controls how adventurous the roll is — higher temperature flattens the menu and gives underdog words more of a chance; that's the "creativity" dial.

Hold on to the key fact: at most steps, several words are almost equally good, and which one gets picked is settled by chance. Nobody — not the reader, not the model — cares whether a particular sentence said overcast or grey. That freedom is unused capacity. The watermark is built entirely out of it.

Part 3 · The trick: loaded randomness

Here is the whole idea in one sentence: keep rolling dice, but replace the casino dice with a pair only you can recognize.

Anthropic's own analogy is a good one. Imagine playing a board game where, instead of rolling a die, players read successive digits of π from a book, starting at a random page. To everyone at the table the game feels identical — the moves are just as unpredictable. But afterwards, anyone with the book could check the record of moves and say: these rolls match π; this game used the book.

The text watermark does exactly this. When the model needs randomness to pick the next word, the watermarked system doesn't ask a random number generator. Instead it computes the randomness from two ingredients:

  1. A secret key — one big number the provider keeps private.
  2. The last few words already on the page — a sliding window of recent context (four tokens, in the published configuration and in ours).

These are stirred together by a hash function into a number that behaves exactly like a fair roll — but is reproducible by anyone holding the key. The pick still lands on overcast 31% of the time and grey 27% of the time. Nothing is added to the text. No hidden characters, no extra tokens, no metadata. The mark is the pattern of which plausible word won each coin flip.

ORDINARYrandom generatornoiseWATERMARKEDkeylast 4 tokenshashkeyed noisemenu odds+ noise→ pick winner“overcast”same odds either way —only the noise source changed
The one thing that changes is the source of the noise. Both paths feed the identical pick-the-winner step, so the odds of each word are untouched — but the keyed path can be replayed later by anyone with the key.

Detection is then simple in spirit. Take a suspicious paragraph. For each word, look at the few words before it, recompute the keyed noise with the secret key, and ask: was this word a "lucky" pick under that noise? In unmarked text, luck averages out — 50/50. In marked text, word after word lands lucky. Thirty lucky words in a row is a coincidence of astronomical odds; the detector turns that into a probability. That's the entire endpoint: text in, "odds this is a coincidence" out.

Part 4 · Reading the claims properly

The public statements from the providers are, in our reading (and after reproducing the method), technically accurate — but every one of them has a precise scope that the headline version loses. Here is the fine print made explicit.

“Watermarking doesn't affect quality.”

True asEach word's odds are mathematically unchanged — this is a theorem about the sampling trick, not a tuning result, and we verify it empirically below. Google also A/B-tested it on live traffic and users couldn't tell.Not"Nothing about the output changes." With a fixed key, the same prompt now yields the same response every time instead of a fresh variation, and asking for five drafts yields five copies. The per-response quality is intact; the variety across retries is what's spent to pay for the watermark.

“It can't be traced to you.”

True asThe key is one global secret per provider, mixed only with the visible text itself. There is mathematically no room in the signal for a user ID, org, or conversation — the detector's only possible output is "this provider's models were likely involved."Not"AI use is undetectable to your school/employer." That's the exact opposite of the point: anyone with access to the provider's detector can learn that the provider's model touched the text — just never who ran it.

“Detection tells you if AI wrote it.”

True asA positive result is rock-solid: the false-positive rate is a mathematical guarantee you can set (our demo runs at one-in-a-million), because unmarked text is provably 50/50 luck.NotA negative proves nothing. Short snippets, heavily edited text, factual answers with only one right phrasing, code, another provider's model, or any open-weights model someone runs themselves — all come back "no signal." The detector can confirm involvement; it can never certify human authorship.

“It costs nothing and adds no delay.”

True asNo extra tokens are generated and no extra model computation runs; the only change is arithmetic inside the word-picker. We measured our own reproduction end-to-end at 0.1–0.2% throughput cost — on a deliberately worst-case rig — once that arithmetic was implemented carefully (numbers below).Not"Free automatically." Our first, naïve implementation cost ~10% on a tiny fast-stepping model — negligibility took a fused kernel to earn, and ours is still just one unoptimized reproduction. Also not free in every configuration: speculative decoding needs explicit engineering to stay compatible, and our reproduction refuses that combination rather than silently skip the mark.

“Light edits won't remove it.”

True asThe mark is spread across every free word choice, keyed by a four-word window. Changing a word only disturbs the handful of windows that overlap it; the rest of the text re-synchronizes immediately. You can watch this live in the detector (the ⚡ button).Not"Robust to rewriting." Paraphrase every sentence and the signal is gone — at which point, as Anthropic notes, calling the result "AI-generated" is itself debatable.

One more thing the claims quietly assume, worth saying out loud: all of this happens inside the provider's serving stack. The model's weights are untouched. Which means the same open-weights model, run by anyone else, produces unmarked text — and conversely, any operator of an inference engine can add such a watermark. That's exactly what we did.

Part 5 · Questions people actually ask

These are the questions that matter in real life — for students, employees, writers, and anyone whose words might one day be run through a detector.

▸Will my teacher or my boss be able to tell I used AI?

Sometimes — and it's worth being precise about when. If you paste in largely-unedited output from a watermarked model, and the person checking has access to that provider's detector (Anthropic has announced one but hasn't shipped it publicly yet), then yes: the text itself can testify that the provider's model was likely involved. What the detector can never reveal is who ran the model, on which account, when, or in which conversation — the mark simply has no room for that information. And the more you rewrote in your own words, the weaker the signal gets, until it's gone.

▸Could I be falsely accused of using AI by this?

This is where watermark detection is better than what exists today, and the distinction deserves to be widely understood. Today's "AI detectors" guess from writing style — and they have wrongly flagged honest work, notoriously including text by non-native speakers. A key-based detector doesn't look at style at all. Its false-alarm rate is a mathematical dial the operator sets: at the threshold used in this page's demo, unmarked text triggers a false alarm about once in a million checks, and that guarantee holds for every writer, in every dialect, forever. If a key-based detector fires, the evidence is real. If it stays silent, it says precisely nothing — silence is not a human-authorship certificate.

▸Is this a form of tracking? Does my chat get embedded in the text?

No. The only ingredients in the mark are the provider's single global key and the words you can already see on the page. Nothing about you, your account, your device, or your conversation goes in — not because of a privacy policy, but because there is mathematically nowhere to put it. Every user of the same model shares the same key; the strongest statement any detector can ever produce is "this provider's model likely chose these words."

▸I wrote it together with the AI, and edited a lot. What will a detector say?

The honest answer: "this provider's model was probably involved" — full stop. The mark degrades smoothly as you edit (you can watch this happen with the sliders in the ⚡ detector), so a heavily-reworked draft may fall below detection entirely, and a lightly-touched one won't. But detection can never measure percentage of authorship, and it cannot distinguish "the AI drafted, I rewrote" from "I drafted, the AI polished." Anthropic's own documentation says the same. Anyone treating a watermark hit as proof that a person didn't do the thinking is over-reading the evidence.

▸If I ask the AI to repeat my paragraph word-for-word, is the copy watermarked?

Effectively no — and the reason goes to the heart of the scheme. The keyed dice only leave a trace where the model has a genuine choice among words. When it's faithfully copying, every next word is a near-certainty: it wins no matter what the dice say, so no luck accumulates. We tested exactly this on our setup — asked the watermarked model to copy a paragraph of Lincoln word-for-word. It complied perfectly, and the 116-token copy scored a luck average of 0.535 (chance: 0.500) — a thousand times short of the detection threshold, where composed text of that length scores beyond 10⁻²⁵. Two consequences: quoted material inside an AI answer carries no mark, and the watermark can never prove that an AI echoed something — only that it composed something.

▸If there's no watermark, can I trust the text is human?

No — this is the single most important limit to internalize. Older models, other providers' models checked against the wrong key, open models anyone runs on their own hardware, text pushed through a paraphraser or translator, and genuinely human writing all look identical to a detector: silent. Watermarks build one-way evidence — positives you can take to the bank, negatives that mean nothing. Any workflow (or accusation) built on "no watermark, therefore human" is broken by design.

▸Could someone forge the mark — say, to frame a provider or a person?

Not from the outside. Making text score as "lucky" requires knowing which words the keyed dice favor at every step, and that requires the secret key. Without it, an attacker can no more plant the watermark than find it. That cuts both ways: it makes positives strong evidence, and it makes the key itself the crown jewel — the method is public science; only the keys are secret.

▸Can one provider's detector read another's watermark? What about translations?

Each provider holds its own key, so each detector is blind to everyone else's marks — "is this AI-generated, in general?" remains unanswerable. Translation splits cleanly in two: when the watermarked model itself translates, every word of the output is its own free choice, so the translation is fully marked. When marked text is translated (or aggressively paraphrased) by some other tool, every word gets re-chosen by a system without the key, and the mark is gone.

▸Can I just ask the model to skip the watermark?

No. The model doesn't know it's being watermarked — the mark is applied by the serving machinery around it, after the model proposes its menu of next words, and no prompt reaches that layer. There is one honest technical caveat: settings that remove randomness entirely (the "always pick the top word" mode some developer APIs expose) leave nothing to mark. Constrained, low-creativity output — exact code, arithmetic, one-right-answer facts — is faint for the same reason. The watermark is exactly as strong as the freedom the text was written with.

Part 6 · What it means

Three consequences follow from how the mark works, and they're worth stating plainly.

For users of the big providers: the watermark is real, invisible, and — read carefully — privacy-preserving in a specific, checkable sense: the signal has no room for identity. What changes is that "likely written with Claude/Gemini" becomes a verifiable property of text rather than a vibe.

For self-hosted AI: the mark lives in the serving stack, not the weights. Any operator can add it — this article's reproduction took one module in an open engine, and the same recipe applies to any sampler built on keyed noise. An operator required (or simply choosing) to mark their outputs can do so at effectively zero cost. But nothing forces the millions of self-hosted deployments to do it.

For society's expectations: because open models exist unmarked, a detector's silence means nothing — text with no watermark is not "human." What watermarking really builds is one-way evidence: positives you can trust with mathematical confidence, negatives that stay forever ambiguous. Policy and public understanding will have to live with that asymmetry, because it is fundamental, not an engineering gap.

Part 7 · The mechanism, precisely

Now the technical version, for readers who want the actual moving parts. (If formulas aren't your thing, skim the bold sentences — you already have the intuition.)

Efficient samplers don't literally roll against a probability menu. They use the Gumbel-max trick: add independent random noise gₖ (from the Gumbel distribution) to every candidate's score and take the maximum:

token = argmax_v ( logit_v / T  +  g_v ),      g_v = −log(−log u_v),  u_v ~ Uniform(0,1)

This is provably an exact draw from the softmax distribution at temperature T — the noise is large relative to score gaps, so underdogs win at exactly their assigned rate. The watermark (the Aaronson construction, 2022, which SynthID-Text builds on) changes one thing: the uniform numbers uₖ stop coming from an RNG and instead come from a keyed pseudorandom function of the sliding context window:

seed  = Hash( key , last H tokens )          # H = 4
u_v   = PRF( seed , v )                      # one uniform per candidate word v

Because the keyed numbers behave exactly like fair random numbers, every word's chances of being picked stay exactly what they would have been anyway — the no-quality-impact claim is baked into the construction, not promised by testing. What's new is that the key-holder can replay u for the word that actually won, at every position, from the text alone.

Detection is a one-sided luck test

For each position t, recompute uₜ = PRF(Hash(key, 4 tokens before t), tokenₜ). Under the null hypothesis — the text was not produced with this key — each uₜ is an independent Uniform(0,1): the hash of somebody else's words with our key is just noise. Under the watermark, winners tend to carry large u. Sum up the surprise:

S = Σ_t −log(1 − u_t)        null: S ~ Gamma(n, 1)   →   exact p-value

The false-alarm rate is therefore guaranteed by arithmetic, not by testing — no classifier, no training data, nothing to drift. Declare "watermarked" only below p = 10⁻⁶ and you will falsely accuse one text in a million, forever, by construction. Missing a real watermark is the other risk, and it works like a budget: every word adds a little evidence — more where the writer had a genuine choice, almost none where only one word would do (facts, code, quotes). Long, free-flowing text builds overwhelming evidence fast.

Three details that matter in practice

Repeated contexts are masked. If the same 4-token window recurs, reusing its seed would force the same word again — a repetition trap. The generator keeps a record of used windows (in our implementation, a per-request Bloom filter on the GPU) and falls back to ordinary randomness on repeats; the detector applies the same skip rule.

Edits are local, catastrophes aren't. The seed depends on a 4-token window, so a changed word corrupts only the ~5 windows overlapping it. The scheme re-synchronizes instantly — this is why light editing degrades the p-value gracefully rather than zeroing it (measured below, and live in the ⚡ detector).

Numerical noise in the model is irrelevant to detection. Serving stacks are not bit-deterministic — different batch sizes pick different GPU kernels, reduction orders shift logits by tiny amounts, and a near-tie can flip a word. That breaks byte-reproducibility of outputs, but the detector never touches logits: it replays only the keyed noise at the tokens that were actually emitted. Whichever way the numerics landed, the emitted token was a keyed-noise argmax over them — still marked, still detectable.

Part 8 · We rebuilt it: reproduction and measurements

To test whether the public claims survive contact with reality, we implemented the scheme in arbi-serve, our inference engine (limited preview), and ran it with Qwen3.5-0.8B (an open-weights model, unquantized bf16) on a single RTX 4090. Total implementation: one new module and a ~30-line hook in the sampler.

The engine's stochastic sampler already drew its Gumbel noise from a counter-based generator keyed on a seed — so the watermark reduced, almost literally, to changing where the seed comes from: a hash of the secret key and a GPU-resident window of each request's last four tokens. Detection is ~100 lines of pure arithmetic that needs no GPU and no model — this page runs it in your browser, bit-identically (verified against the engine to the last bit of the hash).

Correctness-neutrality: measured

CheckMethodResult
Distribution unchanged200,000 keyed draws vs. unkeyed sampler, same menumatch within Monte-Carlo error
Greedy output untouchedtemperature-0 tokens, flag on vs. offbit-identical
Engine test suitesfull CPU gate + GPU sampler suites10,016 + 41 passed, 0 failed
Output quality (real model)per-token NLL of completions, watermarked vs. control arm2.500 vs 2.441 nats (Δ +0.059 ± 0.255)
Degeneration / repetitiondistinct-n and longest repeat run, both armsdistinct-2 0.95 vs 0.93; max run 3 vs 2

Performance-neutrality: measured

ConcurrencyBaseline tok/s per requestWatermarkedΔ
1458.0457.4−0.1%
8339.8339.3−0.2%
64237.6237.6−0.0%

Per-request generation throughput, A/B with GPU clocks locked at 2.7 GHz, arms interleaved (base/wm/wm/base) and every request pinned to an identical decode length, so the only difference between arms is the watermark path. Two honest footnotes. First, "negligible" is earned, not automatic: our initial eager implementation cost ~10% on this deliberately worst-case rig (a tiny 0.8B model stepping in ~2 ms), because ~20 small GPU launches per step matter when steps are short; fusing the watermark into two kernels reduced the isolated sampler cost to ~35 µs/step, which the engine's pipelined run loop then hides almost entirely — the table above is the fused result. Second, this is one implementation, not fully optimized, measured on one small model; on production-scale models with 10–40 ms steps the same fixed cost is far below measurement noise, which is consistent with (though no proof of) the big providers' "no impact" claims.

Detection power: the endpoint's honest datasheet

ConditionMedian p-valueDetected at p<10⁻⁶
First 25 tokens10⁻¹⁰84%
First 50 tokens10⁻²²98%
First 100 tokens10⁻⁴⁰100%
Full completion< 10⁻³⁰⁰100%
Full, 5% of tokens edited< 10⁻³⁰⁰95%
Full, 10% edited10⁻⁴⁰94%
Full, 20% edited10⁻¹⁷84%
Unwatermarked control0.4690%
Watermarked, wrong key0.5990%

Why this matters if you self-host — and how to do it

Watermarking is usually discussed as something the giant labs do. But the mark lives in the serving stack, not in the model — which makes it just as available to anyone running open-weights models on their own hardware, and arguably more useful there:

Compliance is coming to deployers, not just labs. The EU's transparency obligations attach to AI systems placed on its market — and organizations serving fine-tuned open models are in that supply chain. A sampler-level watermark is the lowest-cost, most robust way to satisfy "machine-readable marking" for text.

Provenance for your own content. An organization running internal assistants can answer, with mathematical confidence, "did our bot write this?" — for auditing generated documents, tracing leaks of internal drafts, filtering model output out of future training data, or honoring publish-with-disclosure policies. Your key, your detector, no third party involved.

Trust as a feature. A provider who marks their outputs can prove what their models did and didn't write — which is a stronger position, the day a dispute arrives, than having nothing.

The recipe, for anyone whose engine samples with keyed or counter-based randomness (most modern engines do): derive each step's sampling seed from Hash(key, last-H tokens) instead of a fresh random draw; keep the per-request context window on the GPU so the hot path stays sync-free; mask repeated windows; refuse configurations whose draws you can't reproduce at detection time. The detector is a hundred lines of arithmetic that any auditor can run without a GPU.


Sources & further reading: Anthropic, "How Claude's text watermark works" (Aug 2026) · Dathathri et al., "Scalable watermarking for identifying large language model outputs" (SynthID-Text), Nature (Oct 2024) · Euronews, "EU compliance, delivered globally" (Aug 2026) · TechCrunch, "Anthropic shares more details about how Claude's new watermarks will work" (Aug 2026) · Scott Aaronson's 2022 lecture describing the keyed-Gumbel scheme this family descends from.

About the demo. Generations: Qwen3.5-0.8B (unquantized bf16) served by arbi-serve on one RTX 4090, temperature 1.0, watermark window H=4. The demo key is disclosed by design (0x5EED0FA11) — in production the key is the one secret the whole scheme rests on. The in-page detector was verified bit-identical to the engine's (hash and generator) and to 10⁻⁶ relative on p-values. A detection result speaks to involvement of this key's sampler only; it identifies no person, organization, or session. © 2026 Arbitration City Ltd.