# Alleged Mythos Class "leak" is fake. Forensic Investigation inside. — retained record

> Retained reddit record from reddit:singularity.

Canonical: https://highsignal.app/data/records/b54c7f5b1b81784b

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:singularity)  published 2026-11-01 16:37 ingested 2026-11-02 02:39

[original source ↗](https://www.reddit.com/r/singularity/comments/1xl7lwm/alleged_mythos_class_leak_is_fake_forensic/)

## retained text



```
# numbat: case file

**Subject:** [https://huggingface.co/burner22/numbat](https://huggingface.co/burner22/numbat) **Date:** 2026-11-01 **Method:** Range requests against shard tensor data. Calibration against Qwen2.5-7B.

# Verdict

Not an Anthropic checkpoint.

The packaging is real. The container is real. The tokenizer is real. The embedding matrix is real. Every weight tensor is synthetic.

|Hypothesis|Odds|
|:-|:-|
|Assembled from a real embedding matrix plus generated weights|**99.5%**|
|Real Anthropic checkpoint|**0.5%**|

Two tests each settle it alone.

1. `lm_head[r] = 0.89 * embed[r] + 0.455 * noise[r]` for every row `r`.
2. `input_scale` differs between modules that share an input tensor.

# What the repo claims

* 14T params. 114 layers. Hybrid GDN/MLA. 1,224 experts, top-48, plus one shared.
* NVFP4. 772 shards. 7.72 TB.
* Checkpoint at step 1,830,000 of a 1.96M-step run. Mid-pretraining.
* Codenamed `numbat`, from a Claude Code source leak in March 2026. The leak quotes `prompts.ts`: *"Remove this section when we launch numbat."*

# The packaging is real

|Check|Result|
|:-|:-|
|Shards|772 of 772. No gaps. 7,720,489,342,136 bytes.|
|HF storage|7,720,640,941,879. Zero dedup. Every shard holds unique bytes.|
|NVFP4 blocks|261,888 sampled 16-value blocks. 100.0000% carry a true absmax.|
|Tool versions|`lm-eval 0.4.13` and `nvidia-modelopt 0.47.0` ship today.|
|Transformers|Config says `5.19.0`. Real version. Latest is 5.22.1.|
|Tokenizer|131,072 vocab. 130,808 merges. Equals 131,072 − 256 − 8. Every merge resolves.|
|Param math|107 × 1225 × 3 × 12288 × 2816 = 13.61T. Plus dense, MLA, GDN, embeddings. Lands at 13.7T.|

The generator did its homework. A random fake leaves 5% of NVFP4 blocks without an absmax. This one leaves none.

# The embedding is real

Byte-level BPE, so `Ġ` marks a space.

|Related|cos|Control|cos|
|:-|:-|:-|:-|
|cat / cats|\+0.4750|cat / Paris|\+0.0475|
|dog / dogs|\+0.5515|water / java|−0.0283|
|one / two|\+0.5446|ten / red|\+0.1015|
|king / queen|\+0.3436|the / Tokyo|\+0.0172|
|man / woman|\+0.3577|||
|red / blue|\+0.3511|||
|Paris / France|\+0.3244|||
|Tokyo / Japan|\+0.2468|||

Noise floor is 0.0090. Related pairs sit 3× to 7× above it. Controls sit on it.

Learned structure. Nobody fakes this without a real model.

# Test one: lm_head

Config sets `tie_word_embeddings: false`. So `lm_head` and `embed_tokens` trained apart. Their rows should point in random directions.

|row|numbat|Qwen2.5-7B (real)|
|:-|:-|:-|
|0|\+0.8900|\+0.0165|
|1|\+0.8900|\+0.0259|
|2|\+0.8904|\+0.0196|
|50|\+0.8907|−0.0085|
|100|\+0.8905|\+0.0174|
|500|\+0.8919|\+0.0030|
|1000|\+0.8904|−0.0099|
|mean abs|**0.8906**|**0.0144**|

The cosine holds at 0.890 across every row. The residual holds at 0.455.

    lm_head[r] = 0.89 * embed[r] + 0.455 * noise[r]

Same two constants for all 131,072 rows. Real matrices do not do this.

# Test two: input_scale

`modeling_numbat.py:348`:

    return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))

`gate_proj` and `up_proj` read the same tensor `x`. `input_scale` is the calibrated amax of that tensor. The two values must match bit for bit.

All 1,224 experts read the same hidden state. Their `gate_proj.input_scale` values must match too.

They do not.

|module|input\_scale|
|:-|:-|
|experts.0.gate\_proj|0.18547873198986053|
|experts.0.up\_proj|**0.08691228926181793**|
|experts.0.down\_proj|0.2523329257965088|
|experts.1.gate\_proj|0.07982252538204193|
|experts.2.gate\_proj|0.23889905214309692|
|shared\_experts.gate\_proj|0.09329533576965332|
|shared\_experts.up\_proj|0.09222322702407837|

Fifteen values. Fifteen distinct.

Layer 2 GDN: `q_proj` 0.28462, `k_proj` 0.15753, `v_proj` 0.23753, `g_proj` 0.33552. All read `x`. All differ.

Layer 3 MLA: `q_a_proj` 0.31776, `kv_a_proj_with_mqa` 0.20728. Both read `x`. Both differ.

The values span 0.05 to 0.40. They look drawn, not measured.

# The weights are noise

Every weight matrix holds rows with different scales. Each row holds values with no structure at all.

Input-dimension spread is the tell. Real matrices vary 2× to 5× across input channels. That variation is why block-scaled FP4 formats exist.

|tensor|col-relstd|col max/med|row-relstd|
|:-|:-|:-|:-|
|numbat `embed_tokens` (real)|0.0375|1.34|0.1197|
|Qwen `embed_tokens` (real)|0.0639|2.69|0.0636|
|numbat L0 `up_proj`|**0.0154**|1.06|**0.1209**|
|numbat L0 `down_proj`|**0.0220**|1.10|**0.1206**|
|numbat L0 `o_proj`|**0.0155**|1.07|**0.1211**|
|Qwen L14 `up_proj`|0.0409|1.02|0.0764|
|Qwen L14 `down_proj`|0.0726|1.67|0.0915|
|Qwen L20 `gate_proj`|0.0357|1.45|0.1261|
|Qwen L0 `gate_proj`|0.2999|**18.37**|0.2073|

Two facts.

Real weights bottom out at 0.036. numbat's land at 0.015. Layer 0 of a real model runs 18× column outliers. numbat's layer 0 runs 1.06.

Row spread sits at 0.1206, 0.1209, 0.1211 across three different tensor types. A 0.4% spread. Qwen's vary by 20%.

The embedding in the same file measures 0.0375. That is a real number.

# Block scales agree

Per-block E4M3 scales, input dimension against output dimension:

|tensor|col relstd|col max/med|row relstd|row max/med|
|:-|:-|:-|:-|:-|
|L2 expert0 `gate_proj`|0.0072|1.02|0.1190|1.42|
|L2 expert1 `gate_proj`|0.0070|1.02|0.1193|1.42|
|L2 expert2 `gate_proj`|0.0072|1.03|0.1200|1.44|
|L3 MLA `kv_b_proj`|**0.0022**|**1.01**|0.1374|1.69|

Flat across inputs. Uneven across outputs. The shape of `W[i,:] = s_i * noise`.

# The account

|Field|Value|
|:-|:-|
|Created|2026-10-16T05:58:28Z|
|Name|**"burner"**|
|Models|1|
|Datasets|0|
|Spaces|0|
|Followers|7|
|Discussions posted|**0**|
|Org memberships|none|

The account predates the repo by seven days. It has never posted a comment anywhere on Hugging Face, including under its own eleven threads.

# The upload

|Field|Value|
|:-|:-|
|Repo created|2026-10-23T01:37:02Z|
|Last modified|2026-10-24T19:09:00Z|
|Commits|784 = 772 shards + 11 files + 1 initial|
|Authors|`burner22` on all 784|
|Signatures|none|
|Messages|`huggingface_hub` defaults|

All eleven metadata files landed inside 27 seconds. README, config, tokenizer, `modeling_numbat.py`, index, and training log. All before the first weight shard.

Shards ran from 01:55:18 to the next day at 19:09. Forty-one hours. 18.6 shards per hour. Median gap 110 seconds.

Upload order skips around:

    1, 772, 143, 201, 272, 330, 401, 459, 530, 588, 659, 717, 144, 202, 273, ...

Twelve workers, striding. Throughput works out to 52 MB/s, or 415 Mbps.

Then it stopped. Eight days of silence. The README still says "They're all uploading. Be patient."

# The parameter count

HF reports 6,849,377,242,584 params. The README says 14T. Community thread #6 calls this a lie.

It is not. HF's parser skips `F8_E4M3` tensors, and the 850 GB of block scales carry that dtype. Count two params per packed U8 byte. Add 16.85B BF16. Get 13.68T.

The size claim holds up.

# "Mythos" is a real name

Claude Mythos 5 and 5.1 exist here. Community finetunes date from 2026-06-19. Provider catalogs carry `anthropic.claude-mythos-5`.

The terminology is current and correct. The unverified claim is narrower: the March 2026 source leak, and the `prompts.ts` comment.

# Contradictions

* **NVFP4 on Trainium2 does not exist.** NVFP4 is an NVIDIA Blackwell format. `modelopt` is NVIDIA tooling. Trainium2 has no FP4 path. The FAQ leans on this as the reason a mid-pretraining checkpoint ships quantized.
* **Anthropic does not train in HF transformers.** A hand-written `NumbatForCausalLM` with `auto_map` is not how an internal checkpoint looks. The README pre-empts this: "internal Neuron-parallel runtime... this port."
* **Eval numbers disagree.** `ckpt_metadata.json` reports mmlu n=14042. The training log reports n=281. hellaswag n=10042 against n=201.
* **MMLU 88.5% at 0-shot** from a checkpoint with no post-training sits at the frontier. The repo calls this "raw pretraining."
* **The "Why believe this?" list** checks file sizes, tensor counts, index entries, and round-trip bounds. Every item is a property a generator controls. None require learned weights.

# Replication

**Inventory.**

    curl -s "https://huggingface.co/api/models/burner22/numbat/tree/main?recursive=1" \
      | python3 -c "import json,sys; d=json.load(sys.stdin); \
        s=[e for e in d if e['path'].endswith('.safetensors')]; \
        print(len(s), sum(e['size'] for e in s))"
    # 772 7720489342136

**Test one.** Read the header of shard 1 and shard 772. Compare `lm_head[r]` to `model.embed_tokens.weight[r]`. Expect 0.890 on every row.

    # embed_tokens sits at data offset 6232 of shard 1, not 0.
    # row r starts at 16352 + 6232 + r*24576

**Test two.** The F32 scalars sit contiguously at data bytes 768 to 6232 of shard 1. One 5 KB range request returns all 46 of them.

    curl -sL -r 17120-22583 "https://huggingface.co/burner22/numbat/resolve/main/model-00001-of-00772.safetensors"
    # compare experts.0.gate_proj.input_scale with experts.0.up_proj.input_scale

**Block structure.** Decode nibbles. Confirm each 16-value block holds a code 7. Confirm the block scales stay flat across columns.

# How it was built

1. Take a real `tokenizer.json` and `embed_tokens` matrix. 131,072 × 12,288. No public model matches that shape.
2. Fill every other tensor with `W[i,:] = s_i * N(0,1)`. Draw `s_i` so row spread lands at 0.1197. Reuse that constant everywhere.
3. Set `lm_head = 0.89 * embed + noise`.
4. Draw `input_scale` and `weight_scale_2` from 0.05 to 0.40.
5. Quantize to real NVFP4 with per-16 absmax blocks. Every structural check in the README now passes.
6. Write coherent architecture metadata. Use real tool version strings. Ship a 22 KB `modeling_numbat.py` so `strict=True` loads.
7. Push 7.72 TB over 41 hours with twelve workers.

# What would settle it

One layer of forward pass. Given `lm_head = 0.89 * embed` and the drawn `input_scale` values, the logits will be noise.
```



document fetched 2026-11-02 00:28 · canonical https://reddit.com/r/singularity/comments/1xl7lwm/alleged_mythos_class_leak_is_fake_forensic
