How GPT-6 Astra Solved Historical Ciphers

Two builders using OpenAI’s GPT-6 Astra reported solving historical ciphers that had remained unsolved for decades, within a week of each other in September 2026. One result includes review from a working Enigma historian. The other relies on a keyword already published in an archive. Neither represents a cryptanalytic breakthrough, and both are more notable for what they reveal about long-horizon agent workflows than for the ciphers themselves.

Key Takeaways:

• The 1918 German naval message was produced with ADFGVX, and Astra applied a transposition keyword that already appears on pages 214-215 of a published archival manuscript.
• The 1941 German Army Enigma message (indicator MVUEH) was solved in roughly 10 hours using a crib, a guessed plaintext fragment, not from ciphertext alone.
• Both runs are independent builders’ reports, not OpenAI findings, and neither has been peer-reviewed.
• The reusable part is the workflow: archive search, a purpose-built simulator, parallel key testing, and cross-checking output against external records.

Two Historical Ciphers, Two Different Levels of Evidence

The first result comes from Carter Leffen, who reported that GPT-6 Astra solved a previously unsolved 1941 German Army Enigma message, archived under the indicator MVUEH, over about 10 hours of model time. The recovered text is routine wartime logistics: “Please specify route of march. I am in Rosenow, Rosenow. Immediate reply by radio,” according to coverage of the break summarizing Leffen’s site. Leffen says he sought and received review from Frode Weierud, the cryptologist behind the CryptoCellar archive, before publishing, and CryptoCellar has since logged the break and credited Leffen by name.

The second comes from a writer publishing as prinz, who reported that Astra decoded a 1918 German naval radio transmission produced with the ADFGVX field cipher, one of roughly a dozen remaining unsolved messages on a public list of historical ciphers maintained at scienceblogs.de. The proposed German plaintext translates to a report that an English cruiser arrived at Sevastopol on the 24th and an Allied squadron followed on the 26th, per prinz’s writeup of the decode.

The difference between the two matters more than the shared headline. The Enigma case has credentialed third-party review. The ADFGVX case relies on the poster’s own cross-check against naval records and includes an unresolved discrepancy that the poster himself noted. For readers assessing how much credit belongs to the model versus how much belongs to a message that simply had a low priority, the two cases point in different directions.

The 1918 ADFGVX Message: A Key Application, Not a Break

ADFGVX, introduced by the German Army in June 1918, converts letters and digits into pairs of six symbols (A, D, F, G, V, X), then scrambles those symbols through columnar transposition controlled by a separate keyword. Recovering a message requires identifying both the substitution table and the transposition key.

The target message contains 170 symbols. Astra applied a 19-letter transposition keyword, “TRUPPENVERSCHIEBUNG,” which appears on pages 214 and 215 of J. Rives Childs’s archival manuscript on German military ciphers, according to prinz’s account. The ciphertext itself is on page 217 of that same source. With 170 symbols arranged under a 19-letter keyword, the transposition produces 18 columns of nine symbols and one of eight; reordering the columns by the alphabetical order of the keyword reconstructs the ADFGVX coordinate pairs, which the substitution table converts to plaintext.

# ADFGVX decode, 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" # published on pp. 214-215 of Childs
CIPHERTEXT = "..." # 170 symbols, 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):
 col = columns[c]
 for r, ch in enumerate(col):
 rebuilt[r * n + c] = ch
 return "".join(rebuilt)

The keyword’s presence reduces the difficulty here. Astra selected and applied a historically documented key, then tested the resulting text against external records. That is a key-application and validation task, not ciphertext-only recovery of an unknown key. prinz noted the open question himself: the keyword was associated with messages beginning December 9, 1918, nearly two weeks after this message’s November 27 transmission, and why an earlier-use discrepancy exists remains unresolved. A 2016 Cryptologia paper by George Lasry, Ingo Niebel, Nils Kopal and Arno Wacker documented that Childs had preserved 460 intercepted messages comprising 668 individual cryptograms, and their computerized methods decrypted 618 of them, which puts the scale of the remaining unsolved set in context.

The 1941 Enigma Break: What Was Computed and What Was Supplied

Enigma is a rotor machine, and a three-rotor Army configuration has a very large key space once rotor order, ring settings, and plugboard pairings are combined. That scale required a shortcut. Leffen supplied a crib, a guessed plaintext fragment, drawn from the repeated place name “Rosenow” that appeared in a related message already solved. Feeding that crib into the search reduced the space to something testable.

With the crib in hand, the run recovered the full machine setup: rotor order II-V-III and 10 plugboard pairs, reached through roughly 14.8 million key checks, as reported in the same coverage. Two independent implementations reproduced the plaintext. Leffen also said that building the website explaining the solution took far more work than the codebreaking itself, which indicates where the effort lies.

The division of labor is the point. Leffen set the goal, supplied the crib, and pushed the investigation forward. The agents handled archive searching, built an Enigma simulator from scratch, wrote cryptanalysis code, ran parallel key tests, and cross-checked the candidate plaintext. The model carried out execution, not judgment. Allied codebreakers beat Enigma in the 1940s with human labor and early computing, and the underlying mathematics of a three-rotor machine is not a barrier for any modern machine once a crib narrows the search. What is new is a single system doing the archive reading, simulator construction, and verification loop without a human directing each step.

How the Two Runs Compare

The two results differ sharply in how much of the hard problem was supplied versus solved, and in how much independent scrutiny they received.

The table clarifies the 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.

What the Workflow Shows

Setting aside which cipher was harder, the process is consistent: archive search, a purpose-built simulator, cryptanalysis code, parallel hypothesis testing, and cross-checking results against independent records, run over hours without a human steering each step. That is the same multi-hour, self-directed process seen in other Astra work. OpenAI reported that an internal version of Astra produced new results for 10 problems in mathematics and theoretical computer science that had been open for at least a decade, publishing machine-checkable Lean certificates, as SiliconANGLE reported.

Two limits keep these cipher results in perspective. First, Enigma and ADFGVX belong to a different complexity class from the public-key cryptography that protects modern systems. Leffen and others have drawn a line between a 1930s rotor machine and the elliptic-curve and lattice math behind current protocols, and the historical ciphers here do not affect that math. Second, Astra’s reliability on reasoning tasks varies enough that a single impressive output does not prove general capability. On Artificial Analysis’s independent Intelligence Index, Astra scores 61, matching its predecessor GPT-5.6 Sol, as we covered in our analysis of Astra’s launch benchmarks. The same gap between vendor-reported capability and independently measured capability appears in the model’s cybersecurity profile, where OpenAI designated Astra as the first model to cross its “Critical” threshold and limited the released version to secure code review and patching, as we examined in our look at Astra’s autonomous zero-day discovery.

For teams running agents on research tasks, the transferable lesson is the workflow breakdown, and it points to a specific failure mode. A result only counts once something outside the run can check it. In the Enigma case, two independent implementations and a credentialed reviewer supplied that check. In the ADFGVX case, the check was the poster’s own comparison to naval records, with a documented date discrepancy left open. The same reasoning applies to agent output in production: generation and verification need to be separate steps, ideally with the verifier independent of the generator.

The Verification Gap

Neither result is an OpenAI-published or peer-reviewed finding. Both are independent builders’ reports, and the difference between them is instructive. The Enigma break has an expert who reviewed it before publication and an archive that logged it. The ADFGVX decode reproduced two facts from Royal Navy records, HMS Canterbury reaching Sevastopol on November 24, 1918 and the Allied squadron following on November 26, but the claim that this was the first correct solution remains unverified, as does the reason the message stayed unsolved if the key was already published.

The reusable asset here is the shape of an autonomous research loop that produces something checkable against the historical record, not the plaintext of either message. Whether that loop applies beyond low-priority archival ciphers depends on evidence the public does not currently have: a complete interaction transcript, an independent cryptographic review of the ADFGVX run, and a fair comparison against a human cryptanalyst given the same crib and keyword. Until those exist, the honest reading is that Astra executed two well-scoped decoding jobs with human-supplied shortcuts, and did so with a workflow worth studying.

Related Reading

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

• Understanding x86 Emulation Problems
• How to Hack OpenAI Security Vulnerabilities
• Astra and Fable Alignment Tests Explained
• Fujitsu Monaka: Next-Gen Japanese CPU

Sources and References

Sources cited while researching and writing this article:

• AI Cracks 1918 German Cipher on Black Sea Naval Moves / X
• GPT-6 Astra Solves a WWI German Radio Cipher – prinz
• SiliconANGLE reported