Every structural rule Neurarch runs on your model

Any destructive action (delete_component, delete_components_matching, rename_components_matching, clear_canvas, replace_model) where downstream impact > 4 layers, or any of them are shape-changing.

Number of downstream layers affected, how many would reshape, how many carry weights (rebuild required).

User confirms in the impact-preview card before the action lands.

Estimated total parameter count grows by ≥ threshold × baseline (default 5×, slider 2-20×). Blocks at 2× threshold, warns below.

A misread "scale this 10×" prompt should not silently turn a 60M model into a 6B model that won't fit anywhere.

useProviderStore.paramExplosionThreshold(). Settings → "Param explosion threshold".

An add_connection closes a cycle in the existing DAG. DFS check on the union of current edges and proposed edges.

NN forward graphs are acyclic. Recurrence lives inside the layer type (LSTM, GRU), not as a graph cycle. A connection that closes a cycle is almost always a mis-step.

DAG requirement matches PyTorch nn.Module.forward semantics. torch.autograd docs note that gradient computation requires a DAG.

add_component without afterName, and no follow-up add_connection referencing the new component as either endpoint.

A new layer that's not wired is dead code. The agent occasionally proposes these when it forgets to chain edits; the warning flips the decision back to the user.

Propagates tensor shapes through the sandboxed post-action graph and surfaces only the issues the action would introduce. Sub-checks: attention embedDim % numHeads, GQA numHeads % numKVHeads, elementwise merge parent equality, concat axis compatibility, explicit linear inFeatures vs upstream, computeOutputShape throw, and outputs with NaN / 0 / negative dims at the first layer to introduce them.

Per-layer transforms from componentRegistry.computeOutputShape. Head-dim convention from Vaswani et al. 2017 (Attention Is All You Need). GQA ratio from Ainslie et al. 2023 (GQA).

Text-layer review tools (Cursor, Copilot) can't catch embedDim=384, numHeads=5 until the GPU rejects the kernel. This gate fires sub-millisecond, pre-apply.

Model has ≥ 1 component but no component of type input.

Without an Input layer, tensor shapes can't be propagated and generated code is incomplete.

Drag an Input layer from the I/O section of the palette.

Model has > 1 component but no component of type output.

Code generator can't tell where the forward pass terminates.

Component has no inbound and no outbound connections.

Most often a stranded layer left over from a refactor. Code generator skips it but it inflates the visual graph.

A non-output node has inbound connections but no outbound connections.

Compute happens but the result is discarded. Gradients flow into a black hole.

A normalization layer is connected directly downstream of an activation (relu, gelu, swish, etc.).

Normalization is meant to stabilize the pre-activation distribution. Applying it after activation breaks the assumption and shifts already-nonlinear features back toward zero mean.

Ioffe & Szegedy 2015, BatchNorm places BN between Linear/Conv and the activation.

A dropout layer is connected directly upstream of a BatchNorm.

Dropout at train time changes the activation variance; BN's running statistics get distorted. A known train-vs-eval mismatch.

Li et al. 2018, "Understanding the Disharmony Between Dropout and Batch Normalization".

An explicit Softmax or Sigmoid layer is wired directly into Output.

PyTorch's nn.CrossEntropyLoss applies LogSoftmax internally; an explicit Softmax before it double-applies and slows training. BCEWithLogitsLoss has the same issue with Sigmoid.

torch.nn.CrossEntropyLoss docs.

A normalization layer is wired directly into Output without a final linear / classification head.

Normalization zero-centers the logits, breaking calibration. The model's output scale is no longer meaningful.

≥ 8 weight-carrying layers (conv2d / linear / etc.) and zero residual / skip / add nodes.

Gradient signal degrades through depth without skip connections.

He et al. 2015, ResNet.

Model contains attention layers but no positional encoding (sinusoidal, learned, RoPE, ALiBi).

Self-attention is permutation-invariant. Without PE, the model is a bag-of-words and can't learn order.

Vaswani et al. 2017, Attention Is All You Need, Section 3.5.

Sigmoid or Tanh activation appears in a network with ≥ 5 weight-carrying layers.

Saturating activations vanish gradients in deep stacks. ReLU / GELU / SiLU are the modern defaults.

Glorot & Bengio 2010 on the vanishing gradient problem.

≥ 7 non-I/O layers and zero normalization layers (BN / LN / IN / GN / RMSNorm).

Without normalization, deep nets converge slowly and are sensitive to initialization scale.

Any dropout layer with p > 0.65.

Common dropout rates are 0.1 to 0.5. Anything above 0.65 usually indicates a typo or a confused regularization strategy.

Any layer's estimated activation tensor exceeds 50 M elements (~200 MB per sample at float32).

Activations live in GPU memory through the backward pass. One bloated layer forces tiny batch sizes or OOM.

Model contains an MoE layer but no auxiliary load-balance loss is referenced.

Without an aux loss, experts collapse into a few dominant ones. Most papers add a 0.01 weight router-balance term.

Shazeer et al. 2017, Sparsely-Gated MoE, Section 4.

A groupedQueryAttention component has params where numHeads % numKVHeads != 0.

GQA groups query heads; the group size must divide the head count. Mis-set ratios crash on the first attention forward.

Ainslie et al. 2023, GQA.

A swiGLU / gated FFN has intermediateSize that doesn't follow the common ~(2/3) × 4 × hidden convention used in LLaMA / Mistral.

Param-count parity with standard FFN; mis-sized SwiGLU silently changes the FLOP and param budget.

Shazeer 2020, GLU Variants.

A convolution (conv1d/2d/3d or a depthwise/separable/transpose variant) connects directly into a linear layer.

Conv outputs a multi-dimensional feature map; Linear expects a flat [batch, features] tensor. The forward pass raises a shape error, or silently mis-multiplies the spatial dims. Insert a Flatten or a Global Average Pool between them.

Standard CNN classifier construction (e.g. LeNet / AlexNet head).

An activation node (relu/gelu/silu/sigmoid/tanh/softmax/…) connects directly into another activation node with no Linear/Conv/Norm between them.

Two activations in a row add compute but no expressivity (same-type is a no-op duplicate). A common slip is ReLU → Softmax, which clips logits to ≥ 0 and distorts the output distribution.

Composition of pointwise non-linearities adds no representational power without an intervening affine map (universal-approximation premise).

A linear layer connects directly into another linear layer with no activation between them.

Two stacked linear maps collapse into one (W₂·W₁), so the extra layer costs parameters but adds no representational power — usually a forgotten ReLU. Deliberate low-rank / factorized projections (down-proj → up-proj) are the safe exception.

Linear-map composition closure; the rank of the product cannot exceed the smaller intermediate dimension.

A dropout layer is the last node before the output node.

In training this randomly zeroes the final logits fed to the loss; at eval it is a no-op, so train and eval behaviour diverge. Dropout belongs before the final projection (Linear/Conv), not after it.

Srivastava et al. 2014 (Dropout) — dropout regularizes hidden representations, not output logits.

A downsampling convolution (conv1d/2d/3d, depthwise, or separable) has stride > kernelSize.

The kernel jumps past its own footprint each step, so a band of the input is never read — a silent loss of information. Non-overlapping patches use stride == kernel (e.g. ViT 16/16); stride > kernel is almost always a typo.

Convolution arithmetic — Dumoulin & Visin 2016.

A flatten or linear layer connects directly into a (non-transpose) convolution.

Mirror of R18: a Conv needs a [channels, …spatial] feature map, but Flatten / Linear emit a flat [batch, features] vector. The forward pass raises a shape error unless the spatial dims are rebuilt with a Reshape / Unflatten first.

PyTorch nn.Conv*d input-shape contract.

A normalization layer connects directly into another normalization layer (e.g. LayerNorm → BatchNorm).

Normalizing an already-normalized tensor is redundant; the second layer mostly re-centres/re-scales what the first produced and just burns its own learnable parameters.

Idempotence of standardization — Ioffe & Szegedy 2015.

More than one positional-encoding layer (positionalEncoding, learnedPositionalEmbedding, rope, alibi) in the model.

Position is normally injected once. Stacking absolute + rotary, or two of the same, double-counts position and tends to hurt more than help.

Positional-encoding design — Vaswani et al. 2017, RoPE (Su et al. 2021).

A spatial pooling layer (maxpool, avgpool, adaptive pool) connects directly into a linear layer. Global pools are exempt — they already collapse spatial dims.

Sibling of R18: pooling still emits a [channels, …spatial] map, but Linear expects a flat [batch, features] tensor, so the forward pass raises a shape error. Insert a Flatten or a Global Average Pool first.

Standard CNN classifier head construction.

A flatten layer connects directly into an attention layer.

Flatten collapses the sequence dimension into one long vector, leaving a length-1 sequence, so attention has nothing to relate. Keep the [sequence, dim] layout and flatten only after the attention stack.

Attention operates over a sequence axis — Vaswani et al. 2017.

A ConvTranspose2d has kernelSize not divisible by stride (with stride > 1).

Uneven kernel overlap during upsampling deposits more weight on some output pixels than others, producing checkerboard artifacts. Make kernelSize a multiple of stride, or upsample with Upsample + Conv (resize-convolution).

Odena et al. 2016, Deconvolution and Checkerboard Artifacts.

A GroupNorm layer's channel count is not an exact multiple of numGroups.

GroupNorm splits channels into equal groups; a non-divisible count raises at construction. Parallel to the GQA / attention head-dim divisibility checks. Set numGroups to a divisor of the channel count.

Wu & He 2018, Group Normalization.

A single Linear exceeds ~1B parameters (inFeatures × outFeatures).

A dense layer that large (~4 GB float32) almost always means a feature map was flattened without pooling first. Add a Global Average Pool / more downsampling, or factorize the layer. Embedding and vocab-projection heads are the expected exception.

Parameter-budget hygiene; a single matrix this size dominates model memory.