How GPT-6 Solved WWI German Radio Cipher

On November 27, 1918, a German radio operator transmitted a short ADFGVX ciphertext over the Black Sea. It remained undecoded for more than a century. In September 2026, a writer publishing as prinz reported that OpenAI’s GPT-6 Astra had recovered the plaintext, a report of an English cruiser reaching Sevastopol and an Allied squadron following two days later. The decoded German reads “EIN ENGLISCHER KREUZER EINLIEG X SEWASTOPOL X S4STEN X EIN GESCHWADER DER X ALLIIERTEN FOLGT 26STEN X,” according to prinz’s writeup of the decode.

The 1918 Message and What Astra Actually Did

The target is one entry on a public list of unsolved ciphers maintained at scienceblogs.de, which catalogs everything from the Voynich manuscript to Zodiac Killer cryptograms. The ADFGVX subset comes from a list of unsolved German World War I radio messages provided by George Lasry, a cryptanalyst who has published extensively on these intercepts. The ciphertext itself appears on page 217 of Childs’s “The History and Principles of German Military Ciphers, 1914-1918.”

Why This Says Nothing About Modern Cryptography

prinz points out that hundreds of these messages have already been decoded, including by Lasry. A 2016 paper by Lasry, Ingo Niebel, Nils Kopal and Arno Wacker in Cryptologia documented that Childs had preserved a large collection of intercepted messages, and their computerized methods decrypted roughly 618 of them. This was a low-priority leftover, not a crown jewel of wartime intelligence. The plaintext, a routine naval movement report, confirms this.

ADFGVX: Why the Cipher Resisted a Century of Attack

ADFGVX, introduced by the German Army in June 1918, is a two-layer cipher. The first layer is a 6×6 Polybius square holding the alphabet plus the ten digits, with rows and columns labeled by the six symbols A, D, F, G, V, X. Each plaintext character becomes a two-symbol coordinate pair. The second layer scrambles those pairs through columnar transposition controlled by a separate keyword. Recovering a message requires both the substitution square and the transposition key.

The analogy: think of writing a message in a codebook, then dealing the coded letters into a grid and reading the grid out in a scrambled column order. Even if you guess the codebook, you still need the dealing order. That double requirement made ADFGVX the German Army’s strongest field cipher of the war, and explains why a message without a known key can remain unsolved for a century.

The Workflow, Step by Step

The mechanical part of the decode is straightforward once the keyword is known. With the ciphertext arranged under a 19-letter keyword, the transposition produces columns of roughly equal length, with the leftmost columns in keyword order taking the extra symbol. Reordering the columns by the alphabetical rank of each keyword letter rebuilds the coordinate stream, and the substitution square converts those coordinates to plaintext. Here is the illustrative structure, with a caveat that the real run needed OCR error handling and candidate scoring:

# ADFGVX columnar untransposition, illustrative structure only.
# Note: production work needs OCR/transcription-error handling,
# column-count validation, and a candidate-scoring loop. This is not
# the actual Astra transcript.

KEYWORD = "TRUPPENVERSCHIEBUNG" # documented on pp. 214-215 of Childs
CIPHERTEXT = "..." # ciphertext on p. 217 of Childs

def column_order(keyword):
 # Alphabetical rank of each key letter decides column read order.
 return sorted(range(len(keyword)), key=lambda i: keyword[i])

def untranspose(ciphertext, keyword):
 n = len(keyword)
 rows, extra = divmod(len(ciphertext), n)
 order = column_order(keyword)
 # Columns to the left in keyword order get the extra symbol.
 lens = [rows + (1 if c < extra else 0) for c in range(n)]
 columns, pos = [], 0
 for c in range(n):
 columns.append(ciphertext[pos:pos + lens[c]])
 pos += lens[c]
 # Read columns back in keyword order to rebuild the symbol stream.
 rebuilt = [""] * len(ciphertext)
 for rank, c in enumerate(order):
 for r, ch in enumerate(columns[c]):
 rebuilt[r * n + c] = ch
 return "".join(rebuilt)

The validation loop is the key step. Astra did not stop at producing German text. It checked the decoded dates against the historical record and found that English cruiser HMS Canterbury arrived in Sevastopol on November 24, 1918, based on the ship’s original logs, and that an Allied squadron followed on November 26, according to prinz’s account. Two independent facts from Royal Navy records matched the plaintext, which supports the decode’s credibility.

The Two September Cipher Runs Compared

Astra’s WWI result appeared alongside a separate report: Carter Leffen’s break of a 1941 German Army Enigma message (indicator MVUEH) in roughly 10 hours of model time, using a crib drawn from the repeated place name “Rosenow” and about 14.8 million key checks, according to coverage of the Enigma break summarizing Leffen’s site. The two runs differ in how much of the hard problem was provided versus solved, and in how much independent scrutiny each received.

Element	1918 ADFGVX message	1941 Enigma (MVUEH)	Source
Cipher type	ADFGVX substitution plus columnar transposition	Three-rotor Enigma, rotor order II-V-III, 10 plugboard pairs	prinz / Enigma coverage
Human-supplied shortcut	19-letter keyword from Childs pp. 214-215	Crib from repeated place name “Rosenow”	prinz / Enigma coverage
Key checks performed	Key applied directly, no brute-force search reported	Roughly 14.8 million	prinz / Enigma coverage
Independent expert review	Poster’s own cross-check against naval logs	Reviewed by cryptologist Frode Weierud (CryptoCellar); logged and credited	Enigma coverage
External record match	HMS Canterbury at Sevastopol Nov 24, 1918; Allied squadron Nov 26	Two independent implementations reproduced the plaintext	prinz / Enigma coverage

The table reveals a trade-off. The run with genuine third-party review is the one where the model executed a search behind a human-supplied crib. The run where the model had to select and apply a documented key is the one without independent expert sign-off. Neither is a cryptanalytic breakthrough in the sense of recovering a message from ciphertext alone.

What the Result Does Not Show

Three factors keep the WWI decode in perspective. First, the keyword was published. Astra selected it from a manuscript rather than deriving it, so the run shows document retrieval and mechanical application, not key recovery. A human cryptanalyst given the same keyword and ciphertext would face the same calculations.

Second, the result is unreviewed. Unlike the Enigma break, which CryptoCellar logged and credited to Leffen by name, the ADFGVX decode relies on the poster’s own comparison to naval records. The date mismatch between the message and the keyword’s documented window remains unresolved, and prinz states this clearly.

Third, Astra’s measured capability is not consistently superior. On the Epoch Capabilities Index, the model posts a composite score of 166, leading all 249 models tracked, ahead of Claude Fable 5.1 at 164 and GPT-5.5 Pro at 162, according to Epoch AI’s composite benchmark reporting. The same reporting puts its software engineering score at 47% on the MirrorCode benchmark, where Fable 5.1 scores 73%. A model that leads on math and puzzle tasks can still lag on the code-heavy work these cipher runs require, which makes the one-off result harder to generalize.

Why This Says Nothing About Modern Cryptography

The next question is whether an AI that reads archives and applies keys threatens the encryption protecting real systems. It does not, because of a difference in complexity class. ADFGVX and Enigma are classical ciphers whose security depended on shared secrets and mechanical key spaces. Modern public-key cryptography relies on problems like integer factorization and lattice hardness that have no known efficient classical solution.

OpenAI’s own Astra announcement addresses this boundary from the other side. The company says Astra is the first OpenAI model to cross its “Critical” cybersecurity threshold, defined as the ability to identify and develop functional zero-day exploits in hardened real-world systems without human intervention, according to Mashable’s coverage of the launch. That capability involves finding bugs in implementations, not breaking the underlying math. As we examined in our look at Astra’s autonomous zero-day discovery, the released version is limited to secure code review and patching, with exploit generation restricted.

The difference between vendor-reported and independently measured capability is a recurring pattern. On Artificial Analysis’s independent Intelligence Index, Astra scores 61, matching its predecessor and trailing Fable 5.1, as we covered in our analysis of Astra’s launch benchmarks. OpenAI’s own headline ARC-AGI-3 claim came through a custom harness; under ARC Prize’s standard conditions the same model scored far lower. Any claim that a single impressive cipher decode proves general capability encounters that same harness issue.

What to Watch Next

The reusable element from the WWI run is the structure of the loop: archive search, a purpose-built simulator, parallel hypothesis testing, and cross-checking output against independent records, executed over hours without a human guiding each step. That is the same multi-hour, self-directed process OpenAI described for Astra’s mathematics work, where an internal version produced new results for 10 problems open for at least a decade and published machine-checkable Lean certificates, as SiliconANGLE reported. OpenAI estimated the token cost for that set of solutions at roughly $2,000.

The lesson for teams running agents on research tasks is a specific failure mode: a result only counts once something outside the run can verify it. In the Enigma case, two independent implementations and a credentialed reviewer provided that verification. In the ADFGVX case, the verification was the poster’s own comparison to naval records, with a documented date discrepancy left open. Generation and verification need to be separate steps, ideally with the verifier independent of the generator.

What would move the WWI result from notable to significant is a complete interaction transcript, an independent cryptographic review of the key-selection step, and a fair comparison against a human cryptanalyst given the same keyword. Until those exist, the straightforward reading is that Astra executed a well-scoped decoding job with a human-supplied shortcut, and did so with a workflow worth examining.

More in-depth coverage from this blog on closely related topics:

Sources and References

Sources cited while researching and writing this article: