juiceb0xc0de/nova-1-large-atlas-v1.3

A brain atlas for Smilyai-labs/Nova-1-Standard-1.3B-Preview, a 24-layer Mixture-of-Depths transformer. This is not a chat dataset or a benchmark - it is an internal-mechanics map built by running activations through a corpus of prompts and scoring what each layer, component, head, and feature direction is doing.

If you want to know whether a model represents code and math in the same directions or different ones, what a depth-routed architecture looks like from the inside, or which directions survive a causal test rather than merely scoring well, this is the dataset.

What was run

• Model: Smilyai-labs/Nova-1-Standard-1.3B-Preview
• Corpus: 8,965 diverse prompts across 17 buckets
• Layers probed: all 24
• Behavioral axes: two, both against a shared baseline - code (code probe against neutral stem) and math (math probe against neutral stem)
• Scored projections: gate_proj, up_proj, down_proj, q_proj, k_proj, v_proj, o_proj - all seven
• Passes: activation census, feature taxonomy, per-head analysis, OV-circuit SVD, logit lens, coactivation, code-analysis, two axis contrasts, cone geometry, candidate singular-vector scoring, causal intervention, DAS rotation, capability fence

Architecture notes

Property	Value
Parameters	1.27B
Hidden size	2,048
Layers	24 (12 full + 12 Mixture-of-Depths)
MLP width	5,504
Query heads	16
KV heads	8
GQA group size	2 query heads per KV head
Head dimension	128
Vocabulary	50,304 (GPT-2 BPE base, extended)
Mixture-of-Depths interval	every 2 layers
Mixture-of-Depths capacity	0.5
Tied embeddings	yes
Training stage	Phase 3 SFT, checkpoint step 5,707
Pretraining tokens	~4.0B

A dense SwiGLU transformer with grouped-query attention and Mixture-of-Depths routing. The MLP width of 5,504 is the ffn_mult of 2.667 applied to a 2,048 hidden size and rounded to a multiple of 256.

This is a preview checkpoint, and that shapes how the whole atlas should be read. The model has seen roughly 4.0B pretraining tokens against 1.27B parameters, about 3 tokens per parameter, where compute-optimal guidance sits nearer 20. Every number here describes a model partway through its training run rather than a finished artifact. Where a result looks unusual, training budget is the first explanation to reach for, and finding 10 is the clearest case of it.

The Mixture-of-Depths configuration is the structural feature worth knowing before reading the tables. Every second layer runs at 50% capacity, meaning only half the tokens are routed through that block while the rest bypass it. Because the census aggregates per prompt rather than per token, this atlas cannot measure routing capacity directly, but the parity signature it leaves behind is visible and is covered in finding 3.

The surgery side runs as a funnel rather than a single sweep. Candidate singular vectors are scored statically, a subset is put through causal intervention and either kept or dropped, survivors are rotated into DAS axes, and those axes face a five-domain capability fence. Each stage has its own table, so you can see what the previous stage threw away. Both axes go through the funnel independently.

What the tables contain

Table	Rows	What it gives you
behaviour_axis_features	1,185,792	two axes × 592,896 features
features	592,896	feature taxonomy + activation stats per (layer, component, feature_idx)
axis_svs	66,908	scored candidate singular vectors across seven projections
coactivation	37,628	feature-pair correlations
logit_lens	7,680	promoted/suppressed output tokens per feature
axis_causal	6,720	causal intervention scores and keep decisions, both axes
code_analysis	5,760	entangled vs selective role labels
behaviour_axis_per_head	2,304	per-head axis separation, both axes
per_head	1,152	per-head selectivity across 24 layers
axis_capability	690	138 DAS axes × 5 capability domains
ov_circuits	384	SVD over W_V @ W_O plus QK/FC spectral metrics
axis_das	138	DAS axes with singular values and explained variance
axis_cone	48	per-layer cone geometry, both axes
layers	24	layer metadata and completion flags

Key findings

1. Code and math occupy almost entirely separate directions

Both axes were scored against the same neutral baseline, which makes them directly comparable. Ranking every feature by axis F-stat and intersecting the two lists:

Comparison	Shared features
Top 100 code against top 100 math	0
Top 1,000 code against top 1,000 math	8

Not one of the hundred strongest code directions appears among the hundred strongest math directions. Out of a thousand, eight.

This model does not carry a general "technical content" direction that both probes load onto. Whatever separates code from neutral prose and whatever separates math from neutral prose are, at the top of the ranking, different machinery. That is worth knowing before treating a code-selective direction as a proxy for reasoning or symbolic content generally.

2. The code axis is roughly three times stronger than the math axis

Mean F-stat across all 592,896 features: 73.76 for code against 24.02 for math.

By component:

Component	Code F-stat	Math F-stat	Code max	Math max
up	82.5	25.9	1,633	500
v	81.4	23.6	1,198	429
q	78.5	23.0	1,350	506
k	75.0	22.4	1,125	433
mlp	73.1	23.8	1,572	513
gate	71.6	23.3	1,503	565
attn	65.8	25.1	1,514	479
heads	56.7	22.6	1,334	535

The gap holds across every component, and the ceiling differs by roughly 3× as well: the strongest code feature scores 1,633 while the strongest math feature reaches 565.

Two readings are available and the atlas does not settle between them. The model may genuinely represent code more distinctly than math, or the math probe may be less separable from the neutral stem than the code probe is. Probe construction is part of the measurement here. What the atlas does establish is that on this corpus, with these probes, code is the sharper of the two signals by a wide margin.

3. The Mixture-of-Depths parity shows up in the gate path

The architecture routes only half the tokens through every second layer. The census cannot see token routing directly, but it leaves a parity trace.

Comparing each even layer against the odd layer immediately after it, the even layer has the lower mean activation rate in 11 of 12 pairs. Aggregated:

Layers	Mean activation rate	Dead coordinates
Even	0.4841	37.7%
Odd	0.5032	36.4%

The effect is concentrated almost entirely in one component:

Component	Even-layer rate	Odd-layer rate	Gap
gate	0.4273	0.5121	0.0848
v	0.4992	0.5088	0.0096
heads	0.4966	0.5055	0.0089
q	0.5043	0.4987	-0.0056
k	0.5009	0.4964	-0.0045
attn	0.4971	0.4999	0.0028
mlp	0.4991	0.5024	0.0033
up	0.5030	0.4975	-0.0055

Every component except gate sits within 0.01 and several flip sign. The gate gap is roughly nine times larger than the next largest and points the same way as the config.

The split the census recovers matches the documented architecture exactly. The model is specified as 24 layers built from 12 full blocks and 12 Mixture-of-Depths blocks, and the parity trace lands on a clean 12 and 12.

The gate is the natural place for this to surface, since it is the component whose job is deciding whether a coordinate contributes at all. On capacity-limited layers it has fewer tokens to fire on and the per-prompt activation rate drops accordingly. Read this as a signature consistent with depth routing rather than a measurement of it - the honest version needs per-token capture, which this run did not do.

4. The causal filter removes 97.5% of candidates

The surgery funnel scores 66,908 candidate directions, puts 6,720 through causal intervention, and keeps 168, a survival rate of 2.5%. Broken out, the code axis keeps 95 of 3,360 and the math axis keeps 73 of 3,360.

What separates survivors from casualties:

Outcome	Directions	Mean causal score	Mean composite score
Kept	168	0.0600	0.537
Dropped	6,552	-0.0026	0.497

Causal scores differ by more than an order of magnitude and flip sign. Composite scores, the static blend of Wanda and magnitude heuristics, differ by 0.040. There is some signal in the static score here, but it is small next to the causal separation, and a ranking built on it would put most of the discarded directions ahead of most of the kept ones.

If you use axis_svs scores to pick edit targets, use axis_causal.kept instead.

5. The two axes separate in opposite directions with depth

The cone pass measures mean distance between probe and baseline representations over 200 prompt pairs per layer per axis:

Layer	0	4	8	12	16	20	23
Code	11.97	12.75	11.76	11.92	13.60	14.62	15.27
Math	11.58	10.04	9.26	9.38	10.64	11.53	12.05

The two axes start within 0.4 of each other at layer 0 and end 3.2 apart. Code separation dips slightly through the first third and then climbs steadily to its maximum at the output layer. Math separation falls to a minimum at layer 8, roughly 20% below where it started, then recovers without ever regaining its layer-0 lead.

The model sharpens its code representation as depth increases. Its math representation is weakest in the middle of the network and only partially recovers. Combined with finding 1, the two probes are not just using different directions, they are on different trajectories.

6. The MLP projections carry no fence failures at all

Capability-fence failures by projection:

Projection	Rows	Failures	Failure rate
down_proj	100	40	40.0%
o_proj	145	40	27.6%
k_proj	75	20	26.7%
v_proj	95	25	26.3%
q_proj	65	5	7.7%
up_proj	80	0	0.0%
gate_proj	130	0	0.0%

Not one gate or up axis fails the fence across 210 tested rows. The risk sits in down_proj and the attention output path.

The practical reading is that in this model the expansion half of the MLP is comparatively free to edit while the contraction back into the residual stream is not. down_proj is where the MLP writes its result into the shared representation, and the fence says that write is load-bearing in a way the expansion is not.

7. Surgical headroom is 81.2%, and layer 0 holds the worst axis

138 DAS axes against five capability domains, 690 rows:

Domain	Pass rate	Mean damage	Max damage
factual	81.2%	0.108	2.421
code	81.2%	0.091	2.068
math	81.2%	0.089	1.675
multilingual	81.2%	0.078	1.184
reasoning	81.2%	0.066	0.989

The pass rate is identical across domains because every failing axis fails in all five at once. The 112 surviving axes average 0.0223 nats/token with a worst case of 0.147, while failures reach 2.421. Two populations with very little between them.

Split by axis, code candidates are slightly safer to remove than math candidates: 83.8% pass against 78.1%.

The single worst result is layer 0 o_proj axis 0, which fails at 2.421 on factual for the code axis and 2.418 for the math axis. The same projection and axis index in the same layer is the top failure for both, which is what you would expect if the direction is load-bearing for the model generally rather than for either probe specifically.

8. Attention transforms broadly and induction is spread through depth

Path	Mean spectral concentration	Mean effective rank	Fraction of 128-dim head
OV	0.078	44.1	34.5%
QK	0.225	19.1	14.9%

The OV path spreads across about a third of the head, a high-dimensional weighted transform rather than a sparse token lookup. The QK path is tighter but not dramatically so.

Induction averages 0.533 model-wide and does not concentrate at either end:

Layers	Induction score	OV effective rank
0-5	0.572	40.5
6-11	0.486	44.2
12-17	0.557	47.9
18-23	0.516	44.0

The strongest individual heads sit at layers 3, 18, 5, and 7, spanning the network rather than clustering. Copy-and-continue behavior is distributed here rather than installed in one band.

Effective rank does not transfer across architectures without normalizing by head dimension, so treat these as fractions rather than raw numbers.

9. KV-paired heads are near-identical at matched coordinates

Query heads pair up two to a KV head. In the heads component a feature index is head*128 + d, so an offset of exactly 128 is the same within-head dimension in the partner head, and 256 or more crosses into another pair.

Offset	Pairs	Mean correlation
128 (partner head)	738	0.961
Cross-group	570	0.033

At 0.96, two heads sharing a KV projection are running very close to the same computation at matched coordinates. That is the tightest coupling in the atlas, and with only two heads per group it means half the query heads are close to redundant with their partner.

gate is the only other component with substantial internal correlation at 0.461. heads overall sits at 0.139, and up, attn, q, v, k, and mlp are all within 0.02 of zero.

10. The output vocabulary has not settled yet, which is what a 3-tokens-per-parameter checkpoint looks like

Component	Mean F-stat	Max F-stat
gate	88.1	202.7
mlp	85.0	215.0
up	83.4	190.2
heads	74.7	168.9
attn	71.4	143.0

The spread between the strongest and weakest component is 17 points, and the strongest single feature in the whole pass reaches only 215. Signal is flat across depth, ranging from 71.6 to 101.1 by layer with no peak worth naming.

The token lists match that picture. Layer 7 mlp 540, the top feature at 215.0, promotes delegates, II, inals, effic, ERO, won, Thomson, ateurs, which has no coherent theme. Most other high scorers look similar.

This is the expected result at this training stage, not a property of the architecture. The logit lens reads a direction by projecting it through the unembedding, so it can only recover coherent token families once the mapping from residual directions onto output vocabulary has actually converged. At roughly 3 tokens per parameter, that mapping is still forming. A flat, low-amplitude, semantically noisy logit lens is what a mid-training checkpoint should produce, and it says nothing about what the same architecture would look like at a compute-optimal token budget.

Two supporting details point the same way. Layer 0 gate 725 promotes embedreportprint, a well-known anomalous token inherited from the GPT-2 BPE vocabulary this tokenizer extends, and anomalous tokens stay anomalous until enough training pressure resolves them. And the taxonomy pass resolved zero domain-specific directions anywhere in the model, with all_shared the largest class at 38.95%, which is the same story from a different angle: representations that have not yet differentiated.

The practical consequence for anyone using this atlas is narrow. Do not mine logit_lens here for steering targets. The census, axis, cone, and causal tables are measuring structure that has formed, and findings 1 through 9 rest on those.

What the axis passes are measuring

The axis passes are not a generic "find all important directions" sweep. Each looks for directions that separate a probe set from a neutral baseline, scores candidates statically, tests a subset causally, rotates survivors into DAS axes, and then uses a capability fence to check whether removing those axes damages code, math, reasoning, factual, or multilingual ability. The rows in axis_capability are domain-by-domain damage scores for those candidate axes, not a census of every load-bearing direction in the model.

Important caveats

• Read the recorded model_id with care. manifest.json and layers.model_id both record Smilyai-labs-beta-testers/Nova-1-Large-2.5B-Preview, the repository path the weights were pulled from when this atlas was built. That repository's contents were replaced later the same day. The geometry captured here - 2,048 hidden, 24 layers, 16 query heads, 8 KV heads, 5,504 MLP width, 50,304 vocabulary - matches Smilyai-labs/Nova-1-Standard-1.3B-Preview exactly, and that is the model this atlas describes. The features row count closes on that geometry to the row.
• This is a mid-training checkpoint, and that is the first explanation for anything unusual. Phase 3 SFT at step 5,707, roughly 4.0B pretraining tokens against 1.27B parameters. Structure that has not formed yet will read as absent, and structure still forming will read as noisy. Finding 10 is the clearest instance, and the zero-specific_* taxonomy result belongs in the same bucket. None of it generalizes to what this architecture looks like trained to a compute-optimal budget.
• The causal stage tested a sample, not the full candidate pool. 66,908 candidates were scored, but causal intervention ran on 6,720 directions, about 10.0%. Finding 4 compares kept against dropped within that tested subset and is not a statement about the 60,188 candidates never tested.
• The Mixture-of-Depths result is a signature, not a measurement. The census aggregates per prompt, so it cannot observe token-level routing. Finding 3 reports a parity pattern consistent with the documented configuration. Confirming it needs per-token capture, which this run did not perform.
• Axis strength is a joint property of the model and the probe. Finding 2 reports that the code axis separates about 3× more strongly than the math axis. That could reflect the model or the probe construction, and this atlas cannot distinguish the two.
• coactivation stores a selected subset of feature pairs, not a full census. The comparisons in finding 9 are relative differences within that subset, meaningful as contrasts but not population means.
• No domain-specific directions resolved. The taxonomy returns zero specific_* features across all 592,896, and all_shared dominates at 38.95% with 37.02% never activating. Two things are mixed together here: general-purpose corpus buckets that a model has little reason to build dedicated detectors for, and a training budget at which specialized directions would not have differentiated yet. This atlas cannot separate those, and neither should be read as a ceiling on the architecture.
• Coactivation buckets describe the prompt mix. Dominant buckets come out business (16.4%), design (10.3%), and creative_writing (6.0%), with 30.4% uncategorized. Those proportions reflect the corpus, not the model's priorities.
• Effective rank is not comparable across model families without normalizing by head dimension. This model's heads are 128-dimensional.
• The paired-head result is correlational, not causal. A 0.96 correlation is a strong merging signal, not proof that removal is free. That needs a fenced ablation run.
• Damage is in nats per token, measured on the fence probes, not on any public benchmark.
• No downstream benchmark is implied. The atlas describes what the tensors do on this corpus, not whether the model is good at your task.

How to use

atlas.sqlite is the primary query surface. PRAGMA integrity_check returns ok, and the features row count closes exactly against the model geometry at 24 layers × 24,704 coordinates.

import sqlite3
import pandas as pd

conn = sqlite3.connect("atlas.sqlite")

# do the code and math probes actually use the same directions?
df = pd.read_sql_query("""
    WITH code AS (SELECT layer_id, component, feature_idx FROM behaviour_axis_features
                  WHERE axis_label = 'code' ORDER BY fstat DESC LIMIT 1000),
         math AS (SELECT layer_id, component, feature_idx FROM behaviour_axis_features
                  WHERE axis_label = 'math' ORDER BY fstat DESC LIMIT 1000)
    SELECT COUNT(*) AS shared_directions
    FROM code JOIN math USING (layer_id, component, feature_idx)
""", conn)

The per-layer artifacts under layers/, features/, logit_lens/, and ov/ mirror the same data if you would rather not open the database.

-- the depth-routing parity trace, one component at a time
SELECT component,
       ROUND(AVG(CASE WHEN layer_id % 2 = 0 THEN activation_rate END), 4) AS even_layers,
       ROUND(AVG(CASE WHEN layer_id % 2 = 1 THEN activation_rate END), 4) AS odd_layers
FROM features
GROUP BY component
ORDER BY (odd_layers - even_layers) DESC;

License

Apache 2.0, matching the source model. Consult the source model repository before redistribution or downstream use.

Contact / more

• Model: https://huggingface.co/Smilyai-labs/Nova-1-Standard-1.3B-Preview
• Atlas code: https://github.com/JuiceB0xC0de/qwip_atlas
• Follow: https://huggingface.co/juiceb0xc0de