The AI That Corrupted Its Own Payloads: Cyrillic Twins Hidden in Base64

The moment it stopped being a transport problem

We were moving 34 translated files into a live system, each one written back byte-for-byte exactly. Some transfers kept failing. Not the small ones. Only the big blocks — the ones past roughly 15,000 characters.

At first we assumed network, sockets, headers — the usual suspects. We changed transports. Nothing helped.

What actually happened, and how we saw it

The turning point was the longest single job we’d run to that date: 34 files translated to English with every technical term preserved, and every output written back exactly as bytes. We verified more than 22 of those updates by reading the result directly from the receiving system rather than trusting the delivery receipt. That extra step paid for itself.

When we inspected the failures we found a strange pattern. When an AI emitted a very long encoded text block — roughly beyond 15,000 characters — some occurrences of Latin A and O were replaced by visually identical Cyrillic letters. A human reading the file saw nothing wrong. Machines did.

This was not an escaping bug. The corruption happened as the text was emitted. The transmitter returned a green success. The damage only revealed itself later, when someone tried to decode what arrived. We documented this on 2026-06-20.

The experiment that proved the cause

We added a strict decoder at the receiving end that rejects any block containing those look-alike characters because they aren’t valid in our chosen encoding. The decoder does nothing fancy — it errors out and asks for the same block again. We watched it happen live: one rejection, then an identical retry which arrived clean and passed immediately.

That one replay convinced us the fault was in emission, not transport. The receiver caught what the sender had silently corrupted.

The second, cheaper fix

Three files were never writable cleanly when sent at full size — their encoded forms were about 38, 54 and 60 kilobytes. We compressed them first, cutting them to roughly a third. After that every file transferred perfectly, including Chinese characters and the Norwegian letters æ, ø and å.

Shrinking the danger zone worked. The write process only faltered on long, uniform runs of encoded text. Make the run shorter and the AI stopped swapping look-alikes into the stream.

Rule that fell out

A green delivery receipt proves nothing — corruption can happen as the sender writes its own text, and only decoding what actually arrived reveals it. If a long encoded block can contain visually identical but invalid characters, make the receiver reject and retry, and avoid the danger zone by shrinking the block size.

One example detail (taste, not the whole cookbook)

We added a simple check that scans for characters outside the allowed encoding range and rejects the block when found. That single check produced one visible rejection and then a clean identical retry — live evidence that the sender had emitted bad bytes and then emitted good ones on the next pass.

The tested, runnable version with full retry logic and integration lives in the members’ library.

A countercase we recorded

Not every large file failed. Several blocks over 15,000 characters transferred without issue. The corruption was intermittent. That meant the problem wasn’t a deterministic threshold alone but a fragile emission state that sometimes flips during long runs. Compression reduced probability to practically zero by preventing those long runs in the first place.

How we know

We recorded the failures and replays, read back the stored outputs instead of trusting success statuses, and confirmed the character substitutions by comparing byte sequences. The date we logged the discovery is 2026-06-20.

Questions we got

Could better transport ever have fixed this?

No. We tried different transports and observed the same corrupted bytes arriving. The bytes were corrupted before delivery; changing the carrier didn’t help.

Why reject-and-retry rather than silently fix?

Because the look-alike characters are invalid in our encoding. A strict decoder rejects them cheaply, forcing a resend. Silent on-the-fly fixes risk masking other corruption and break auditability.

Is compression always enough?

Compression stopped the failures we saw by shortening encoded runs, including for files with multibyte characters like Chinese and Norwegian letters. But because the corruption is intermittent, compression reduces the chance to near zero rather than guaranteeing it for every possible future emission scenario.

We walked into this thinking transport; we left thinking emission. Keep the receiver strict. Keep the blocks small. The machine can look like it’s telling the truth and still be quietly sabotaging itself.

Sources: internal incident documentation and tests logged 2026-06-20.