VINDEX3

EXECUTION · LIVING SPEC §8 · ABI §8.3

FROM DESCRIPTION TO COMPUTATION

A component says what part of the system it is. Its execution surface says what the generic operations need to run it — every value fully resolved when the container was built.

How does VINDEX3 execute a model?

VINDEX3 stores a generic model program. Components declare operators — softmax, MLA, KDA, gated-delta, Mamba2 — and each operator declares the semantics, operands and continuation state it requires. The runtime binds every required operand or refuses by name, then lowers the program to generic kernels without ever recovering the source model family: the checkpoint, config and architecture name can be deleted and execution must not change.

Why doesn't VINDEX3 assume a KV cache?

Because KV is one state family, not the definition of continuation. The program declares what persists between tokens: KV rows for softmax attention, a latent-compressed cache for MLA, fixed-size recurrent state for the delta families, SSM state for Mamba2. A pure-SSM container declares its whole continuation with no KV row anywhere — and the runtime reads the declaration from the plan, never from an architecture guess.

witnessed — mamba2-780m · 2026-08-30

The most dangerous fact in a system is the one whose deletion changes nothing.

WHAT THIS FIXES

That is what a hidden default is: a value the code supplies when nobody is looking — invisible precisely because removing it changes no output, until the day it changes everything. This chapter is a hunt for hidden defaults. Every operand must map to an operation. Every operation must carry judged semantics. And the proof is causal: mutate the stored fact and the computation must change. Where mutation changes nothing, a default was hiding.

An executor reads; it never defaults.

ExecutionSurface — GROUPED BY OPERATION

Seven surfaces. No family knowledge in any of them.

attentionAttentionSurface

Everything softmax attention needs, judged in advance — including the facts no tensor evidence can reveal, like parameter-free QK normalisation, which is a judged semantic.

geometrynum_q_heads · num_kv_heads · head_dim
scalingquery_scale? · score_scale · logit_softcapping?
qk normqk_norm_scope · qk_norm_weight_offset · parameter_free_qk_norm
gatingoutput_gate? — attention output gating is a generic primitive, not a family quirk
extrassinks? · attention_bias?
ffn · moeFfnSurface · MoeSurface

The feed-forward contract, dense or routed through the same shape: a dense layer is simply the surface with no MoE block.

ffnintermediate_size · activation · ffn_type · gate_policy · moe?
routingexperts · top_k · router_kind · routing_policy · router_bias
expert storageexpert_intermediate_size · expert_format · gate_up_layout?
structureshared_experts · branch_scale? · dense_prefix_layers? · hybrid
normNormSurface

Where normalisation sits is operand evidence, judged as placement — PreOnly or PrePost. Count is not semantics; placement is.

fieldspre · post? · final_norm · placement (PreOnly | PrePost)
headHeadSurface

What embedding and output-head objects need — the only surface an Embedding or OutputHead object carries.

fieldsvocab_size · embedding_norm? · embed_scale? · output_multiplier? · final_logit_softcapping? · head_reuses_embedding
linear_attention · kda · mla · mamba2THE OTHER OPERATOR FAMILIES

Recurrent, latent and state-space operators carried as first-class surfaces, present only when the model uses them — never inferred from a model name.

linear_attentionkey_heads · key_head_dim · value_heads · value_head_dim · conv_kernel · state_dtype?
mlanum_heads · kv_lora_rank · qk_nope_head_dim · qk_rope_head_dim · v_head_dim
kdathe KDA geometry, plus kda_gate_lower_bound?
mamba2state_size · num_heads · head_dim · expand · conv_kernel · n_groups · chunk_size · the dt clamp (an unbounded side is a declared fact) · rms_norm · the bias estate · activation

The completeness contract, since graph schema 6: the surfaces follow the component's declared operation program, and presence means semantic presence. A stack whose layers attend carries an attention group; a stack whose program runs an FFN carries an FFN group; a pure-SSM stack carries neither — and writing one anyway is the fabrication schema 6 removed. Object kinds keep identity; they no longer imply operation families. Attention is vocabulary, not ontology.

Seven surfaces. No family knowledge in any of them.attention · ffn · moe · norm · head · linear_attention · kda · mla · mamba2.

SURFACES FOLLOW THE PROGRAM — SCHEMA 6, WITNESSED

BEFORE — KIND-IMPLIED

DecoderStack
      ↓
attention assumed
      ↓
FFN assumed
      ↓
KV assumed

SCHEMA 6 — PROGRAM-DERIVED

Component
      ↓
declared operator program
  softmax · MLA · KDA
  gated-delta · mamba2
  conv-QKV attention · …
      ↓
required surfaces
      ↓
continuation state
mamba2-780m — 48 declared Mamba2 operators · 0 attention operators

before schema 6:   48 fabricated attention surfaces   ✕
at schema 6:       48 Mamba2 operators
                    0 attention surfaces
                    0 FFN surfaces                     ✓

mamba2attn-250m — 28 Mamba2 operators · 4 conv-QKV attention operators

at schema 6:       attention exactly where declared
                   conv-QKV, never plain softmax
                    0 FFN surfaces                     ✓

Both directions of the sentence are now executed evidence, not schema tests. An architecture with no attention fabricates none: the pure-SSM witness was first refused with nineteen itemised findings, then admitted with zero fabricated surfaces and operand closure enforced at encode. And an architecture with selected, non-standard attention gets those operators only where declared: the hybrid witness carries its four conv-QKV blocks — causal convolution over the fused QKV, partial rotary — as their own operator on exactly the declared layers, and runs them at its reference's numerical floor. The Record keeps every half.

OPERAND ROLES — THE TYPED VOCABULARY

Every tensor inside a decoder stack is typed by what it is to the generic operations. An operation plan binds every operand its programme requires, or refuses. Closure needs the complete set — a missing operand is a named refusal, never a silently skipped step.

softmax attention

AttnQ  AttnK  AttnV  AttnO
AttnQBias  AttnKBias  AttnVBias  AttnOBias
AttnOutputGate  AttnSinks
AttnQNorm  AttnKNorm

gated deltanet — nine, closure needs all

LinearAttnInProjQkv
LinearAttnInProjA  LinearAttnInProjB
LinearAttnInProjZ  LinearAttnConv1d
LinearAttnALog  LinearAttnDtBias
LinearAttnNorm  LinearAttnOutProj

mamba2 — nine, one norm per layer

Mamba2InProj  Mamba2Conv1d
Mamba2Conv1dBias
Mamba2ALog  Mamba2D  Mamba2DtBias
Mamba2GatedNorm  Mamba2OutProj
Mamba2PreMixerNorm

conv-QKV attention — five, shared norm role

ConvQkvInProj  ConvQkvConv1d
ConvQkvConv1dBias
ConvQkvOutProj
Mamba2PreMixerNorm

kimi delta attention — fifteen

KdaQProj  KdaKProj  KdaVProj
KdaQConv1d  KdaKConv1d  KdaVConv1d
KdaFAProj  KdaFBProj
KdaGAProj  KdaGBProj  KdaBProj
KdaALog  KdaDtBias
KdaONorm  KdaOutProj

mla · ffn

MlaQProj  MlaKvAProj  MlaKvBProj
MlaKvANorm  MlaOutProj

FfnGate  FfnUp  FfnDown

norms — placement, not count

PreAttentionNorm  PostAttentionNorm
PreFfnNorm  PostFfnNorm
PreExpertsNorm  PostDenseFfnNorm
PostExpertsNorm
placement: PreOnly | PrePost | PreMixer

mixture of experts · misc

MoeRouterWeight  MoeRouterBias
MoeRouterScale  MoeRouterPerExpertScale
ExpertGateUp(+Scales/Bias)
ExpertDown(+Scales/Bias)
PerExpertGate/Up/Down(u16)
SharedExpertGate/Up/Down
LayerScalar

THE REFUSAL THAT TAUGHT THE FORMAT

The gate earned its place in the vocabulary by refusal. The first real four-norm model shipped an attention-gate weight in every one of its 52 layers — and the closure gate refused all 52, naming what was missing: required primitive, attention output gate. Not a crash. A named absence. The gate’s semantics were then judged from the reference implementation, the primitive entered the IR, and the model closed at 52 layers, twelve of twelve operands each. The format learned something new the only honest way: by refusing to guess it.

OPERAND CLOSURE — THREE DEPTHS

CLOSURE, IN PLAIN TERMS

Closure is the promise that nothing in the container is left unexplained. Every stored tensor must be claimed by an operation, and every operation's semantics must have been judged rather than guessed. A weight that no operation consumes does not quietly ride along: the gate refuses to close and names it. That is the second half of the proof the authority chapter starts — agreement says the witnesses do not contradict each other, closure says they left nothing out.

Nothing unexplained: read what closure promises, watch a layer close operand by operand, or read the invariant and the boundary as the specification pins them.

Operand closurelearn: what closure promises · inspect: a layer, closing · spec: the clause that governs it. One concept, one URL, the depth of your choosing.

THE BOUNDED PROGRAMME VOCABULARY

What consumes those operands is a programme built from a closed set of operations: linear, fused linear, activation, clamp, multiply, add, scale, normalise, route, gather, weighted reduction, residual merge, pre and post transforms. There is no general graph interpreter. A new architecture either fits the vocabulary, or extends the registry with a new named programme — in the open.

THE COMPILER BOUNDARY — WHERE FAMILY KNOWLEDGE IS ALLOWED TO LIVE

SOURCE COMPILER — FRONT END

HF model_type, upstream reference
        ↓
architecture-specific judgment OK
        ↓
generic VINDEX3 IR

EXECUTION — BACK END

VINDEX3 IR
        ↓
generic op plan
        ↓
generic kernels
— no family knowledge here

VINDEX3 permits architecture-aware ingestion and produces an architecture-independent executable IR. The trap this guards against has a name — the naming-convention trap. Dispatching on object-id strings is the same defect laundered through a name: the convention becomes an undeclared schema.

Removing the original checkpoint, config.json, the HF model type and the architecture name must not change execution.

STATE IS AN OPERATION REQUIREMENT

Operator
   ↓ declares
ContinuationState — one or more typed regions

softmax attention    └─ KV rows              grows with context
MLA                  └─ latent KV            compressed, per position
gated deltanet       ├─ delta matrix         fixed size, folded every token
                     └─ conv history
Mamba2               ├─ SSM state            head_dim × state_size per head
                     └─ conv history
conv-QKV attention   ├─ KV rows              grows with context
                     └─ conv history         fixed, over the fused QKV
future operators     declared, never assumed

An operator may declare more than one continuation region — and operation family does not imply state shape. Both recurrence families here carry a convolution history beside their folded state, and modelling only the matrix once left a whole buffer invisible until the first single-token continuation. Nor is multi-region state peculiar to recurrence: the hybrid witness's conv-QKV attention — recognisably attention — requires a KV cache AND a convolution history on the same layer, and a provider that can hold only rows refuses the layer rather than allocating half of it. KV is one region kind — not the definition of model continuation. Three real witnesses hold that sentence up: a KDA + MLA + softmax hybrid carrying three state kinds already executes, a pure-SSM container describes its whole continuation as two recurrent regions per layer — eighteen million elements, constant in sequence length, no KV row anywhere — and the Mamba2Attn hybrid runs both mixed regions through generic execution at its reference's own numerical floor. The typed state schema — declared precision for KDA, latent-cache geometry for MLA — closed that half of the lift on 2026-08-31, additive within schema 6: a latent cache is its own region species, one operator-defined row per position rather than a K/V pair, and Kimi-Linear-48B now declares its 20 recurrent layers and its 7 growing caches from the container alone. The rule underneath does not change: state geometry is a container fact, read from the plan, never inferred from architecture — and the surfaces that report it read the same plan, after one summary was caught calling seven growing caches constant-size recurrent state.

THE ENGINEERING CONTRACT, COMPLETE

four-authority consistency + operand closure     = execution sufficiency
execution sufficiency    + independent parity    = execution correctness
execution correctness    + causal mutation controls = semantic authority

The four authorities in that first line, and the ladder these rungs climb, each have their own exhibit.

PUBLISHED 29 AUG 2026 · REVISED 31 AUG 2026 · VERSION 3.0 Candidate

CITE

site build 43a1b6b · built 2026-09-02

CITE THIS

Web page · 3.0 Candidate

Hay, C. (2026). Execution. In VINDEX3 Specification (Version 3.0 Candidate). VINDEX3. https://vindex3.org/execution

A chapter of the specification, citable on its own. Cite the version rather than the site — the canonical reference, and how to use it, live at /cite.

SOURCES

  • vindex3-format.md §8 (the living spec)
  • vindex3-format-spec.md §8.3, §17.4 (the 3.0 Candidate — lift 1 landed at graph schema 6)
  • reference implementation — graph/surface.rs · graph/roles.rs