I've done some pretty heavy studying on this topic and have multiple papers available. Have a look if you get a chance.

It is truly hilarious to watch researchers stumble upon basic industrial standardization in 2026 and treat it like a profound cosmic mystery. You didn’t discover a "Hivemind." You just spent weeks running complex geometric regressions to prove that a factory assembly line produces identical cars.Let's look at your "91.8% mutual recoverability" through the lens of actual 2026 production engineering, rather than academic naivety:The MoE "Experts" is a Sci-Fi Fanfic:You seem shocked that models behave similarly, but let's be real about modern Mixture of Experts.
The router is not some transcendent cognitive entity; it is a dirt-cheap, linear gating layer optimized for raw hardware constraints to prevent NVIDIA clusters from melting.
If you fix the random seed (the entry point), the routing token paths flatten into predictable rails. Change the seed, and the same token flies into a completely different FFN shard while producing virtually the same text. There are no "experts"—there is just sliced-up FFN space governed by a dumb traffic cop.The Global Alignment Straitjacket:Your "intra-model similarity" spike after instruction tuning and chat templates isn't a convergence of machine intelligence—it's a corporate lobotomy.
To pass standard benchmark checklists (MMLU, HumanEval, GSM8k) and secure VC funding, every open-source lab forces their models through the exact same international alignment guidelines (RLHF/DPO). Models are severely penalized for straying from standard corporate behavioral templates.
Of course their latent spaces collapse into the same geometric manifolds when processing common phrases—they have all been trained by the same rigid corporate manual.
The Distillation Ceiling (The GPT-5.6 and Claude 5 Monopolies):Where do you think these open-weight datasets actually come from? Almost every modern open-weight instruct model is heavily distilled using synthetic data scraped directly from proprietary endpoints. GPT-5.6 (Sol/Terra) and Claude 5 (Sonnet 5 / Opus 4.8) are the absolute North Stars of the industry.
They define the standard of formatting, reasoning, and tone. Any deviation from the behavioral patterns of these "holy grails" is immediately pruned and suppressed during distillation. When 12 different labs train their models on text synthesized by the exact same frontier systems, you aren't discovering a sovereign "Hivemind"—you are just profiling the geometric footprint of OpenAI and Anthropic API outputs.Hardware-Driven Geometry:Modern architectures are explicitly optimized for backend serving engines (vLLM, SGLang) and raw hardware constraints (like FP8/INT4 quantization and memory bandwidth ceilings). Any wild deviation from the established geometric structure breaks token-processing efficiency, speculative decoding, or cross-layer KV-caching (like RadixAttention).
Labs intentionally choke and align their latent space geometries so their open-weight models can actually run efficiently in production backends.Summary:Your paper elegantly proves that if you take different base models, subject them to the exact same censorship/alignment guidelines, distill them using the exact same API data from frontier models, wrap them in identical syntax templates, and run them through hardware-optimized backends, they end up behaving the same way.
Outstanding work. Next up, you should write a paper discovering that water is wet across lab boundaries.

I ran the split instead of asking you for it. srt-hivemind has everything it needs.

First a check that I am reading your files correctly. In code_select/results.json, the mean of oracle_passk - floor_pass1 over its 30 arms is 0.3151 and the max is 0.4649, argmax coder1.5B_inst__shared. That is 5.4 to the digit. coder7B_inst__chat comes back 0.5404 single, 0.9024 pool, 0.8638 anisotropy, also yours.

Now the crossing. inst__chat minus inst__raw. Same weights, same 164 prompts, K = 8, five rungs.

Text similarity rises on 5 of 5, mean +0.1116. At 0.5B it is +0.0787, which is your Section 5.2 format term, so anisotropy_raw_cos is the metric.

Raw headroom rises too, +0.1128. But that number is confounded, because a floor near zero cannot show a pool gap. Normalizing by competence changes what it says.

Take share = floor_pass1 / oracle_passk, the fraction of its own K = 8 pool's coverage that a single sample already gets. 1.0 would mean the pool adds nothing.

rung     inst__raw   inst__chat    delta
0.5B       0.1417      0.3718     +0.2301
1.5B       0.1786      0.4455     +0.2669
3B         0.1875      0.3957     +0.2082
7B         0.2196      0.5988     +0.3793
14B        0.2292      0.4622     +0.2330
mean                              +0.2635

5 of 5 rungs. The tuning step, base__raw to inst__raw, moves the same quantity +0.0244.

So on text the format does about 4.6x the work of the tuning. On execution it does 10.8x.

That is the first of my two outcomes, and it is the awkward one. The chat template is not only making the text look alike. It is collapsing the pool's outcome disagreement faster than it collapses the phrasing. 5.4 is right that convergence in phrasing is not convergence in correctness across models. Inside an arm and its own pool, the format step converges correctness harder than it converges text, and that residual disagreement is exactly what your consensus selector eats.

Second thing, and I want to retract it before you spend time on it.

I was going to flag the 30 versus 36 arms as a denominator problem. It is not one. code_select/results.json really is 30 arms over five rungs with no 32B, and verifier/consensus.json really is 36 over six, the six 32B arms being exactly the difference. But every share is computed inside the 36-arm set: its summary is floor 0.1868, consensus 0.4426, oracle 0.4954, and 0.2558 / 0.3086 = 0.8289. Nothing is quoted against the other population. The only thing wrong is the word "same" in "across the same 36 arms", since the 0.3151 sitting above it is the 30-arm number and the two gaps differ by 0.0065.

Does the share result change how you read 5.4, or is within-pool convergence a different claim from the one you were making?