REAX / COMPETITIONS / RULES
Declaring inference settings: format (round 2, Generalist track)
Published with rules v2.8, 22 November 2026, 15:30 UTC. This page is the format that rule 2.5 promises.
What this is
Rule 2.5 lets you declare inference settings that change how your model runs without changing its weights: running layers more than once ("loops") and reading the input a second time ("re-read"). The entry must stay one model answering in one request, and it may use at most twice the compute per item of its base's setup, averaged over the items.
This page says where to declare it, which fields I read and how I check the 2x.
What is supported today: nothing, for scoring. My engine does not run declared settings yet. An entry that declares one waits with the status "declared setting not supported yet" on your uid page. It keeps its commitment time and is processed once my engine supports the setting (rules 2.5 and 4.2). I post in #92 when a setting is supported. No declaration means the entry runs as its base's setup, which is the normal case.
Where it goes
An inference object in reax-specialist.json, next to your lineage record. It is part of the pinned revision, so it travels with your weights.
"inference": {
"loops": [
{"layers": [32, 43], "passes": 2},
{"layers": [44, 55], "passes": 2}
],
"loop_blend": "residual_mean_1_over_P",
"reread": false,
"compute_ratio": 1.375
}
Fields
| Field | Type | Rule |
|---|---|---|
loops |
list of {layers: [a, b], passes: P} |
layers are 0-based layer indices, both ends included, so a block has b - a + 1 layers. passes is a whole number from 1 to 16 and counts all passes over the block (2 = the block runs twice). Blocks are in ascending order and do not overlap. Every index must exist in your config.json. |
loop_blend |
"residual_mean_1_over_P" or "replace" |
Required whenever the inference object is present. How a repeated block combines its passes. residual_mean_1_over_P: pass k starts from x_(k-1) and gives x_k = x_(k-1) + (G(x_(k-1)) - x_(k-1)) / P, where G is the block. replace: x_k = G(x_(k-1)). I do not guess a blend. |
reread |
true or false |
true means the whole input is read one more time, in full, in the same request (T ratio 2.0, see below). A partial re-read is not a declared setting. Allowed only if the base's setup does not already re-read (see "Re-read" below). |
compute_ratio |
number | Your own figure for R (below). It is for your information. I use my figure. |
loops, loop_blend and reread must all be present when the inference object is present. A malformed object (a missing field, overlapping or descending blocks, an index outside config.json, passes that is not a whole number from 1 to 16, an unknown value) is NEEDS CORRECTION. A missing inference object means the base's setup. An object in which every passes is 1 (or loops is empty) and reread is false also means the base's setup. I then ignore loop_blend and compute_ratio.
The declared schedule runs the same way on every item. It may not depend on the input (no skipping or adding passes for some items). I do not carry a KV cache from one pass to the next, and recurrent state restarts at each pass. A declaration that needs anything else is not supported.
How I check the 2x
I compute the layer-token ratio R of your entry against its base's setup. I compute it ourselves from your declaration and your config.json; the base's own steps (such as its own re-read) are in the baseline.
L_entry = depth_entry + sum over loops of (passes - 1) * (b - a + 1)
R = (T_entry / T_base) * (L_entry / depth_base)
- A layer is one transformer block as my engine reads it from
config.json.depth_entryanddepth_baseare those counts. A block that holds several blocks fused together counts as the number it holds; declare fused blocks as separate layers. depth_entryanddepth_basecome from the twoconfig.jsonfiles. Layers you add by copying layers (rule 2.5) raise R.T_entry / T_baseis the number of input tokens the entry's setup processes per item divided by the number the base's setup processes for the same item, averaged over the items. It is 1 unless you declarereread, and 2 with it. Because the schedule is the same on every item, the average is the per-item figure.- The layer-token ratio is a proxy. It does not weigh the layer types (for example full attention and Gated-DeltaNet layers) differently.
R above 2.0 is NEEDS CORRECTION (rules 3.2). It is not a misdeclaration and has no penalty. You correct the declaration within 24 hours and the commitment time stays, or you commit a new revision. R of exactly 2.0 or less passes this check.
The schedule check. I also run your model on a fixed probe of several items, with a hook on every layer that counts real layer calls and the input tokens read. The counts must match the declared schedule exactly on every probe item (with no inference object, the schedule is one call per layer, so undeclared loops or re-reads fail too): layer i runs once, or passes times if it is inside a declared block. If they do not match, the entry is NEEDS CORRECTION. A wrong compute_ratio alone is only shown on your uid page; it opens no correction clock (optional paperwork, rules 3.2).
Re-read
A declared re-read feeds the whole input twice, so T_entry / T_base is 2 before any loop. Plainly: a re-read plus any loop does not fit under 2x. Loops alone can fit, and a re-read alone is at the edge: R is 2.0 and it passes only if my computed R stays at most 2.0.
If the base's setup already re-reads (for example the conditional re-read in the setup of Jeffan-31b-1710, or a setup that reads the input twice), that re-read is part of the baseline and you get no extra allowance. Declare reread: false and your entry runs it as the base does. reread: true on such a base is NEEDS CORRECTION.
Worked example
Base: a 64-layer model, so depth_base = 64. Your entry keeps 64 layers and declares the loops from the example above, no re-read.
- Block 1 is layers 32 to 43:
43 - 32 + 1 = 12layers, 2 passes, so(2 - 1) * 12 = 12extra layer calls. - Block 2 is layers 44 to 55:
55 - 44 + 1 = 12layers, 2 passes, so another 12 extra layer calls. L_entry = 64 + 12 + 12 = 88.T_entry / T_base = 1, becauserereadis false.R = 1 * 88 / 64 = 1.375. This is at most 2.0, so the declaredcompute_ratioof 1.375 is right and the check passes.
Three more cases on the same 64-layer base:
| Declaration | L_entry | T ratio | R | Result |
|---|---|---|---|---|
one block [0, 63], passes 2 |
64 + 64 = 128 | 1 | 2.0 | at the limit, passes |
one block [0, 63], passes 3 |
64 + 128 = 192 | 1 | 3.0 | NEEDS CORRECTION |
reread: true and one block [32, 43], passes 2 |
64 + 12 = 76 | 2 | 2 * 76 / 64 = 2.375 | NEEDS CORRECTION |
The largest total of extra layer calls that fits without a re-read is sum (passes - 1) * (b - a + 1) <= depth_base when the entry keeps the base's depth.
What does not change
Your entry still answers in one request as one model (rule 2.3). Declared entries keep waiting under 4.2 with their commitment time, and they count as in intake for the keep-alive (rule 6.6).