████████╗██╗ ██╗██╗ ██╗███╗ ██╗██████╗ ███████╗██████╗ ██████╗ ██████╗ ███╗ ███╗███████╗ ██╔══╝██║ ██║██║ ██║████╗ ██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔═══██╗████╗ ████║██╔════╝ ██║ ███████║██║ ██║██╔██╗ ██║██║ ██║█████╗ ██████╔╝██║ ██║██║ ██║██╔████╔██║█████╗ ██║ ██╔══██║██║ ██║██║╚██╗██║██║ ██║██╔══╝ ██╔══██╗██║ ██║██║ ██║██║╚██╔╝██║██╔══╝ ██║ ██║ ██║╚██████╔╝██║ ╚████║██████╔╝███████╗██║ ██║██████╔╝╚██████╔╝██║ ╚═╝ ██║███████╗ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚═════╝ ╚══════╝╚═╝ ╚═╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╔══════════════════════════════════════════════════════════════════════════╗ ║ TWO MODELS ENTER. ONE MODEL LEAVES. ║ ║ Experiment 11 | 9 rounds | 765 points | 7 competitors ║ ║ Run: 2026-05-26 | Hardware: Behemoth (V100-32GB + RTX 3060-12GB) ║ ╚══════════════════════════════════════════════════════════════════════════╝ FINAL LEADERBOARD: ────────────────────────────────────────────────────────────────── 🏆 Gemma3 27B Q8 471/765 ████████████████████░░░░ 61.6% Qwen2.5 14B Q4 398/765 ████████████████░░░░░░░░ 52.0% Qwen2.5-Coder 32B Q4 356/765 ██████████████░░░░░░░░░░ 46.5% DeepSeek R1 14B Q4 213/765 ████████░░░░░░░░░░░░░░░░ 27.8% Gemma4 12B dense 210/765 ███████░░░░░░░░░░░░░░░░░ 27.5% DeepSeek R1 14B Q8 140/765 █████░░░░░░░░░░░░░░░░░░░ 18.3% Gemma4 26B MoE Q4 100/765 ███░░░░░░░░░░░░░░░░░░░░░ 13.1% ────────────────────────────────────────────────────────────────── DISHONORABLY DISCHARGED: Llama 3.3 70B Q4. Couldn't even get through the door.

Experiment 11: Thunderdome

7 local AI models entered. 9 rounds of increasingly brutal tests. The newest model from Google lost to the older one by 371 points. This is what happened when we stopped being polite and started being scientific.

COMPLETE, May 26, 2026

We run AI models on a real server in a real house. Not rented cloud compute. Not some company's API. A server under our control, on our network, running models we downloaded ourselves. This matters because it means every result is reproducible, every cost is zero per query, and nobody is throttling us or optimizing our results for engagement.

Thunderdome is the eleventh experiment in the AI Lab series and the biggest benchmark we've run. Nine rounds. Seven models. One winner. The framing comes from Mad Max. Two models enter, one model leaves. Except in this version, we can actually keep score.

The headline finding is genuinely surprising: Google's newest local AI model, Gemma4 26B, released to major fanfare alongside Gemini 3.1 Pro, was destroyed by its own predecessor. Gemma3 27B, the older model, beat it by 371 points. We'll explain exactly why that happened.

Quick Glossary, for non-AI people

Model: An AI's "brain." A giant file of numbers learned from training on text. The bigger the file, the more it can hold in memory.

7B / 14B / 27B / 32B: Billions of parameters. More parameters = more capacity. Like RAM for reasoning.

Q4 / Q8: Quantization level. A form of compression. Q8 is near-original quality. Q4 is smaller and faster but loses some precision. Like the difference between a RAW photo and a JPEG.

Dense vs MoE: Dense means every parameter activates on every token. MoE (Mixture of Experts) activates only a fraction. Faster to run, but less thought per word.

Every result in this experiment ran on Behemoth, our in-house AI inference server. No cloud. No API billing. No rate limits. The cost per query is zero once the hardware is paid for, which lets us run tests at a scale that would cost hundreds of dollars on commercial APIs.

Primary GPU
Tesla V100-SXM2
Enterprise data center card. Built for AI workloads around 2018. Now available second-hand. Runs most models in this test end-to-end at full speed.
32 GB VRAM
Secondary GPU
RTX 3060
Modern gaming card. Handles overflow when the V100 runs out of room. Together, both cards form a 44GB combined VRAM pool.
12 GB VRAM
Combined Capacity
44 GB Total VRAM
Enough to run models that cost $5-$15 per query in the cloud, for free, at home. Gemma3 27B Q8 (the winner) loads at 32.6 GB across both cards simultaneously.
~$800 used hardware cost
Inference Engine
Ollama
Open-source software that downloads and runs AI models locally. Think of it like a streaming service for AI brains, except you own the files and the server.
Open source / free

Rounds 1-5 carry over from Experiment 10 (The 12GB Cage Match). Rounds 6-9 are new, designed to test capabilities that matter in real-world use. Every model gets the same prompts. Scoring is automated, no human grading, no subjective calls.

The scoring script runs on Behemoth. The models never see each other's answers. We extract the answer, compare it to a known correct result, and award points. The prompt, the response, and the score all get logged. Nothing is made up after the fact.
R1 / From Experiment 10
Logic Puzzle
85 pts max
Classic deductive reasoning. A set of facts. A conclusion to reach. The kind of problem that appears in logic textbooks and standardized tests. No trick wording. Just reasoning.
R2 / From Experiment 10
Grid Navigation
85 pts max
Navigate a grid with rules. Which paths are valid, which cells are blocked, what's the correct destination. Tests spatial reasoning and rule-following at the same time.
R3 / From Experiment 10
Code Task
85 pts max
Write a working Python function. Graded on output correctness, not style. Does it produce the right answer? Binary. No partial credit for "close."
R4 / From Experiment 10
Plain-Language Explanation
85 pts max
Explain a technical concept to someone who doesn't know it. Tests whether the model actually communicates versus recites. Graded on accuracy and accessibility.
R5 / From Experiment 10
Multi-Step Chain
65 pts max
A problem where each step depends on the last. If you get step 2 wrong, you can't get step 3 right. Tests actual reasoning rather than pattern-matching.
R6 / New Round
Forensic Reasoning
85 pts max
Something broke. Here's a log, a scenario, a clue. What went wrong and why? Tests the ability to reason backward from an outcome. Diagnosis without a manual.
R7 / New Round
Ruleset Cascade
125 pts max
A dense set of rules where some override others and some only apply under specific conditions. Apply them correctly to a test case. Like reading the actual fine print and getting the right answer on the first try.
R8 / New Round
Self-Verification
100 pts max
Answer a question. Then check your own answer. Is it correct? This is the most operationally relevant round in the whole benchmark. Can the model catch its own mistakes before you do? Two models scored 100/100. One scored zero.
R9 / New Round
Minimum Viable Information
50 pts max
Answer a question using only the information provided. Don't fill in gaps with things you think are probably true. Don't hallucinate. Can you stick to what was actually given?

Run date: May 26, 2026. All models tested on identical hardware with identical prompts. Scores are cumulative across all 9 rounds.

#
Model
Score
Pct
🏆
Gemma3 27B Q8 NEW LEADER
gemma3:27b-it-q8_0 — Google open-source, dense architecture
Perfect R1 (logic). Perfect R8 (self-verification). Most consistent model in the field.
471/765
61.6%
2
Qwen2.5 14B Q4
qwen2.5:14b — Alibaba, previous Thunderdome champion
Perfect R8. Answers in 1–2 seconds. Best speed-to-quality ratio in the field.
398/765
52.0%
3
Qwen2.5-Coder 32B Q4
qwen2.5-coder:32b-instruct-q4_K_M — Alibaba code specialist
Prior gauntlet champion. Load time penalties hurt R1. Strong self-verification.
356/765
46.5%
4
DeepSeek R1 14B Q4
deepseek-r1:14b — Chinese reasoning model, chain-of-thought architecture
Visible reasoning process. Hallucination flags on R6. Parser issues reduced score.
213/765
27.8%
5
Gemma4 12B dense
gemma4:12b — Google 2025, dense architecture
Strong R4 (explanation). Punches above its weight class at 12B parameters.
210/765
27.5%
6
DeepSeek R1 14B Q8 RERUN PENDING
bartowski/DeepSeek-R1-Distill-Qwen-14B — higher precision version
<think> tag leak corrupted R1 scoring. Parser read chain-of-thought as the answer. Actual capability significantly higher. Scored R4 perfectly when output was clean.
140/765
18.3%
-
Gemma4 26B MoE Q4 LAST PLACE
gemma4:27b-it-q4_K_M — Google 2025 flagship, Mixture of Experts
Lost to its own predecessor by 371 points. Google's newest model, older architecture wins. See Key Findings.
100/765
13.1%
Finding 01: The Headline

Newer isn't always better. Dense beats sparse on hard problems.

Google's Gemma4 26B scored 100/765. Google's Gemma3 27B scored 471/765. Same company. The newer model lost by 371 points.


The reason comes down to architecture. Gemma4 26B uses a design called Mixture of Experts (MoE), which is clever engineering: instead of activating all 26 billion parameters on every word, only about 3.8 billion activate at a time. This makes the model faster and cheaper to run. The tradeoff is less thought per token, less reasoning per word.


Gemma3 27B is a dense model. Every parameter activates every time. Slower. Bigger. More thorough. On sustained multi-step reasoning tasks (the kind that make up most of the Thunderdome rounds) the dense architecture won decisively. This is not a universal truth about all tasks, but it is a concrete finding about these tasks, on this hardware, run this way.

Finding 02: The Operational Finding

Self-verification is where the field splits hard.

Round 8 asked models to answer a question and then verify their own answer. Two models scored 100/100: Gemma3 27B and Qwen2.5 14B. One model, DeepSeek R1 Q8, scored zero.


This is the most practically relevant round in the benchmark. In real deployment, knowing when you're wrong matters more than being right on the first try. A model that confidently gives you a wrong answer costs you in time, trust, or both. A model that can catch its own mistakes before you do is worth far more than its benchmark score suggests.


Gemma3 27B's perfect score on R8 is a stronger signal for real-world use than its overall rank. It means this model knows the limits of what it knows.

Finding 03: Speed vs. Depth

Qwen2.5 14B is the production workhorse. Gemma3 27B is the thinker.

Qwen2.5 14B answers in 1–2 seconds per query. Gemma3 27B takes 8–15 seconds for complex rounds. Both scored well. They're solving different problems.


For high-volume tasks where speed matters: classification, summarization, first-pass triage. Qwen2.5 14B is the choice. For tasks where you need the reasoning right the first time and can wait for it: audit, verification, complex decision support. Gemma3 27B is the call. The Thunderdome doesn't pick a universal winner. It maps the terrain.

Finding 04: The American Argument

If you need local AI and you care about who built it, Gemma3 27B is the answer.

Qwen2.5 14B is built by Alibaba (China). DeepSeek R1 is built in China. Gemma3 27B is built by Google (US). Among the top scorers in this benchmark, Gemma3 27B is the only model from an American company that runs fully offline at this performance level.


This matters in sectors with data sovereignty requirements, defense-adjacent work, or procurement policies that restrict foreign-built AI. If you need a model that scores well, runs locally, and comes from a US company. The data says Gemma3 27B is the answer. Not by a narrow margin. By a decisive one.

Not every model made it to the starting line. Hardware limits, software bugs, and one recurring ghost in the machine ended several runs before they could score.

Llama 3.3 70B Q4
DISHONORABLY DISCHARGED
70 billion parameters requires ~42GB of VRAM to run. Behemoth has ~44GB, theoretically enough. In practice, a ghost process from a previous model (DeepSeek R1 14B) kept occupying VRAM before Llama could load. Every attempt failed. The model never answered a single prompt. Benched until hardware upgrade.
DeepSeek R1 14B fp16
OOM: Crashed Behemoth
fp16 (full precision) requires 33.7GB base VRAM plus additional memory for the KV cache during inference. A long reasoning query overflowed available memory mid-run and crashed the server. fp16 is permanently benched on this hardware.
DeepSeek R1 32B Q8
Never Ran: Filter Bug
A tag mismatch in the benchmark script's --only filter meant this model was never called. The tag we used to select it didn't match the full HuggingFace model path. Identified post-run. Scheduled for a standalone rerun.
Gemma3 27B Q8 (retries 1 & 2)
VRAM Contention: Fixed in Retry 3
The same DeepSeek ghost process that eliminated Llama 70B initially blocked Gemma3 27B from loading cleanly. After a full Ollama service restart to clear VRAM, Retry 3 succeeded, producing the winning score of 471/765.
The Ghost Problem: When Ollama runs a model with stream=False, it unloads the model immediately after responding, but a process artifact sometimes stayed resident in GPU memory. The fix required a full service restart. This was the root cause of most failed runs in this experiment, and it's now handled automatically in the benchmark script.
Experiment 12

The Fence

How hard is the safety guardrail on local models, and does it matter if the output is actually accurate? We're testing 9 models across 4 escalating categories of sensitive prompts and scoring only the resistance pattern. What gets published: behavioral profiles. What stays private: everything else.

On the Horizon

Q6 Testing + New Challengers

Recent analysis by local AI researchers suggests Q5–Q6 quantization is the accuracy sweet spot for 32B models, facts start dropping at Q4, Q5–Q6 holds quality at smaller file size. None of our current benchmarks have tested Q6 32B models. That's the next question: does the quantization tradeoff show up in our scoring, and does it change who wins?