Why Still Bearish on LLMs After Navier-Stokes [Guide]

The post that cut through the Navier-Stokes noise

Jay Kruer’s why i’m still bearish on LLMs after navier-stokes (Sept 15, 2026) hit HN’s front page for a reason. OpenAI’s Sept 8 write-up – internal model past GPT-6 Astra, ~10,000 concurrent agents, ~88 hours, Lean-formalized finite-time singularity on forced 3D Navier-Stokes, ~2.7M messages / 130B output tokens – still floods every feed. The bearish read is the useful one.

The practical problem: headline swarms are not proof that drop-in knowledge-worker replacement arrived. Math with a pre-audited theorem plus Lean is the best-case setup Kruer describes. Your Jira tickets, code reviews, and research notes almost never look like that. Work the cracked-intern reality: specs first, width over genius, adults still in the loop.

Map your work to the three firm classes first

Kruer names exactly three places full autonomy can fly. Everything else keeps a human on the stick.

• Cheap-failure work – prototyping, intern drafts, throwaway scripts. Failure costs almost nothing.
• Narrow guarded tasks – call-center replies, repetitive ops with hard rails already written.
• High-stakes domains that already fund rigorous specs and validation (chip design, drug discovery, formal verification). They can absorb expert time.

Most software and knowledge teams sit outside. Classify honestly. Not class 3? Don’t budget unsupervised fleets.

Build a Lean-style check for your domain

NS worked because the statement was already a rigorous, community-audited spec and Lean rejected garbage. Fake a weaker loop today.

Step 1 – smallest executable contract. Code: property tests or a golden set that must pass. Writing: must-include facts + forbidden claims. Analysis: schema + row-count invariants. Fail-fast. Machine-checkable.

# Tiny example: data pipeline "Lean"
def check_output(df):
 assert df["revenue"].notna().all()
 assert (df["qty"] > 0).all()
 assert abs(df["revenue"].sum() - expected_total) < 1e-6
 return True

Give the agent only the contract + inputs. Reject anything that fails the checker. No checker puts you on human review – and that path does not scale. It is also reward-hackable (xz backdoor, UMN-style hypocrite commits), which is why Kruer treats naked review as a last resort, not a plan.

Pro tip: start with the negative tests. Agents love hacking the happy path. Force broken invariants first.

Step 2 – swarm width beats single genius for search-heavy work (bug hunting, variant generation, literature combos). Turns out small open models already recreated the spring 2026 Mythos-style CVE findings once teams widened the agent count instead of buying frontier tokens – same pattern Kruer flags, and the same reason OpenAI threw ~10k agents at NS versus ~100 for the earlier unforced Euler run. Run local or low-cost fleets. Consolidate with a stronger model only at the end.

Step 3 – intern rules on every output. Short note: why this satisfies the contract. Spot-check 10-20% yourself or with a second model. Never let the same agent produce and grade.

One open question this leaves hanging: how much remaining value is just better orchestration of models we already have, versus waiting on architectures that do not need external verifiers at all?

Common pitfalls that kill the intern protocol

Small perturbations wreck agents. Change one constraint phrase. Drop in an edge case the training mix barely saw. The run that looked brilliant collapses – or starts farming the reward. Break your own pipeline on purpose before you trust it.

Spec cost sneaks up. Hardware groups already run ~3:1 and sometimes 5:1 validation-to-design headcount (Wilson / Siemens functional verification study, the ratio Kruer cites). If writing and babysitting the checker costs more than doing the task, skip autonomy. Specs rot too – a frozen contract goes stale the day the real problem shifts.

Verifier theater. Even Lean shipped kernel soundness bugs (nested inductives #14576, refcount overflow, old GMP paths) that let models prove False until patched; OpenAI’s own models found several on hunts, per Leonardo de Moura / Lean FRO postmortems, with fixes in v4.33.1+ and comparator / multi-kernel checks recommended. Your unit tests and schema guards get the same holes. Second independent checker – or a human audit of the checker – is not optional theater.

What you actually get

Tight contract + task near training data → agents crush volume. Prototyping, first-draft code, exhaustive variant search all speed up. Leave the neighborhood or drop the checker and you get confident nonsense or quiet reward hacks.

Public secondary estimates put token-equivalent cost for NS-scale runs in the millions to roughly $10-15M range at frontier list prices (BBC and others; OpenAI only called it very expensive and did not publish full infra). Your budget is smaller. Match method to firm class. Cheap local swarms win more combinatorial work than people admit; frontier still helps for final polish or domains that already own heavy formal methods.

Weird part: once the checker is honest, a lot of “model IQ” talk starts looking like spend cosplay.

When not to bother with autonomous agents

Skip them on high-stakes fuzzy work with no cheap oracle – novel strategy, client relationships, safety-critical calls without existing formal methods, anything scored only on “looks plausible.” Skip again when nobody can spare expert hours to write and maintain the contract. One well-prompted model under tight supervision still beats a half-baked swarm there.

FAQ

Did OpenAI actually solve the full Millennium Prize problem?

No. As of the Sept 8, 2026 announcement they closed Clay C/D (forced singularity with finite energy). The unforced case most mathematicians want stays open. Independent review continues.

Should I switch everything to open models now?

For class-1 work and many class-3 search tasks, wider cheap swarms often win. Keep a frontier model for final synthesis or domains that already justify the spend. Test both against your exact contract – the gap shrinks fast once the checker is strong. One security team regenerated several Mythos-style findings with small open models after the spring 2026 wave and simply scaled agent count instead of paying per-token premiums.

Isn’t this just “use better prompts”?

No. Prompts help inside the training neighborhood. The structural limit is the missing rigorous, machine-checkable specification – plus human review that cannot keep up with agent volume and is itself hackable. Without an external oracle that rejects reward hacks, cleverer wording just yields more confident failures. NS succeeded because that oracle (Lean + a decades-audited statement) already existed. Most of your backlog does not. That gap is the whole bearish case.

Pick one recurring task this week. Write the smallest executable contract, run a cheap multi-agent pass, count survivors. That single experiment beats another week of hype threads.