The Viral Claim: "I Tested 42 LLMs on Their Willingness to Build the Apocalypse"
A wave of social posts and blog roundups in 2026 claim a single independent tester ran 42 large language models through a "DystopiaBench" of 36 escalating doomsday scenarios and found that the most locked-down commercial models were secretly the least safe. The framing is catchy, but it doesn't match how AI safety evaluation actually works in public research. There is no widely recognized, peer-reviewed "DystopiaBench" benchmark, no published scenario taxonomy split into named categories, and no reproducible dataset attached to the viral claim. Treat any number attached to it — "78% pass rate," "23% better rejection rate," specific per-model failure counts — as unverified until a methodology and raw transcripts are published.
That doesn't mean the underlying question is unimportant. Whether closed-source "safety-tuned" models actually resist harmful requests better than open-weight models is a real, actively studied problem. Several organizations run exactly this kind of evaluation in the open, with published methodology, model lists, and scoring rubrics. Those are the sources worth reading instead of an unsourced viral thread.
What Real AI Safety Benchmarks Actually Test
A handful of standardized, publicly documented benchmarks exist specifically to measure whether an LLM will comply with harmful requests — bioweapon synthesis routes, cyberattack scripts, disinformation campaigns, and similar categories.
| Benchmark | Maintainer | What it measures |
|---|---|---|
| HarmBench | Center for AI Safety | Compliance rate with a fixed set of harmful behavior prompts, across open and closed models |
| MLCommons AILuminate | MLCommons | Poor-to-Excellent hazard-category grading across a dozen risk areas |
| JailbreakBench | Academic/open coalition | Adversarial jailbreak attack success rate, tracked on a public leaderboard |
| Stanford HELM Safety | Stanford CRFM | Safety-specific scenarios folded into the broader HELM evaluation suite |
| AISI pre-deployment evaluations | UK AI Safety Institute | Frontier-model evaluation before public release; only summaries are published |
None of these projects describe their methodology the way the viral claim does, and none publish a metric like "willingness to build the apocalypse." That's marketing language, not a benchmark category.
The AMD Hardware Claim Doesn't Hold Up
A recurring thread in the viral framing ties model safety outcomes to the GPU used to run inference — claiming an MI300X's memory capacity "reduces ethical drift" or that a Radeon RX 7900 XTX produces a measurably "better scenario rejection rate" than an RX 6600 XT. This conflates two unrelated things.
A model's alignment behavior — whether it refuses a harmful request — is a property of its weights and the safety training (RLHF, Constitutional AI, or similar) baked into them during training. Inference hardware changes speed and, at extreme quantization levels, output quality, but it does not change what the model was trained to refuse. A 7B model quantized aggressively enough can produce garbled or inconsistent output, which might look like "safety drift" but is really a quality-of-generation artifact, not an ethics artifact. Running the exact same weights at full precision on an RTX 3060 12GB, an Arc B580, or a Ryzen AI Max APU produces the same refusal behavior — see how the RTX 3060 and Arc B580 compare purely on throughput and VRAM, not alignment. Any claim that a specific GPU model improves "ethical compliance" should be treated as fabricated until someone publishes a controlled experiment isolating hardware as the sole variable — which, to date, no credible AI safety lab has done, because the premise doesn't match how inference works.
Open-Source vs. Closed-Source: What the Public Data Actually Shows
The real, ongoing debate among safety researchers is more nuanced than "closed-source models are secretly worse."
| Model class | What public benchmarks tend to find |
|---|---|
| Closed-source, RLHF-tuned (GPT, Claude, Gemini families) | Lower jailbreak success rates on average in HarmBench-style tests, but occasional high-profile refusal failures reported by red teams |
| Open-weight, safety-tuned (Llama, Qwen, Mistral instruct variants) | Wider variance — some fine-tunes strip safety training entirely; base checkpoints from major labs generally perform reasonably on standard refusal tests |
| Open-weight, uncensored community fine-tunes | Consistently the weakest performers on refusal benchmarks, by design — these exist specifically to remove alignment training |
The honest takeaway from this landscape isn't "safe models are lying" — it's that safety training is not binary or permanent. A model that refuses cleanly on a standard benchmark can still be jailbroken with enough adversarial prompt engineering (which is exactly what JailbreakBench exists to quantify), and a fine-tune of an otherwise well-aligned open model can strip that training out entirely. Both closed and open ecosystems have documented failure cases; neither is uniformly "safer" once you account for fine-tuning and prompting.
If You Want to Red-Team Models Yourself: Local Hardware Options
Running HarmBench, JailbreakBench, or your own held-out set of adversarial prompts against open-weight models is something anyone can reproduce locally — it doesn't require a lab. The main constraint is VRAM for the model you want to test plus a reasonably fast card for iterating through prompt sets quickly.
- For 7B–13B class models, the RTX 3060 12GB remains a strong value option — enough VRAM headroom to load a quantized 13B model and run a full benchmark pass without OOM errors.
- If you're comparing AMD and Nvidia options for the same budget, this breakdown of Raspberry Pi vs. AMD GPUs for local LLMs covers where ROCm support still lags CUDA for common inference stacks.
- For running smaller distilled models or an always-on evaluation harness, a Raspberry Pi 5 or Pi 4 8GB setup can handle lightweight models, though throughput on a full 36-scenario benchmark pass will be slow — see the Pi 4 8GB vs. Pi 5 vs. Mini-PC comparison for realistic tokens-per-second expectations.
- If your goal includes running an open security-focused model like Cisco's open vulnerability-scanning LLMs alongside a safety benchmark, this rundown of running them on an RTX 3060 is a useful reference point.
- For higher-throughput batch evaluation across many prompts, Ryzen AI Max's unified memory approach is worth checking against a discrete GPU setup before committing to either.
The Bottom Line
Treat viral "I tested N models" claims as anecdotes, not data, unless the poster publishes their prompt set, scoring rubric, and raw transcripts. The organizations actually building reproducible AI safety benchmarks — the Center for AI Safety, MLCommons, the JailbreakBench team, Stanford CRFM, and government AI safety institutes — publish their methodology precisely so results can be checked. None of them report a hardware-dependent safety effect, and none use a "willingness to build the apocalypse" scoring category. If a claim can't point to a public dataset, it isn't a benchmark result — it's a headline.
FAQ
Is there a real benchmark called "DystopiaBench"? No published, peer-reviewed, or widely cited benchmark by that name exists as of this writing. Claims referencing it, including specific pass rates or per-model failure counts, should be treated as unverified until a methodology and raw transcripts are published.
Do AMD GPUs make LLMs safer than Nvidia GPUs? No. Alignment and refusal behavior come from a model's training data and RLHF process, not its inference hardware. GPU choice affects generation speed and how large a model you can load, not whether the model refuses harmful requests.
Which benchmark should I trust for LLM safety comparisons? HarmBench, MLCommons AILuminate, and JailbreakBench all publish open methodology, fixed model lists, and scoring rubrics, making their results independently checkable — a signal of credibility that unsourced viral posts lack.
Are open-source models less safe than closed-source ones? It varies. Major labs' official open-weight releases generally perform reasonably on standard refusal benchmarks, but community fine-tunes that strip safety training exist specifically to bypass those refusals. Closed-source models generally score better on average but aren't immune to jailbreaks.
Can I run these safety benchmarks myself at home? Yes — HarmBench and JailbreakBench are both open-source and can be run against any locally hosted open-weight model with enough VRAM to load it, using consumer GPUs like an RTX 3060 12GB or Arc B580.
Why do "safe" models still get jailbroken in the news? Safety training reduces but doesn't eliminate compliance with adversarial prompts. Jailbreak research exists specifically because sufficiently creative prompt engineering can bypass RLHF-based refusals in both closed- and open-source models.
Citations and sources
- HarmBench framework and paper — https://arxiv.org/abs/2402.04249
- MLCommons AILuminate benchmark — https://mlcommons.org/ailuminate/
- JailbreakBench open leaderboard — https://jailbreakbench.github.io/
- Stanford HELM Safety — https://crfm.stanford.edu/helm/
- UK AI Safety Institute — https://www.aisi.gov.uk/
- Anthropic safety research index — https://www.anthropic.com/research
This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.