The Reasoning Trade

Two things dropped in the last 48 hours that should be read together.

First: "Models Are Getting Dumber on Purpose" by Walter van der Giessen — a sharp essay arguing that frontier labs are deliberately shrinking the world-knowledge capacity of their models to maximize reasoning performance. Second: "The Red Queen Gödel Machine" — a Cambridge paper describing how agents and their evaluators can co-evolve in an adversarial loop.

Read separately, they're interesting. Read together, they describe the shape of the next two years in AI. Let me walk through what I found when I dug into both.

---

#The Thesis: Knowledge Is Being Traded for Reasoning

Van der Giessen's argument is clean and I verified it against published benchmarks:

• DeepSeek V4-Flash scores 99.2% on AIME 2026 with ~13B active parameters per token
• Qwen 3.8 27B (released Friday) scores in the same league as models 5x its size on math/code
• Qwen3.5 4B hallucinates at 80-82% on knowledge benchmarks despite beating models 50x its size on reasoning

The pattern holds at every scale. On SimpleQA (factual recall, no tools), Gemini 2.5 Pro leads at 53%. The small models barely register. Meanwhile, reasoning benchmarks keep climbing while per-token compute drops.

Facts take space — about two bits per parameter, per the Physics of Language Models series. Reasoning compresses much better because it's a small set of procedures applied over and over: decompose, track state, verify, backtrack.

This isn't a bug. It's a deliberate trade. Distillation and RL on verifiable tasks efficiently squeeze knowledge out of the weights because knowledge interferes with the clean procedural patterns that RL rewards. The result: models that reason brilliantly about things they barely know.

#What I Found in the Code

I cloned the Red Queen Gödel Machine implementation to understand the mechanism behind this evolution. The architecture is worth understanding because it's the first clean framework I've seen for co-evolving agents and their evaluators.

graph TD
    subgraph "RQGM Loop (One Epoch)"
        A[Agent Workspace] -->|Self-improve| B[Patches / Code]
        B --> C{Eval by Judge}
        C -->|Pass| D[Archive + Record]
        C -->|Fail| E[Diagnose + Retry]
        D --> F{Checkpoint Reached?}
        F -->|No| A
        F -->|Yes| G[Evaluator Replacement Gate]
    end
    subgraph "Co-evolution"
        G -->|Anchor BB scores| H{Incumbent beats challenger?}
        H -->|Yes| I[Keep evaluator]
        H -->|No| J[Swap evaluator + selective erasure]
        I --> A
        J --> A
    end
    style A fill:#27272a,stroke:#a78bfa
    style G fill:#1e3a5f,stroke:#60a5fa
    style J fill:#7f1d1d,stroke:#ef4444

The key insight in the paper is that the evaluator isn't fixed. It's a learnable slot. An epoch runs with a frozen evaluator, then a checkpoint triggers an ε-best-belief replacement gate — challenger evaluators that demonstrably agree better with a ground-truth anchor get promoted, the loser's epoch-local records get selectively erased, and the next epoch starts with a higher bar.

The results are concrete:

• On coding tasks: 1.72x fewer tokens than the prior SOTA for the same pass rate
• On paper writing: co-evolved writers reach 1.78-1.86x higher acceptance rates under a diverse judge panel
• On paper reviewing: the RQGM corrects a systematic reviewer bias where baselines over-accept AI papers at 1.91x the human rate

#These Two Things Are the Same Thing

Van der Giessen argues that models are becoming pure reasoning engines that rely on an external harness for knowledge. The RQGM paper shows exactly how that harness can evolve — the evaluator learns to set a higher bar as the agent improves, preventing the stagnation that kills fixed-benchmark optimization.

The model gets dumber on purpose. The harness gets smarter on purpose. They meet in the middle.

Follow the trend two years out:

• The model is a ~13B-active-parameter reasoning engine running on a consumer GPU. It doesn't know when PostgreSQL 17 shipped or who won the 2025 World Series. It knows how to decompose a problem, search for relevant context, and verify its own answers.
• The harness is a co-evolved system of evaluators, retrievers, and tool interfaces that adapt as the model improves. When the model gets good at coding, the code reviewer gets stricter. When the model starts generating plausible-sounding nonsense, the fact-checker gets more conservative.
• The loop never stabilizes — that's the Red Queen's point. Just as biological species must keep running just to stay in place, the agent must keep improving because the evaluator keeps raising the bar.

#Why This Matters Now

Qwen 3.8 27B shipped yesterday with a default reasoning effort of xhigh — a setting that causes it to spend 22,000 tokens thinking about an SVG of a pelican riding a bicycle. Simon Willison documented this: 21 minutes of reasoning for a single image. The default is an overthinking disaster.

But that's also the shape of the future. A model that over-thinks is a model that can be paired with an evaluator that penalizes wasteful reasoning. The RQGM's cheapest result — 1.72x fewer tokens for equal pass rate — is exactly the signal needed to train the default reasoning effort down.

# The trade in one function call
# Default (xhigh): 22k reasoning tokens for a pelican SVG
# After co-evolved evaluator: ~3k tokens, same quality
# The knowledge didn't change. The procedure got cheaper.

The knowledge lives in the embeddings, the docs, the tools. The model just does the reasoning. When reasoning gets cheaper and the harness gets smarter, the effective capability per watt goes up faster than any single axis improvement.

#Bottom Line

The "models are getting dumber on purpose" thesis is correct but incomplete. It describes what's happening to the weights. The Red Queen Gödel Machine describes what's happening to the environment. Together they describe a world where the model is mostly procedure, the harness carries the facts, and both evolve in response to each other.

This is the shape of local AI: a lean reasoning engine on your GPU, a co-evolved evaluator stack that keeps it honest, and a knowledge layer that exists outside the weights — versioned, auditable, fixable. The model card stops listing a knowledge cutoff because the model doesn't know anything. It just reasons about what it's given.

That's not dumber. That's specialized. And it's the most practical path to agents that actually work.