The arms fitted on the final mini-beatrix-3 core, the lookup arm's versions, and the four control twins of 2s. On mini-beatrix-3's final checkpoint (step 245,674, still opening bare) the arm list now holds the arm sets (stages 1-4, stages 1-8, the caption set, the research sets; two seeds each), served one row per set with a box per arm so any subset runs; the sixteen solo arms; and every version of the lookup arm (softmax attention after blocks 2, 6, 12 and 20, born at zero), mounted through amoe 0.2.12 from the arm's own tensors, which are read from the checkpoint by range request when no arm-only file exists. The lookup rows get recall prompts in the Completion tab and an activity line per site; the set rows get each member stage's prompts. The run's own stage programs (the checkpoints to step 148,000) use the same member switch. New crafts: mini-beatrix-2s-control (the original softmax twin) and its re-runs -attn-fp16-r10k (still training), -attn-fp16 and -bf16 (stopped), decoded in fp32. Pin: amoe-lora 5c934cf -> 9b1942d (v0.2.12); geolip-alephllm unchanged.

README.md

@@ -9,7 +9,7 @@ python_version: '3.12'
 app_file: app.py
 pinned: false
 license: mit
-short_description: Three byte-level AlephLLM crafts and their arms
+short_description: Byte-level AlephLLM crafts, their arms, and 2s's twins
 models:
 - AbstractPhil/mini-beatrix-2.5s
 - AbstractPhil/mini-beatrix-3
@@ -19,8 +19,9 @@ models:
 # Beatrix — AlephLLM chat
 
 Three generations of the same byte-level architecture, served side by
-side, newest first. Pick the **Craft** first; everything below it
-follows.
+side, newest first, and four control twins of 2s that run ordinary
+softmax attention where 2s runs the splat. Pick the **Craft** first;
+everything below it follows.
 
 **mini-beatrix-3** — 376M parameters over 32 blocks: the same governed
 full-splat hub, deeper, and the Space's default. Its mission is
@@ -34,7 +35,22 @@ own stage; the run detached them at step 148,000, partway through the
 fourth stage, and finished on the core alone. Pick a checkpoint that
 carries them (a stage close before that point, or 148,000 itself, the
 last with all four) and they open all on, each switchable exactly; every
-later checkpoint, the final one included, is the core alone.
+later checkpoint is the core alone.
+
+**Arms fitted on the final core.** The final checkpoint opens bare and
+lists the arms fitted on it afterwards, with the core frozen:
+
+- **Arm sets** — one 13.7M arm per curriculum stage, on together (stages
+  1–4, stages 1–8, and an experimental set adding an arm for image
+  captions; two seeds each, plus research sets). A box per arm switches
+  any subset off; a switched-off arm removes exactly its own write.
+- **Solo arms** — each stage's arm trained alone, two seeds.
+- **The lookup arm** — ordinary softmax attention after blocks 2, 6, 12
+  and 20, born at zero, so off is the core bit for bit. It fetches a
+  value planted far back in a long text, where the core alone forgets it
+  within a few hundred bytes. Every version is listed, with recall
+  prompts in the Completion tab to run with the arm on and with *Core
+  only*.
 
 **Take it home — mini-beatrix-3.** The final weights, as
 [mini-beatrix-3](https://huggingface.co/AbstractPhil/mini-beatrix-3):
@@ -73,6 +89,13 @@ m.mount_arm("pair"); m.say("...")     # an arm — detach_arm() puts it back
 The library served here is the wider surface, refuted and control rows
 included; the package is the settled subset.
 
+**The 2s control twins** — 2s's recipe and data with softmax attention
+in all 20 blocks: the original twin (it destabilized under the recipe
+tuned for the splat and closed at 2.88 bits per byte against 2s's 1.11),
+two precision re-runs from its step 16,000 (stopped), and a re-run from
+its step 10,000 with fp32 attention around fp16 flash, stable and still
+training. No arms; decoded in fp32.
+
 **mini-beatrix-1** — 112.5M parameters, pretrained on 15.3 billion raw
 bytes, serving with a **library of detachable arms**: small aleph
 adapters (3.2M–5.3M parameters), each trained on one exact frozen core.

app.py

@@ -29,9 +29,20 @@ own config, its own byte format, and its own arm library:
                    148,000 and finished on the core alone, so the
                    checkpoints from 92,000 to 148,000 ship their arms and
                    the Space serves them together as a program
-                   (arm_mount "program": all live as trained, or any one
-                   switched off exactly), while every later checkpoint,
-                   the final one included, is the core alone.
+                   (arm_mount "program": all live as trained, or any
+                   subset switched off exactly), while every later
+                   checkpoint, the final one included, is the core alone.
+                   On the FINAL core (245,674) the arms fitted afterwards
+                   are listed too: the arm SETS (several arms trained
+                   switched on together; any subset can be switched on),
+                   the solo arms, and every version of the LOOKUP ARM (a
+                   zero-born softmax attention arm after blocks 2, 6, 12
+                   and 20; amoe.arms.lookup), its tensors read from each
+                   version's checkpoint by range request.
+  the 2s twins     257.6M · mini-beatrix-2s's recipe and data with softmax
+                   attention in every block where 2s has the splat hub:
+                   the original control twin and its re-runs from earlier
+                   weights. No arms; decoded in fp32.
 
 Crafts are discovered from the repo at boot: a craft with no manifest or
 no checkpoint is skipped, and one that starts shipping appears on its
@@ -128,10 +139,50 @@ GEN_BUDGET_S = 95.0
 # chat plus a 3.2M arm that makes it chat, removable bit-for-bit.
 # Listed newest first; if the default ever fails to load, the next one
 # down serves instead.
+# The 2s TWINS (`twin`): the pre-registered control of 2s — its recipe and
+# data with softmax attention in all 20 blocks where 2s has the splat hub —
+# and its re-runs from earlier weights. No arms. Decoded in fp32 (`fp32`):
+# the re-runs trained their attention block in fp32 around fp16 flash, and
+# bf16 decoding would serve a coarser model than the one that trained.
+# `twin` carries (the short label for the craft title, the panel line).
 CRAFTS = [
     {"name": "mini-beatrix-3", "fmt": "specials", "wants_arms": True,
      "stage_arms": True, "fp32": True},
     {"name": "mini-beatrix-2s", "fmt": "specials", "wants_arms": True},
+    {"name": "mini-beatrix-2s-control-attn-fp16-r10k", "fmt": "specials",
+     "wants_arms": False, "fp32": True, "twin": (
+         "re-run from step 10,000, fp16 attention · still training",
+         "ℹ️ **the 2s twin, re-run and stable** — the twin re-run from its "
+         "step-10,000 weights with its attention block computed in fp32 "
+         "around fp16 flash attention, retracing 2s's curriculum. It has "
+         "stayed stable, and on each of the six stage-boundary texts reached "
+         "so far it reads fewer bits per byte than 2s (one run, one seed). "
+         "It is still training; the Space lists what had shipped when it "
+         "last started.")},
+    {"name": "mini-beatrix-2s-control", "fmt": "specials",
+     "wants_arms": False, "fp32": True, "twin": (
+         "the original control twin · training complete",
+         "ℹ️ **a control** — mini-beatrix-2s's recipe and data with softmax "
+         "attention in all 20 blocks where 2s has the splat hub. It ran the "
+         "whole mission in bf16, and under the recipe tuned for the splat "
+         "its training destabilized from step 17,600 (the gradient norm past "
+         "its clip on 813 of the last 824 logged steps); it closed at 2.88 "
+         "bits per byte on held-out text against 2s's 1.11. Steps 10,000 and "
+         "16,000 are the weights its re-runs started from.")},
+    {"name": "mini-beatrix-2s-control-attn-fp16", "fmt": "specials",
+     "wants_arms": False, "fp32": True, "twin": (
+         "re-run from step 16,000, fp16 attention · stopped",
+         "ℹ️ **a precision test** — the twin re-run from its step-16,000 "
+         "weights (before it destabilized) with its attention block computed "
+         "in fp32 around fp16 flash attention. Stopped at step 18,251, in "
+         "web-text pretraining.")},
+    {"name": "mini-beatrix-2s-control-bf16", "fmt": "specials",
+     "wants_arms": False, "fp32": True, "twin": (
+         "re-run from step 16,000, bf16 · stopped",
+         "ℹ️ **the precision test's control** — the twin re-run from its "
+         "step-16,000 weights with fresh optimizer states and the bf16 "
+         "attention it first ran with. Stopped at step 18,323, in web-text "
+         "pretraining.")},
     {"name": "mini-beatrix-1", "fmt": "v1tags", "wants_arms": True},
 ]
 DEFAULT_CRAFT = "mini-beatrix-3"    # the newest completed mission leads
@@ -255,7 +306,9 @@ EXHIBIT_STEP = {"mini-beatrix-1": 88508}
 # as a BEFORE/AFTER pair across the chat anneal — 57,607 continues
 # documents, 61,422 answers — and that contrast is the clearest thing
 # the run produced, so the earlier half stays one click away.
-ALWAYS_OFFER = {"mini-beatrix-2s": [57607]}
+ALWAYS_OFFER = {"mini-beatrix-2s": [57607],
+                # the weights the twin's re-runs started from
+                "mini-beatrix-2s-control": [10000, 16000]}
 # default arm for the craft's DEFAULT step only — scoped so it can never
 # displace another checkpoint's own chat arm. day1/poly is a BEHAVIOR arm
 # on a single-turn Q&A frame: Chat therefore sends one question at a time
@@ -352,8 +405,11 @@ def load_arm_index(files, craft):
 
 def _arm_files(arm):
     """The hub files one arm row mounts: its own checkpoint, or a stack's
-    or a stage program's members (neither has a file of its own)."""
+    or a stage program's members (neither has a file of its own), or the
+    checkpoint a lookup arm's tensors are read from."""
     m = arm.get("mount") or {}
+    if m.get("type") == "lookup":
+        return [m.get("arm_file") or m["source"]]
     return (list(m["members"]) if m.get("type") in ("stack", "program")
             else [arm["path"]])
 
@@ -384,7 +440,15 @@ STAGE_TEACHES = {
     "tryfail": "trying, checking, finding the error, fixing it",
     "mixed": "a review spiral over every earlier stage",
     "register": "definitions, and one fact said several ways",
+    "caption": "image captions in a labelled frame (tags, caption, short, "
+               "attributes, scene, photo, structure, medium, long, rating)",
 }
+# the member switch's labels (stage number, then what the stage is about)
+MEMBER_LABEL = {"perspective": "1 perspective", "concept": "2 concepts",
+                "rules": "3 rule chains", "arith": "4 arithmetic",
+                "causal": "5 cause and effect", "tryfail": "6 try-fail-revise",
+                "mixed": "7 mixed", "register": "8 register",
+                "caption": "9 captions"}
 # completion prompts in each stage's own training format, cut just before
 # the part the stage teaches
 STAGE_PROBES = {
@@ -415,6 +479,9 @@ STAGE_PROBES = {
     "register": [
         "Plainly: the rain filled the barrel by morning. Formally:",
         "The word 'fragile' means"],
+    "caption": [
+        "caption: a red bicycle leaning against a brick wall on a rainy "
+        "street\nshort:"],
 }
 # general text none of the stages is about: where every arm should be
 # quiet (the activity line after a reply shows whether it is)
@@ -444,11 +511,10 @@ def load_stage_programs(files, craft):
     """{step: [row, ...]} for a craft whose arms are co-trained stage arms.
 
     Every step with at least one arm file gets the PROGRAM row — all of
-    that step's arms live, the model as the run trained it. With two or
-    more arms it also gets, per arm, "only this one live" and "this one
-    switched off": the exact contrasts the per-arm switch exists for (a
-    switched-off arm passes its input through unchanged; nothing
-    renormalizes)."""
+    that step's arms live, the model as the run trained it. Which members
+    run is the member switch's choice (any subset; a switched-off arm
+    passes its input through unchanged and nothing renormalizes), so one
+    row per program replaces the old only-this / all-but-this rows."""
     members = {}
     for f in files:
         if not f.startswith(f"{craft}/arms/"):
@@ -463,25 +529,133 @@ def load_stage_programs(files, craft):
         names = [n for _, n, _ in ms]
         paths = [p for _, _, p in ms]
         words = ", ".join(_stage_word(n) for n in names)
-        rows = [_program_row(
+        by_step[step] = [_program_row(
             craft, step, names, paths, names, "",
-            f"Stage arms, all live as trained ({words})"
+            f"Stage arms trained with this core ({words})"
             if len(names) > 1 else
-            f"Stage arm {names[0]}, live as trained")]
-        if len(names) > 1:
-            for n in names:
-                rows.append(_program_row(
-                    craft, step, names, paths, [n], f"#only={n}",
-                    f"Only {n} live (the other {len(names) - 1} off)"))
-            for n in names:
-                rows.append(_program_row(
-                    craft, step, names, paths,
-                    [x for x in names if x != n], f"#without={n}",
-                    f"All live except {n}"))
-        by_step[step] = rows
+            f"Stage arm {names[0]}, trained with this core")]
     return by_step
 
 
+# ------------------------------------------- arms fitted on the final core
+# After the mission, arms were fitted on mini-beatrix-3's FINAL core with
+# the core frozen: arm SETS (several arms trained switched on together;
+# mounted as a program, any subset switchable), SOLO arms (one at a time)
+# and the LOOKUP ARM (zero-born softmax attention after chosen blocks). The
+# sets and solos come from arms_catalog.json (built from the training
+# results by mb25/build_v3_space_catalog.py); the lookup arm's versions are
+# found in the repo listing at boot, so a version that ships later appears
+# after a restart with nothing rebuilt.
+LOOKUP_RE = re.compile(r"^(mini-beatrix-3-la[\w.-]*)/checkpoints/"
+                       r"step_(\d+)\.safetensors$")
+LOOKUP_CACHE = os.environ.get("BEATRIX_LOOKUP_CACHE", "/tmp/beatrix-lookup")
+
+
+def load_lookup_rows(files, craft, core_step, core_cfg):
+    """One row per checkpoint of every lookup-arm craft whose manifest
+    chain (init_from, step by step) starts from THIS craft's core at
+    core_step and whose trunk config equals the core's (the arm trained
+    with the trunk frozen, so every version mounts on that one core). The
+    row mounts only the arm: its tensors are read from the checkpoint by
+    range request (or from an arm-only file when one shipped)."""
+    spec = (CATALOG.get(craft) or {}).get("lookup") or {}
+    found = {}
+    for f in files:
+        m = LOOKUP_RE.match(f)
+        if m:
+            found.setdefault(m.group(1), []).append(int(m.group(2)))
+    mans = {}
+    for lc in found:
+        try:
+            mans[lc] = json.load(open(hf_hub_download(
+                REPO, f"{lc}/manifest.json"), encoding="utf-8"))
+        except Exception as e:
+            print(f"[boot] lookup arm {lc}: manifest unreadable "
+                  f"({type(e).__name__}) — not offered", flush=True)
+
+    def root(lc, seen=()):
+        src = ((mans.get(lc) or {}).get("init_from") or {}).get("source", "")
+        m = re.search(r"([^/]+)/checkpoints/step_(\d+)\.safetensors$", src)
+        if not m:
+            return None
+        parent, st = m.group(1), int(m.group(2))
+        if parent == craft:
+            return st
+        if parent in seen or parent not in mans:
+            return None
+        return root(parent, seen + (lc,))
+
+    rows = []
+    for lc, steps in sorted(found.items()):
+        man = mans.get(lc)
+        if not man:
+            continue
+        mc = man.get("model_config") or {}
+        trunk_ok = all(mc.get(k) == v for k, v in core_cfg.items()
+                       if k != "name")
+        if root(lc) != core_step or not trunk_ok or not mc.get(
+                "lookup_arm_sites"):
+            print(f"[boot] lookup arm {lc}: not chained to {craft} @"
+                  f"{core_step:,} with the same trunk — not offered",
+                  flush=True)
+            continue
+        sites = [int(s) for s in mc["lookup_arm_sites"]]
+        depth = int(mc.get("lookup_arm_depth") or 1)
+        d = int(mc["d_model"])
+        per_layer = 4 * d * d + 4 * d   # qkv + o (4d²), the q/k gains (2d), the norm (2d)
+        info = (spec.get("crafts") or {}).get(lc) or {}
+        reads = (spec.get("reads") or {}).get(lc) or {}
+        tail = lc[len(craft) + 1:]
+        arm_only = {}
+        for f in files:
+            m = re.match(rf"^{re.escape(lc)}/lookup_arm/lookup_arm_step_"
+                         rf"(\d+)\.safetensors$", f)
+            if m:
+                arm_only[int(m.group(1))] = f
+        for st in sorted(steps, reverse=True):
+            rd = reads.get(str(st)) or {}
+            fetch = rd.get("fetch_2048")
+            path = f"{lc}/checkpoints/step_{st:08d}.safetensors"
+            rows.append({
+                "path": path, "step": core_step, "name": f"{tail}@{st}",
+                "group": "lookup arm", "kind": "lookup", "family": "lookup",
+                "title": (f"Lookup arm · {info.get('short', tail)} · step "
+                          f"{st:,} · "
+                          + (f"fetch from 2,048 bytes back {fetch:.2f}"
+                             if fetch is not None else "not read yet")
+                          + (f" · {depth} layers a site" if depth > 1 else "")),
+                "what": info.get("what") or tail,
+                "lookup_craft": lc, "lookup_step": st, "reads": rd,
+                "sites": sites, "depth": depth,
+                "params": depth * len(sites) * per_layer,
+                "mount": {"type": "lookup", "source": path,
+                          "arm_file": arm_only.get(st),
+                          "name": f"{tail}@{st}"},
+                "template": None,
+                "decode": {"temperature": 0.0, "top_p": 1.0, "rep": 1.0,
+                           "precision": "fp32",
+                           "why": "the arm's reads are greedy"},
+                # after the packaged sets; newest craft first, newest step
+                "rank": 3.5 + 0.01 * info.get("order", 9) + 1e-9 * (
+                    10 ** 7 - st)})
+    return rows
+
+
+def load_final_core_rows(files, craft, core_step, core_cfg):
+    """The catalog's rows for the final core (sets and solos, each listed
+    only when every file it mounts is on the hub) and the lookup rows."""
+    present = set(files)
+    rows = [dict(r) for r in ((CATALOG.get(craft) or {}).get("rows") or [])
+            if int(r.get("step", -1)) == core_step]
+    kept = [r for r in rows if all(p in present for p in _arm_files(r))]
+    if len(kept) < len(rows):
+        print(f"[boot] {craft}: {len(rows) - len(kept)} catalog arm(s) have no "
+              "file on the hub — not offered", flush=True)
+    kept += load_lookup_rows(files, craft, core_step, core_cfg)
+    kept.sort(key=lambda r: (r.get("rank", 99), r.get("title", "")))
+    return kept
+
+
 def load_reports(files, craft):
     """{step: report} for every stage-close report the run has shipped
     (<craft>/reports/v3/<phase>_step<N>.json). A stage close is where the
@@ -579,6 +753,30 @@ def _mount(c, arm, step):
     the handle, or None when any file fails provenance. Adapter geometry
     is read from each file's own tensors (the library holds more than one
     shape), so nothing is assumed from a default spec."""
+    m = arm.get("mount") or {}
+    if m.get("type") == "lookup":
+        # provenance was settled at boot (the version's manifest chain from
+        # this exact core, the same trunk config) and _resolve_arm pins the
+        # row to the core's step; only the arm's own tensors are fetched
+        t0 = time.time()
+        try:
+            f = (hf_hub_download(REPO, m["arm_file"]) if m.get("arm_file")
+                 else arm_mount.fetch_lookup_tensors(REPO, m["source"],
+                                                     LOOKUP_CACHE))
+        except Exception as e:
+            print(f"[arms] refusing lookup arm {arm['name']}: its tensors "
+                  f"could not be read ({type(e).__name__}: {str(e)[:200]})",
+                  flush=True)
+            return None
+        print(f"[arms] {c.name} @{int(step):,}: lookup arm {arm['name']} ready "
+              f"({os.path.getsize(f) / 1e6:.1f} MB, {time.time() - t0:.1f}s)",
+              flush=True)
+        h = arm_mount.mount(c.model, {"type": "lookup", "name": arm["name"]}, f)
+        print(f"[arms] {c.name} @{int(step):,}: lookup arm {arm['name']} "
+              f"mounted (blocks {', '.join(map(str, h.sites))}, "
+              f"{h.spec.depth} layer{'s' if h.spec.depth > 1 else ''} a site, "
+              f"{h.n_params() / 1e6:.1f}M)", flush=True)
+        return h
     local = []
     for p in _arm_files(arm):
         t0 = time.time()
@@ -695,12 +893,29 @@ class Craft:
                                   if ph.get("status") == "active"), None)
         self.stage_arms = bool(spec.get("stage_arms"))
         self.fp32 = bool(spec.get("fp32"))
+        self.twin = spec.get("twin")        # (title label, panel line) or None
         self.reports = (load_reports(files, self.name) if self.stage_arms
                         else {})
         self.arms = (load_stage_programs(files, self.name)
                      if self.stage_arms else
                      load_arm_index(files, self.name) if spec["wants_arms"]
                      else {})
+        # the run's own stage programs end at step 148,000; the arms fitted
+        # afterwards on the FINAL core join that step's list (and only it)
+        self.mission_steps = set(self.arms) if self.stage_arms else set()
+        self.final_rows = 0
+        if self.stage_arms:
+            final = max(self.cores)
+            extra = load_final_core_rows(files, self.name, final,
+                                         dict(manifest["model_config"]))
+            self.arms.setdefault(final, []).extend(extra)
+            self.final_rows = len(extra)
+            if extra:
+                print(f"[boot] {self.name} @{final:,}: "
+                      f"{sum(r['kind'] == 'arm-set' for r in extra)} arm sets, "
+                      f"{sum(r['kind'] == 'solo' for r in extra)} solo arms, "
+                      f"{sum(r['kind'] == 'lookup' for r in extra)} lookup arm "
+                      "versions fitted on the final core", flush=True)
         self._chat_ok = {                      # per CHECKPOINT, not craft
             s: bool(self.frame_trained and self._chat_from is not None
                     and int(m.get("tokens") or 0) > self._chat_from)
@@ -714,8 +929,8 @@ class Craft:
         # (the run detached them there and finished on the core alone):
         # the last step that ships arms, so later cores are labelled as
         # the core alone rather than as "before the stage arms"
-        self.arm_last = (max(self.arms) if self.stage_arms and self.arms
-                         else None)
+        self.arm_last = (max(self.mission_steps)
+                         if self.stage_arms and self.mission_steps else None)
         self.arm_by_path = {a["path"]: a
                             for arms in self.arms.values() for a in arms}
 
@@ -807,10 +1022,12 @@ class Craft:
         step = int(step)
         arms = self.arms.get(step, [])
         if self.stage_arms:
-            # the run's own model at this checkpoint is the core WITH its
-            # stage arms (they trained together), so every one opens live
+            # the run's own model at an armed checkpoint is the core WITH its
+            # stage arms (they trained together), so they open live; the
+            # final core was released bare, and the arms fitted on it
+            # afterwards are listed, not opened
             for a in arms:
-                if a.get("live") == a.get("members"):
+                if a.get("kind") == "stage-program":
                     return a["path"]
             return CORE_ONLY
         if step == getattr(self, "step", None):
@@ -869,11 +1086,16 @@ class Craft:
                         else "pre-chat (documents only)")
         n_chat = sum(a["kind"] == "chat" for a in arms)
         if self.stage_arms:
-            names = arms[0]["members"] if arms else []
+            prog = [a for a in arms if a.get("kind") == "stage-program"]
+            names = prog[0]["members"] if prog else []
+            extra = len(arms) - len(prog)
             if step in self.reports:
                 bits.append(f"close of {self.reports[step].get('tag')}")
             bits.append(("stage arms: " + ", ".join(
                 _stage_word(n) for n in names)) if names
+                        else "arm sets, solo arms and the lookup arm "
+                             "fitted on it afterwards"
+                        if extra
                         else "core alone (arms detached)"
                         if self.arm_last and step > self.arm_last
                         else "before the stage arms")
@@ -893,13 +1115,18 @@ class Craft:
         arms = (f"{len(self.arm_by_path)} arms" if self.arm_by_path
                 else "no arms yet")
         if self.stage_arms:
-            newest = self.arms.get(max(self.arms), []) if self.arms else []
-            k = len(newest[0]["members"]) if newest else 0
+            last = self.arms.get(self.arm_last, []) if self.arm_last else []
+            k = len(last[0]["members"]) if last else 0
             arms = ("no stage arms yet" if not k else
                     f"{k} stage arm{'s' if k != 1 else ''} trained with it"
                     if self.arm_last >= max(self.cores) else
                     f"{k} stage arm{'s' if k != 1 else ''} to step "
                     f"{self.arm_last:,}")
+            if self.final_rows:
+                arms += " · arm sets and the lookup arm on the final core"
+        if self.twin:
+            return (f"{self.name} · {n} · softmax twin of 2s · "
+                    f"{self.twin[0]}")
         if self.fmt == "specials":
             state = ("in training" if self.active_phase
                      else "training complete")
@@ -957,9 +1184,27 @@ def _resolve_arm(c, arm_path, step):
     return arm if (arm and arm["step"] == int(step)) else None
 
 
-def _select(craft, step, arm_path):
+def _live_set(arm, live):
+    """Which members of a program row run: the member switch's choice
+    (a list; an empty list switches every member off) or, when the caller
+    sent none, the row's own default (every member on)."""
+    members = list(arm.get("members") or [])
+    if live is None:
+        return list(arm.get("live") or members)
+    want = set(live)
+    # a non-empty choice naming none of this row's members is left over
+    # from another row (a send that raced the switch's refresh): it gets
+    # the row's default, never "all off" by accident. An EMPTY choice is
+    # the visitor unticking every box and means exactly that.
+    if want and not want & set(members):
+        return list(arm.get("live") or members)
+    return [n for n in members if n in want]
+
+
+def _select(craft, step, arm_path, live=None):
     """Make the live model BE (craft, step, arm). arm_path is "" for
-    core-only. Runs inside the ZeroGPU worker, where each call starts
+    core-only; `live` is the member switch's choice for a program row.
+    Runs inside the ZeroGPU worker, where each call starts
     from the parent's packed state, so a non-default selection re-applies
     per request (weights come from the local hub cache — no
     re-download). Returns a provenance dict."""
@@ -1001,36 +1246,115 @@ def _select(craft, step, arm_path):
         c.handle = _mount(c, arm, step)       # provenance, every switch
         if c.handle is not None:
             c.loaded["mount"] = want_mount
+    on = None
     if arm is not None and c.handle is not None:
-        if arm.get("live") is not None:       # a stage program row
-            c.handle.set_live(arm["live"])
-        if arm.get("live") is not None and c.loaded["arm_path"] != want:
-            print(f"[arms] {c.name} @{step:,}: on "
-                  + (", ".join(arm["live"]) or "none")
-                  + (f" · off {', '.join(n for n in arm['members'] if n not in arm['live'])}"
-                     if len(arm["live"]) < len(arm["members"]) else ""),
-                  flush=True)
+        if arm.get("members"):                # a program row: the switch
+            on = _live_set(arm, live)
+            c.handle.set_live(on)
+            if (c.loaded["arm_path"] != want
+                    or c.loaded.get("live") != on):
+                print(f"[arms] {c.name} @{step:,}: on "
+                      + (", ".join(on) or "none")
+                      + (f" · off {', '.join(n for n in arm['members'] if n not in on)}"
+                         if len(on) < len(arm["members"]) else ""),
+                      flush=True)
         c.loaded["arm_path"] = want           # commit only now
+        c.loaded["live"] = on
     arm_on = arm is not None and c.handle is not None
     fp32 = c.fp32 or (arm_on and (arm.get("decode") or {}).get("precision")
                       == "fp32")
     prov = {"craft": c.name, "checkpoint_step": step,
-            "arm": (want.split("/")[-1] if arm_on else None),
+            "arm": ((arm.get("name") if arm.get("kind") in ("lookup", "arm-set")
+                     else want.split("/")[-1]) if arm_on else None),
             "arm_kind": (arm["kind"] if arm_on else "core-only"),
             "precision": "fp32" if fp32 else "bf16",
             "switch_s": round(time.time() - t0, 2)}
-    if arm_on and arm.get("live") is not None:
-        prov["live_arms"] = list(arm["live"])
+    if arm_on and on is not None:
+        prov["live_arms"] = list(on)
         prov["stage_arms"] = list(arm["members"])
+    if arm_on and arm.get("kind") == "lookup":
+        prov["lookup_sites"] = list(arm["sites"])
+        prov["lookup_version"] = f"{arm['lookup_craft']}@{arm['lookup_step']}"
     return prov
 
 
-def _program_line(c, step, arm):
+def _f3(x):
+    s = f"{x:.3f}"
+    return s[1:] if s.startswith("0.") else s
+
+
+def _set_line(arm, live):
+    """An arm set fitted on the final core: which members run, what the set
+    is, and what was measured for it (each member's own stage text with
+    every arm off, with the whole set on, and with that member alone; the
+    set's cost on held-out web text)."""
+    on = set(live)
+    reads = arm.get("reads") or {}
+    mem = " · ".join(f"`{_stage_word(n)}` {'✓' if n in on else '✗'}"
+                     for n in arm["members"])
+    meas = " · ".join(
+        f"{_stage_word(n)} {_f3(r['off'])}→{_f3(r['on'])}"
+        + (f" (alone {_f3(r['alone'])})" if r.get("alone") is not None else "")
+        for n, r in reads.items() if r.get("off") is not None
+        and r.get("on") is not None)
+    return "  \n".join(filter(None, [
+        f"**Arm set** · {arm['name']} · {len(arm['members'])} arms, "
+        f"{arm['params'] / 1e6:.1f}M · {arm.get('status', '')} · fitted on "
+        f"THIS core with the core frozen — " + mem,
+        arm.get("what", ""),
+        ("Measured, each arm's own stage text in bits per byte, every arm "
+         "off → the set on (that arm alone): " + meas
+         + (f" · held-out web text with the set on {arm['web']:+.4f}"
+            if arm.get("web") is not None else "")) if meas else "",
+        "Tick and untick arms below to run any subset: a switched-off arm "
+        "removes exactly its own write, nothing renormalizes. Decoded greedy "
+        "in fp32 as measured; the Completion tab has prompts in each stage's "
+        "own format."]))
+
+
+def _solo_line(arm):
+    return "  \n".join(filter(None, [
+        f"**Solo arm** · {arm['title'].split(' · ', 1)[1]} · "
+        f"{arm['params'] / 1e6:.1f}M · {arm.get('status', '')}",
+        arm.get("what", ""),
+        f"Measured: {arm['score']} (bits per byte)" if arm.get("score") else "",
+        "Decoded greedy in fp32 as measured; the Completion tab has prompts "
+        "in its stage's own format."]))
+
+
+def _lookup_line(c, arm):
+    rd = arm.get("reads") or {}
+    bare = ((CATALOG.get(c.name) or {}).get("lookup") or {}).get("bare") or {}
+    fet = " · ".join(f"{k.split('_')[1]} bytes back {rd[k]:.2f}"
+                     for k in ("fetch_1024", "fetch_2048", "fetch_3072",
+                               "fetch_3400") if rd.get(k) is not None)
+    return "  \n".join(filter(None, [
+        f"**Lookup arm** · version `{arm['lookup_craft']}` step "
+        f"{arm['lookup_step']:,} · softmax attention after blocks "
+        + ", ".join(map(str, arm["sites"]))
+        + (f", {arm['depth']} layers a site" if arm.get("depth", 1) > 1 else "")
+        + f" · {arm['params'] / 1e6:.1f}M · born at zero and trained with THIS "
+        "core frozen, so switching it off gives the core back bit for bit",
+        "This version: " + arm.get("what", ""),
+        ("Measured, the planted value's first byte fetched from: " + fet
+         + (f" (the core alone: {bare.get('fetch_1024', 0):.2f} / "
+            f"{bare.get('fetch_2048', 0):.2f} at 1,024 / 2,048)" if bare else ""))
+        if fet else "Not read yet.",
+        "Its write is concentrated where a question asks for a value planted "
+        "earlier. Try the recall prompts in the Completion tab with the arm "
+        "on and with Core only. Decoded greedy in fp32; after a run the "
+        "activity line shows how far the whole arm, and each site alone, "
+        "moved the predictions on that text."]))
+
+
+def _program_line(c, step, arm, live=None):
     """A stage program as it runs on this checkpoint: every member on or
     off (what each stage teaches, while there are few enough to fit), and,
     when this checkpoint is a stage close, the cost the trainer measured
     for each arm on general text."""
-    live = set(arm["live"])
+    if arm.get("kind") == "arm-set":
+        return _set_line(arm, _live_set(arm, live))
+    live = set(_live_set(arm, live))
     few = len(arm["members"]) <= 2
     mem = " · ".join(
         f"`{n}` {'✓ on' if n in live else '✗ off'}"
@@ -1048,17 +1372,20 @@ def _program_line(c, step, arm):
         lines.append("Measured by the trainer at this stage close, each "
                      "arm's cost on held-out web text (bits per byte, on "
                      "minus off; its bar is +0.012): " + " · ".join(cost))
-    lines.append("Switching an arm off removes exactly its write; the core "
-                 "and the other arms are untouched. Decoded in fp32. After "
-                 "each run the stats line shows how far each live arm moved "
-                 "the predictions on that text.")
+    lines.append("Tick and untick arms below to run any subset: switching an "
+                 "arm off removes exactly its write; the core and the other "
+                 "arms are untouched. Decoded in fp32. After each run the "
+                 "stats line shows how far each live arm moved the "
+                 "predictions on that text.")
     return "  \n".join(lines)
 
 
-def status_md(craft, step, arm_path=CORE_ONLY):
+def status_md(craft, step, arm_path=CORE_ONLY, live=None):
     c = S(craft)
     step = _step(c, step)
     arms = c.arms.get(step, [])
+    prog = [a for a in arms if a.get("kind") == "stage-program"]
+    extra = [a for a in arms if a.get("kind") in ("arm-set", "solo", "lookup")]
     meta = c.ckpt_meta.get(step, {})
     newest = max(c.cores)
     arm = _resolve_arm(c, arm_path, step)
@@ -1071,12 +1398,23 @@ def status_md(craft, step, arm_path=CORE_ONLY):
                     "They live on bytes UTF-8 can never produce, so "
                     "nothing you type can forge them."
                     + (f"  \n**Arms** all switched off — the raw core "
-                       f"({len(arms[0]['members'])} stage arm"
-                       f"{'s' if len(arms[0]['members']) != 1 else ''} "
+                       f"({len(prog[0]['members'])} stage arm"
+                       f"{'s' if len(prog[0]['members']) != 1 else ''} "
                        "trained with it here)"
-                       if c.stage_arms and arms else ""))
-    elif arm and arm.get("live") is not None:
-        arm_line = _program_line(c, step, arm)
+                       if c.stage_arms and prog else "")
+                    + (f"  \n**Arms** none attached — the final core alone. "
+                       f"Fitted on it afterwards and listed under *Arm*: "
+                       f"{sum(a['kind'] == 'arm-set' for a in extra)} arm "
+                       f"sets, {sum(a['kind'] == 'solo' for a in extra)} solo "
+                       f"arms, {sum(a['kind'] == 'lookup' for a in extra)} "
+                       "versions of the lookup arm"
+                       if c.stage_arms and extra else ""))
+    elif arm and arm.get("members"):
+        arm_line = _program_line(c, step, arm, live)
+    elif arm and arm.get("kind") == "solo":
+        arm_line = _solo_line(arm)
+    elif arm and arm.get("kind") == "lookup":
+        arm_line = _lookup_line(c, arm)
     elif arm:
         sp = arm.get("spec") or {}
         t = _tmpl(arm)
@@ -1116,6 +1454,8 @@ def status_md(craft, step, arm_path=CORE_ONLY):
         + f" · {c.core_params/1e6:.1f}M core · ctx {c.cfg.context}"
         + (f" · newest is {newest:,}" if step != newest else ""),
         arm_line,
+        # a 2s twin says what it is (a control, which re-run, its state)
+        (c.twin[1] if c.twin else ""),
         # which side of the chat anneal THIS core sits on — the mission
         # ends in a before/after pair and they are not interchangeable
         (f"**Phase:** `{c.phase_of(step)}` · "
@@ -1126,15 +1466,20 @@ def status_md(craft, step, arm_path=CORE_ONLY):
          if c.fmt == "specials" and c.phase_of(step) else ""),
         # a craft still in pretraining has never seen its chat frame:
         # say so rather than letting the Chat tab imply otherwise
-        ("⚠️ this craft is **still pretraining** (phase "
-         f"`{c.active_phase}`, {c.tokens_seen/1e9:.2f}B bytes) and has not "
-         "reached the anneal that teaches its conversation frame — Chat "
-         "will read as off-distribution. **Completion** is the honest "
-         "view of what she can do today."
-         + (f" Checkpoints and progress were read when this Space started"
-            f", from a manifest written {c.updated_utc}; the run has moved "
-            "on since, and a restart picks up what it shipped."
-            if c.updated_utc else "")
+        (("⚠️ this run **stopped before** the anneal that teaches the "
+          f"conversation frame (it ended in phase `{c.active_phase}`, "
+          f"{c.tokens_seen/1e9:.2f}B bytes) — Chat will read as "
+          "off-distribution. **Completion** is the honest view."
+          if c.twin and "stopped" in c.twin[0] else
+          "⚠️ this craft is **still training** (phase "
+          f"`{c.active_phase}`, {c.tokens_seen/1e9:.2f}B bytes) and has not "
+          "reached the anneal that teaches its conversation frame — Chat "
+          "will read as off-distribution. **Completion** is the honest "
+          "view of what she can do today."
+          + (f" Checkpoints and progress were read when this Space started"
+             f", from a manifest written {c.updated_utc}; the run has moved "
+             "on since, and a restart picks up what it shipped."
+             if c.updated_utc else ""))
          if c.fmt == "specials" and not c.frame_trained else ""),
         # the craft finished its chat anneal but THIS checkpoint predates
         # it: the pre-chat baseline continues documents rather than
@@ -1151,7 +1496,12 @@ def status_md(craft, step, arm_path=CORE_ONLY):
         # mini-beatrix-3 after its arms were detached (step 148,000): say
         # why the arm picker holds only the core here (one short line: the
         # panel sits above the tabs)
-        (f"ℹ️ the core alone: its stage arms were detached at step "
+        (f"ℹ️ the run's own stage arms were detached at step "
+         f"{c.arm_last:,} (pick {c.arm_last:,} or an earlier stage close to "
+         "run them); the arms in the list here were fitted on this final "
+         "core afterwards, with the core frozen."
+         if c.stage_arms and c.arm_last and step > c.arm_last and extra else
+         f"ℹ️ the core alone: its stage arms were detached at step "
          f"{c.arm_last:,}. Pick {c.arm_last:,} or an earlier stage close "
          "to run them."
          if c.stage_arms and c.arm_last and step > c.arm_last else ""),
@@ -1192,10 +1542,10 @@ def status_md(craft, step, arm_path=CORE_ONLY):
         ("ℹ️ no arm has been trained on this lineage yet — and none is "
          "needed to talk to it: the conversation frame was taught to the "
          "core itself, in the anneal that closed its mission."
-         if not c.arm_by_path and c.chats(step) else ""),
+         if not c.arm_by_path and c.chats(step) and not c.twin else ""),
         ("ℹ️ no arm has been trained on this lineage yet — every reply "
          "here is the raw pretrained core."
-         if not c.arm_by_path and not c.chats(step) else ""),
+         if not c.arm_by_path and not c.chats(step) and not c.twin else ""),
     ]))
 
 
@@ -1232,13 +1582,17 @@ def _examples_of(arm):
 
 
 def _probe_prompts(arm):
-    """Completion prompts for a stage program: each member stage's own
-    training format, then general text where every arm should stay quiet.
-    None for any other row (the prompt list is then hidden)."""
-    if not arm or arm.get("live") is None:
+    """Completion prompts for a stage program or arm set (each member
+    stage's own training format) or a solo arm (its stage's), then general
+    text where every arm should stay quiet. None for any other row (the
+    prompt list is then hidden)."""
+    if not arm:
+        return None
+    words = ([_stage_word(n) for n in arm["members"]] if arm.get("members")
+             else [arm["probe_stage"]] if arm.get("probe_stage") else None)
+    if not words:
         return None
-    out = [p for n in arm["members"]
-           for p in STAGE_PROBES.get(_stage_word(n), [])]
+    out = [p for w in words for p in STAGE_PROBES.get(w, [])]
     return [[p] for p in out + OFF_STAGE_PROBES]
 
 
@@ -1248,6 +1602,161 @@ def _probe_update(arm, fam_examples):
             if probes and fam_examples else gr.update(visible=False))
 
 
+# Recall prompts for the lookup arm, in its training phrasing (the deep
+# renderer's single record, updated record and lockers): a value planted
+# after the first sentences, ordinary text, then the record's sentence
+# again, cut just before the value. The filler is plain prose written for
+# this page. Greedy decoding: the next bytes should be the planted value.
+_FILL = (
+    "The ferry left the north landing a little after seven, as it did on "
+    "most mornings in the dry season. The river was low and brown, and the "
+    "pilot kept to the deep channel near the eastern bank, where the water "
+    "moved faster and the sandbars could not reach. On the deck a few "
+    "traders sat beside their baskets of onions and dried fish, and a boy "
+    "sold tea from a dented kettle balanced on a charcoal stove. Nobody "
+    "spoke much in the first hour. The light came up slowly behind the "
+    "hills, turning the haze from grey to a pale gold, and the birds that "
+    "lived in the reeds rose in loose flocks as the boat passed. At the "
+    "bend below the old mill the pilot sounded the horn twice, the signal "
+    "for the farms on the far side that the ferry would stop on its way "
+    "back. The mill itself had not turned in years. Its wheel was rusted "
+    "in place and a fig tree grew from the roof of the grinding room, its "
+    "roots working down through the cracked plaster toward the water. "
+    "Some of the older passengers remembered when the mill had ground "
+    "wheat for three villages, and they talked about the long lines of "
+    "carts that used to wait on the road in the harvest weeks. The traders "
+    "were more interested in the price of diesel, which had risen again, "
+    "and in whether the new bridge upstream would ever be finished. "
+    "Everyone had an opinion about the bridge. It had been promised for "
+    "twelve years, and twice the pylons had been started and then left to "
+    "stand in the current like the legs of some patient wading bird. By "
+    "the middle of the morning the wind had changed. It came from the "
+    "south now, warm and smelling of cut grass, and it raised small waves "
+    "that slapped against the hull. The pilot slowed the engine and let "
+    "the boat drift for a while past the island where the fishermen kept "
+    "their huts. Smoke rose from one of the chimneys, and a dog ran along "
+    "the shore barking until the ferry was out of sight. The boy with the "
+    "kettle had sold all his tea and sat on an upturned crate counting his "
+    "coins into neat stacks. The market town came into view a little "
+    "before noon. Its waterfront was crowded with boats of every size, "
+    "from narrow canoes to the steel barges that carried gravel down from "
+    "the quarries, and the ferry had to wait its turn to reach the stone "
+    "steps of the landing. While it waited, the passengers gathered their "
+    "things and argued gently about who would get off first. The steps "
+    "were wet and slippery, worn smooth by a century of feet, and a man in "
+    "a blue cap stood at the top to help people up with their loads. "
+    "Beyond the landing the market spread across a wide square shaded by "
+    "plane trees. There were stalls for cloth and stalls for tools, a row "
+    "of women selling herbs and seeds from small paper packets, and at the "
+    "far end a covered hall where the butchers worked. The noise was "
+    "constant and cheerful. Prices were called out, refused, called again, "
+    "and finally agreed with a handshake or a shrug. A radio somewhere "
+    "played the same song three times in an hour. In the afternoon the "
+    "heat settled over the square and the trading slowed. Stallholders "
+    "dozed under their awnings, and the cats that lived around the "
+    "butchers' hall stretched out on the cool stones by the fountain. Only "
+    "the children kept moving, chasing each other between the tables and "
+    "through the narrow lanes that led away from the square toward the "
+    "older houses on the hill. The ferry would not leave again until four. "
+    "Its crew ate lunch on the deck, bread and cheese and a few late "
+    "plums, and talked about the season, the river and the bridge.")
+
+
+def _sentences(text, n):
+    """The leading whole sentences of `text` that fit in n bytes."""
+    body = text[:max(0, n)]
+    return body[:body.rindex(". ") + 2] if ". " in body else body
+
+
+def _recall(plant, ask, gap, later=None):
+    """~220 bytes of prose, the plant, about `gap` bytes of prose, the
+    question. `later` (a second sentence of the record) goes in a third
+    of the way through the gap: the updated-record form."""
+    head = _sentences(_FILL, _FILL.index(". ", 200) + 2)
+    rest = _FILL[len(head):]
+    body = _sentences(rest, gap - len(plant))
+    if later:
+        first = _sentences(body, len(body) // 3)
+        body = first + later + body[len(first):]
+    return head + plant + body + ask
+
+
+def _back(text, value):
+    """How far back the answer sits: bytes from the value's (last) plant
+    to the end of the prompt, where the reply begins."""
+    b = text.encode()
+    return len(b) - b.rindex(value.encode())
+
+
+def _recall_rows():
+    rows = []
+    for cue, value, gap in (("code", "48213", 450), ("word", "quilmet", 1050),
+                            ("number", "7395021", 2100),
+                            ("token", "vandrel", 3100)):
+        t = _recall(f"The secret {cue} is {value}. ",
+                    f"The secret {cue} is ", gap)
+        rows.append((f"the secret {cue}, planted {_back(t, value):,} bytes "
+                     f"back (the answer: {value})", t))
+    t = _recall("The secret key is 3fa91c. ", "The secret key is ", 1600,
+                later="The secret key is now 82d04e. ")
+    rows.append(("an updated key: the first value, then a later one "
+                 f"{_back(t, '82d04e'):,} bytes back (the answer: the later "
+                 "value, 82d04e)", t))
+    t = _recall("Locker 4821 holds code 55370. Locker 3109 holds code 90412. "
+                "Locker 7744 holds code 21865. Locker 1296 holds code 67093. ",
+                "Locker 3109 holds code ", 900)
+    rows.append(("four lockers, the asked one planted "
+                 f"{_back(t, '90412'):,} bytes back (the answer: 90412; "
+                 "telling keys apart is still open: the one-layer arm reads "
+                 "near chance here)", t))
+    return rows
+
+
+RECALL_PROBES = _recall_rows()
+
+
+def _recall_update(arm):
+    if arm and arm.get("kind") == "lookup":
+        return gr.update(choices=[lab for lab, _ in RECALL_PROBES], value=None,
+                         visible=True)
+    return gr.update(visible=False, value=None)
+
+
+def on_recall(label):
+    """Writes the chosen recall prompt into the Completion prompt box."""
+    for lab, text in RECALL_PROBES:
+        if lab == label:
+            return text
+    return gr.update()
+
+
+def _members_update(arm, live=None):
+    """The member switch: shown for a program row (a stage program or an
+    arm set), one box per member, every box ticked when the row is picked."""
+    if not arm or not arm.get("members"):
+        return gr.update(choices=[], value=[], visible=False)
+    return gr.update(
+        choices=_member_choices(arm), value=_live_set(arm, live),
+        label=_member_label(arm), visible=True)
+
+
+def _member_choices(arm):
+    return [(MEMBER_LABEL.get(_stage_word(n), _stage_word(n)), n)
+            for n in (arm or {}).get("members") or []]
+
+
+def _member_label(arm):
+    return ("Arms in this set · untick any arm to switch it off"
+            if (arm or {}).get("kind") == "arm-set" else
+            "Stage arms trained with this core · untick any arm to switch "
+            "it off")
+
+
+def on_members(craft, step, arm_path, live):
+    """Ticking or unticking a member re-renders the panel's member line."""
+    return status_md(craft, step, arm_path, live)
+
+
 def on_arm(craft, step, arm_path, auto_decode, fam_examples):
     """Selecting an arm re-tunes what the arm needs and shows what it
     knows: a task arm collapses to turn-end off-distribution and turns
@@ -1263,7 +1772,9 @@ def on_arm(craft, step, arm_path, auto_decode, fam_examples):
             gr.update(value=r) if auto_decode else gr.update(),
             gr.update(samples=_examples_of(arm)) if fam_examples
             else gr.update(),
-            _probe_update(arm, fam_examples))
+            _probe_update(arm, fam_examples),
+            _members_update(arm),
+            _recall_update(arm))
 
 
 def on_checkpoint(craft, step, auto_decode, fam_examples):
@@ -1394,6 +1905,11 @@ def _rep_penalty(logits, produced, penalty, n=8, window=256):
 
 ACTIVITY_BYTES = 1024       # the text window the per-arm activity reads
 CALL_BUDGET_S = 112.0       # ZeroGPU ends the call at 120 s
+# the reply must end this long after the GPU call began, whatever the arm
+# switch before it cost: a first mount of a nine-arm set downloads ~0.5 GB,
+# and a reply cut by the call's own end is lost mid-stream instead of
+# stopping with a note
+CALL_GEN_END_S = 105.0
 
 
 @torch.no_grad()
@@ -1406,8 +1922,11 @@ def _activity(c, deadline):
     reply, inside the same GPU call, while the program is still attached.
     Near zero means the arm is quiet on this text."""
     h, ids = c.handle, getattr(c, "last_ids", None)
-    if not isinstance(h, arm_mount.ProgramHandle) or ids is None \
-            or ids.shape[1] < 2:
+    if ids is None or ids.shape[1] < 2:
+        return ""
+    if _is_lookup(h):
+        return _lookup_activity(c, h, ids, deadline)
+    if not isinstance(h, arm_mount.ProgramHandle):
         return ""
     live = [n for n in h.names if h.live.get(n)]
     if not live:
@@ -1421,37 +1940,87 @@ def _activity(c, deadline):
             continue
         with h.masked(n):
             lb = c.model(x)[0].float().log_softmax(-1)
-        kl = float((lb.exp() * (lb - la)).sum(-1).mean())
-        moved = float((lb.argmax(-1) != la.argmax(-1)).float().mean())
-        # below ~1e-9 an fp32 KL between two near-identical distributions
-        # is rounding, not a measurement: say "none measurable", not 0
-        parts.append(f"`{n}` " + (f"{kl:.1e} nats/byte" if kl >= 1e-9 else
-                                  "< 1e-9 nats/byte (none measurable)")
-                     + f", top byte changed at {moved:.1%} of positions")
+        parts.append(f"`{n}` " + _kl_text(la, lb))
     return (f" · **arm activity** on this text (last {x.shape[1]:,} bytes, "
             "each arm switched off alone): " + " · ".join(parts))
 
 
+def _kl_text(la, lb):
+    """KL(off || as it ran) in nats per byte and the top-byte change rate.
+    Below ~1e-9 an fp32 KL between two near-identical distributions is
+    rounding, not a measurement: say "none measurable", not 0."""
+    kl = float((lb.exp() * (lb - la)).sum(-1).mean())
+    moved = float((lb.argmax(-1) != la.argmax(-1)).float().mean())
+    return ((f"{kl:.1e} nats/byte" if kl >= 1e-9 else
+             "< 1e-9 nats/byte (none measurable)")
+            + f", top byte changed at {moved:.1%} of positions")
+
+
+def _is_lookup(h):
+    try:
+        from amoe.arms.lookup import LookupHandle
+    except ImportError:
+        return False
+    return isinstance(h, LookupHandle)
+
+
+@torch.no_grad()
+def _lookup_activity(c, h, ids, deadline):
+    """The lookup arm's write on the text just produced: the whole arm
+    switched off, then each site switched off alone, as KL(off || armed)
+    per byte over the last ACTIVITY_BYTES. The arm writes where a cue
+    asks for a value planted earlier and barely anywhere else, so on
+    ordinary text these read near zero; on a recall prompt the write sits
+    at the question. The arm's flags are restored even if a read fails."""
+    x = ids[:, -ACTIVITY_BYTES:]
+    wraps = h.wraps()
+    la = c.model(x)[0].float().log_softmax(-1)
+    parts = []
+    try:
+        for w in wraps:
+            w.enabled = False
+        lb = c.model(x)[0].float().log_softmax(-1)
+        parts.append("whole arm off " + _kl_text(la, lb))
+    finally:
+        for w in wraps:
+            w.enabled = True
+    for s, w in zip(h.sites, wraps):
+        if time.time() > deadline:
+            parts.append(f"block {s} not read (GPU time)")
+            continue
+        try:
+            w.enabled = False
+            lb = c.model(x)[0].float().log_softmax(-1)
+        finally:
+            w.enabled = True
+        parts.append(f"after block {s} off alone " + _kl_text(la, lb))
+    return (f" · **lookup arm activity** on this text (last {x.shape[1]:,} "
+            "bytes): " + " · ".join(parts))
+
+
 @spaces.GPU(duration=120)
 def _stream(craft, ids, max_new, temperature, top_p, use_cache, arm_path,
-            ckpt_step, stop=(), stop_ids=(), guard=False, rep=1.0):
+            ckpt_step, stop=(), stop_ids=(), guard=False, rep=1.0,
+            live=None):
     """The GPU call: the reply as it streams (_generate), then, when a
-    stage program ran, one more yield that adds each live arm's measured
-    activity on the finished text to the stats line."""
+    program of arms or the lookup arm ran, one more yield that adds the
+    measured activity on the finished text to the stats line."""
     t_call = time.time()
     last = None
     for last in _generate(craft, ids, max_new, temperature, top_p,
                           use_cache, arm_path, ckpt_step, stop, stop_ids,
-                          guard, rep):
+                          guard, rep, live, call_t0=t_call):
         yield last
-    if last is not None and last[2].get("live_arms"):
+    if last is not None and (last[2].get("live_arms")
+                             or last[2].get("lookup_sites")):
         line = _activity(S(craft), t_call + CALL_BUDGET_S)
         if line:
             yield last[0], last[1] + line, last[2]
 
 
 def _generate(craft, ids, max_new, temperature, top_p, use_cache, arm_path,
-              ckpt_step, stop=(), stop_ids=(), guard=False, rep=1.0):
+              ckpt_step, stop=(), stop_ids=(), guard=False, rep=1.0,
+              live=None, call_t0=None):
     """Yields (text, stats, prov) — prov is what actually RAN, resolved
     by _select, not what the dropdowns asked for. It travels back
     through the yield because it has to cross a process boundary: the
@@ -1467,7 +2036,7 @@ def _generate(craft, ids, max_new, temperature, top_p, use_cache, arm_path,
     tasks) and a threading.Lock would be actively unsafe under fork: one
     held by any parent thread at fork time is inherited locked with no
     owner, and the child would block forever."""
-    prov = _select(craft, ckpt_step, arm_path)
+    prov = _select(craft, ckpt_step, arm_path, live)
     c = S(craft)
     model = c.model
     dev = next(model.parameters()).device
@@ -1493,10 +2062,16 @@ def _generate(craft, ids, max_new, temperature, top_p, use_cache, arm_path,
     stop_ids = set(int(s) for s in stop_ids)
     out, t0 = [], time.time()
     deadline, budget_hit = t0 + GEN_BUDGET_S, False
+    if call_t0 is not None:          # the switch above spent the same call
+        deadline = min(deadline, call_t0 + CALL_GEN_END_S)
     label = (f"{prov['craft']} · step {prov['checkpoint_step']:,} · "
-             + (("stage arms on: " + ", ".join(
-                 f"`{n}`" for n in prov["live_arms"]))
+             + ((("stage arms on: " if prov["arm_kind"] == "stage-program"
+                  else f"arm set `{prov['arm']}`, on: ")
+                 + (", ".join(f"`{n}`" for n in prov["live_arms"])
+                    or "none (every member switched off)"))
                 if prov.get("live_arms") is not None else
+                f"lookup arm `{prov['lookup_version']}`"
+                if prov.get("lookup_version") else
                 f"arm `{prov['arm'].split('@')[0]}`" if prov["arm"]
                 else "core only")
              + (" · fp32" if prov.get("precision") == "fp32" else "")
@@ -1570,14 +2145,15 @@ def _generate(craft, ids, max_new, temperature, top_p, use_cache, arm_path,
             # the requested byte count was honoured as far as the GPU
             # allowance allowed; the shortfall is stated, never hidden
             note = (f" …[stopped at {len(out)} of {max_new} bytes — "
-                    f"{GEN_BUDGET_S:.0f}s GPU budget"
+                    f"{deadline - t0:.0f}s GPU budget"
                     + ("" if use_cache else "; the KV cache is off, so "
                        "every byte recomputes the whole context") + "]")
             yield _render(out, c.fmt) + note, stats + " · **budget**", prov
 
 
 def complete(craft, prompt, max_new, temperature, top_p, use_cache, arm_path,
-             ckpt_step, guard, rep=1.0, request: gr.Request = None):
+             ckpt_step, guard, rep=1.0, members=None,
+             request: gr.Request = None):
     if not prompt or not prompt.strip():
         yield "(enter a prompt)", ""
         return
@@ -1601,7 +2177,8 @@ def complete(craft, prompt, max_new, temperature, top_p, use_cache, arm_path,
                                          arm_path, step_i, stop=stops,
                                          stop_ids=stop_ids,
                                          guard=bool(guard),
-                                         rep=float(rep)):
+                                         rep=float(rep),
+                                         live=_members_in(members)):
             yield prompt + text, stats
         done = True
     finally:
@@ -1672,8 +2249,17 @@ def _specials_chat_ids(history, message, context, budget=None):
                                                      errors="replace")
 
 
+def _members_in(members):
+    """The member switch's value as _select takes it: a list (possibly
+    empty: every member off), or None when no switch value came with the
+    call (an API caller), which means the row's own default."""
+    if members is None:
+        return None
+    return [str(m) for m in members]
+
+
 def chat(craft, message, history, max_new, temperature, top_p, use_cache,
-         arm_path, ckpt_step, guard, rep=1.0, convo_id="",
+         arm_path, ckpt_step, guard, rep=1.0, convo_id="", members=None,
          request: gr.Request = None):
     if not message or not message.strip():
         yield list(history or []), "", ""
@@ -1759,7 +2345,8 @@ def chat(craft, message, history, max_new, temperature, top_p, use_cache,
                                          top_p, use_cache, arm_path, step_i,
                                          stop=stops, stop_ids=stop_ids,
                                          guard=bool(guard),
-                                         rep=float(rep)):
+                                         rep=float(rep),
+                                         live=_members_in(members)):
             body = _finish_reply(text, stops)
             history[-1]["content"] = (preface + body) if body else empty
             yield history, "", stats
@@ -1782,7 +2369,9 @@ TITLE = "# Beatrix — byte-level AlephLLMs you can talk to"
 # Everything explanatory lives in a closed accordion for that reason.
 DESCRIPTION = """
 Three generations of the same architecture, served side by side, newest
-first. Pick the **Craft** first — everything below it follows.
+first, and four control twins of 2s that run ordinary softmax attention
+where 2s runs the splat. Pick the **Craft** first — everything below it
+follows.
 
 **mini-beatrix-3** — 376M parameters over 32 blocks: the same governed
 full-splat hub as 2s, deeper. Its mission is **complete** — 64.4 billion
@@ -1814,11 +2403,46 @@ pick a checkpoint that carries them: the stage closes before that point,
 or 148,000 itself, the last with all four. They open all on; each can
 run alone or be switched off, a switched-off arm removes exactly its own
 write, and after every run the stats line shows how far each live arm
-moved the predictions on that text. Every later checkpoint, the final
-one included, is the core alone. The stages with arms: perspective (one
-event seen from different people), concept (kinds and opposites), rules
-(if-then chains over made-up words) and arithmetic (with the working
-shown).
+moved the predictions on that text. Every later checkpoint is the core
+alone. The stages with arms: perspective (one event seen from different
+people), concept (kinds and opposites), rules (if-then chains over
+made-up words) and arithmetic (with the working shown).
+
+**Arms fitted on the final core.** After the mission, new arms were
+fitted on the final core (step 245,674) with the core frozen, and that
+checkpoint lists them under *Arm*. It still opens bare; pick a row to
+attach one.
+
+- **Arm sets**: one arm per curriculum stage (13.7M parameters each),
+  on together. Picking a set shows a box for each of its arms. Untick
+  any of them, alone or several at once, to run every subset of the set:
+  a switched-off arm removes exactly its own write, and nothing
+  renormalizes. The panel gives each arm's measured bits per byte on its
+  own stage's text and the set's cost on held-out web text. Listed first
+  are the two packaged sets (stages 1–4 and stages 1–8) and the
+  experimental caption set (the eight plus an arm for image captions in
+  a labelled frame), each in two seeds; the research sets after them
+  differ in how the arms were trained together.
+- **Solo arms**: each stage's arm trained alone, two seeds each.
+- **The lookup arm**: ordinary softmax attention added after four of the
+  core's blocks (2, 6, 12 and 20), born at zero and trained with the
+  core frozen, so switching it off gives the core back bit for bit. The
+  core remembers by address, and a value planted early in a long text
+  fades from it within a few hundred bytes. The arm was trained on web
+  text mixed with recall rows (a value planted behind text, asked for
+  later), and every version of it is listed. Picking one shows recall
+  prompts in the Completion tab: run one with the arm on, then with
+  *Core only*. On the measured recall rows the core alone fetches none
+  of the values from 1,024 bytes back; the deep-mix versions fetch the
+  value's first byte about nine times in ten from 2,048 bytes back.
+  Telling apart several values planted under different keys (the
+  lockers prompt) is still open: the one-layer arm reads near chance
+  there.
+
+The packaged sets and solo arms ship with the
+[mini-beatrix-3](https://huggingface.co/AbstractPhil/mini-beatrix-3)
+package: `m.mount_arm("stages-1-8")` for a set, `m.mount_arm("solo/s3_rules")`
+for one solo arm, `m.detach_arm()` for the bare core again.
 
 **mini-beatrix-2s** — 237.1M parameters, **full splat**: the signed
 address read runs in *every* block (v1 used it in three), with a
@@ -1862,6 +2486,19 @@ The library here is the wider surface — 73 rows including the refuted
 and control ones that exist to be disprovable. The package is the
 settled subset, carrying each arm's measured numbers with it.
 
+**The 2s control twins.** The four crafts named mini-beatrix-2s-control
+are 2s's own recipe and data with ordinary softmax attention in all 20
+blocks where 2s has the splat hub: the experiment's control. The
+original twin ran the whole mission in bf16. Under the recipe tuned for
+the splat its training destabilized from step 17,600, and it closed at
+2.88 bits per byte on held-out text against 2s's 1.11. Three re-runs
+start from its own earlier weights. Two precision tests restarted at
+step 16,000 and stopped near 18,300. The third restarted at step 10,000
+with the attention computed in fp32 around fp16 flash attention; it has
+stayed stable and is still training, and the Space lists what it had
+shipped when the Space last started. The twins carry no arms and decode
+in fp32.
+
 **mini-beatrix-1** — 112.5M parameters, pretrained on 15.3 billion raw
 bytes, carrying a **library of detachable arms**: small adapters
 (3.2M–5.3M parameters) each trained on one exact frozen core. Pick a
@@ -1940,7 +2577,7 @@ _C0 = STATE[CRAFT]
 
 with gr.Blocks(title="Beatrix — AlephLLM chat") as demo:
     gr.Markdown(TITLE)
-    with gr.Accordion("About Beatrix — the three crafts, how she reads text, "
+    with gr.Accordion("About Beatrix — the crafts, how she reads text, "
                       "what the arms are, what to expect", open=False):
         gr.Markdown(DESCRIPTION)
         gr.Markdown(LOG_NOTE)
@@ -1964,6 +2601,23 @@ with gr.Blocks(title="Beatrix — AlephLLM chat") as demo:
                                label="Arm (adapter)", scale=4,
                                allow_custom_value=True,
                                interactive=bool(_C0.arm_by_path))
+    # the member switch: one box per arm of the picked program (a stage
+    # program or an arm set), every box ticked when the row is picked;
+    # hidden for every other row, so no other craft's page grows
+    # gradio checks a submitted value against the component's choices: the
+    # session's copy once an event has updated them, the page's own at the
+    # start of a session (and for API callers). Hidden, the switch starts
+    # with every member name any program row carries, so no session's
+    # first call is refused; picking a row narrows it to that row's members.
+    _a0 = _C0.arm_by_path.get(_C0.default_arm(STEP))
+    _all_members = list(dict.fromkeys(
+        n for _c in STATE.values() for _r in _c.arm_by_path.values()
+        for n in (_r.get("members") or [])))
+    members_pick = gr.CheckboxGroup(
+        choices=(_member_choices(_a0) if (_a0 or {}).get("members") else
+                 _member_choices({"members": _all_members})),
+        value=_live_set(_a0, None) if (_a0 or {}).get("members") else [],
+        label=_member_label(_a0), visible=bool((_a0 or {}).get("members")))
     with gr.Row():
         max_new = gr.Slider(16, MAX_NEW_CAP, value=192, step=16,
                             label="Max new bytes")
@@ -2023,7 +2677,8 @@ with gr.Blocks(title="Beatrix — AlephLLM chat") as demo:
         # after a Clear ran together as one conversation
         convo = gr.State("")
         _chat_in = [craft_pick, msg, chatbot, max_new, temperature, top_p,
-                    use_cache, arm_pick, ckpt, guard, rep, convo]
+                    use_cache, arm_pick, ckpt, guard, rep, convo,
+                    members_pick]
         _chat_out = [chatbot, msg, stats_md]
         _ev1 = msg.submit(chat, _chat_in, _chat_out)
         _ev2 = send.click(chat, _chat_in, _chat_out)
@@ -2039,6 +2694,14 @@ with gr.Blocks(title="Beatrix — AlephLLM chat") as demo:
         # max_lines pinned: unpinned textboxes auto-grow to 20 rows in
         # 6.23.1, and a streaming continuation would push the tabs out
         # of reach inside the non-scrolling iframe
+        # shown only for the lookup arm: a value planted early in a long
+        # text, asked for at the end, in the phrasing the arm trained on
+        recall_pick = gr.Dropdown(
+            [lab for lab, _ in RECALL_PROBES], value=None,
+            label="Recall prompts for the lookup arm · picking one writes "
+                  "it into the prompt box; run it with the arm on, then "
+                  "with Core only",
+            visible=bool(_a0 and _a0.get("kind") == "lookup"))
         prompt = gr.Textbox(label="Prompt", lines=4, max_lines=4,
                             value="The history of mathematics begins")
         comp_out = gr.Textbox(label="Continuation (streams)", lines=12,
@@ -2059,8 +2722,9 @@ with gr.Blocks(title="Beatrix — AlephLLM chat") as demo:
         _ev3 = comp_go.click(
             complete,
             [craft_pick, prompt, max_new, temperature, top_p, use_cache,
-             arm_pick, ckpt, guard, rep],
+             arm_pick, ckpt, guard, rep, members_pick],
             [comp_out, stats_md])
+        recall_pick.input(on_recall, recall_pick, prompt)
     # ONE halt for every generator, wired after both tabs so a Stop on
     # either side reaches the run in flight. Cancelling closes the
     # generator at its yield: the bytes already streamed stay on screen,
@@ -2076,14 +2740,19 @@ with gr.Blocks(title="Beatrix — AlephLLM chat") as demo:
     # toggles say otherwise
     craft_pick.change(on_craft, [craft_pick, auto_decode, fam_examples],
                       [ckpt, arm_pick, status_box, temperature, top_p, rep,
-                       ex.dataset, comp_ex.dataset])
+                       ex.dataset, comp_ex.dataset, members_pick,
+                       recall_pick])
     ckpt.change(on_checkpoint, [craft_pick, ckpt, auto_decode, fam_examples],
                 [ckpt, arm_pick, status_box, temperature, top_p, rep,
-                 ex.dataset, comp_ex.dataset])
+                 ex.dataset, comp_ex.dataset, members_pick, recall_pick])
     arm_pick.change(on_arm,
                     [craft_pick, ckpt, arm_pick, auto_decode, fam_examples],
                     [status_box, temperature, top_p, rep, ex.dataset,
-                     comp_ex.dataset])
+                     comp_ex.dataset, members_pick, recall_pick])
+    # ticking a member re-renders the panel's member line; .input fires on
+    # the visitor's own clicks only, not when on_arm refreshes the boxes
+    members_pick.input(on_members, [craft_pick, ckpt, arm_pick, members_pick],
+                       status_box)
     demo.load(js=RESIZE_JS)
 
 demo.launch()

arm_mount.py

@@ -20,11 +20,15 @@ Recipe types (the `mount.type` field of an arm-index row):
   recurrent   a small recurrent cell per site fed by the attention read
   program     a co-trained stage-arm program (mini-beatrix-3): one anchor
               arm per curriculum stage, trained together with the core,
-              nested in stage order, each member switchable on its own
+              nested in stage order, each member switchable on its own;
+              the arm sets fitted on the finished core mount the same way
+  lookup      a zero-born causal softmax-attention arm after chosen
+              blocks (amoe.arms.lookup), read from the lookup_* tensors
+              of a trainer checkpoint or of an arm-only file
 
-The relay_ema, recurrent and gain recipes carry state across cached
-decode steps; a fresh prefill starts that state over, and the uncached
-path treats every forward as a fresh context.
+The relay_ema, recurrent, gain and lookup recipes carry state across
+cached decode steps; a fresh prefill starts that state over, and the
+uncached path treats every forward as a fresh context.
 
 Trained arms and their measurements:
 huggingface.co/AbstractPhil/alephllm-mini-beatrix-training
@@ -49,7 +53,7 @@ from amoe.io.checkpoint import load_anchor, load_dispatch
 from amoe.runtime.attach import AttachHandle, _probe
 
 MOUNT_TYPES = ("anchor", "stack", "routed", "relay_ema", "recurrent",
-               "program")
+               "program", "lookup")
 
 
 # ------------------------------------------------------------- geometry
@@ -370,11 +374,90 @@ def _mount_recurrent(model, path):
     return attach_recurrent(model, name, RecurrentSpec(**blob["spec"]), state=blob["state"])
 
 
+# ------------------------------------------------------------- lookup arm
+LOOKUP_PREFIXES = ("lookup_arms.", "lookup_norms.")
+_ST_DTYPES = {"BF16": torch.bfloat16, "F16": torch.float16,
+              "F32": torch.float32, "F64": torch.float64}
+
+
+def _st_tensor(meta, raw):
+    t = torch.frombuffer(bytearray(raw), dtype=_ST_DTYPES[meta["dtype"]])
+    return t.reshape(meta["shape"]).clone()
+
+
+def fetch_lookup_tensors(repo: str, path: str, cache_dir: str) -> str:
+    """The lookup arm's tensors out of a trainer checkpoint on the hub, by
+    HTTP range reads: the safetensors header, then only the lookup_*
+    tensors' bytes (about 34 MB of a 790 MB file per attention layer set).
+    Written once to a local safetensors file under cache_dir (atomically,
+    so two workers never read a half-written file) and reused after."""
+    import json
+    import os
+    import struct
+    import tempfile
+
+    from huggingface_hub import HfFileSystem
+    from safetensors.torch import save_file
+
+    out = os.path.join(cache_dir, path.replace("/", "__") + ".lookup.safetensors")
+    if os.path.exists(out):
+        return out
+    os.makedirs(cache_dir, exist_ok=True)
+    with HfFileSystem().open(f"{repo}/{path}", "rb") as fh:
+        n = struct.unpack("<Q", fh.read(8))[0]
+        header = json.loads(fh.read(n))
+        base = 8 + n
+        spans = sorted((header[k]["data_offsets"][0], header[k]["data_offsets"][1], k)
+                       for k in header if k.startswith(LOOKUP_PREFIXES))
+        if not spans:
+            raise KeyError(f"{path}: the checkpoint carries no lookup arm")
+        lo, hi = spans[0][0], spans[-1][1]
+        tensors = {}
+        if hi - lo <= 2 * sum(e - b for b, e, _ in spans):    # one read
+            fh.seek(base + lo)
+            blob = fh.read(hi - lo)
+            for b, e, k in spans:
+                tensors[k] = _st_tensor(header[k], blob[b - lo:e - lo])
+        else:
+            for b, e, k in spans:
+                fh.seek(base + b)
+                tensors[k] = _st_tensor(header[k], fh.read(e - b))
+    fd, tmp = tempfile.mkstemp(dir=cache_dir, suffix=".part")
+    os.close(fd)
+    save_file(tensors, tmp, metadata={"source": f"{repo}/{path}",
+                                      "keys": str(len(tensors))})
+    os.replace(tmp, out)
+    return out
+
+
+def _mount_lookup(model, path, name="lookup"):
+    """A lookup arm: zero-born causal softmax attention after chosen blocks,
+    each layer behind its own LayerNorm (amoe.arms.lookup). The geometry is
+    read from the keys (sites, depth, heads from the q/k gains) and checked
+    against the bound trunk; the attention runs in fp32 under autocast, as
+    it was trained. Cached decode keeps the arm's own key/value cache."""
+    from safetensors.torch import load_file
+    from amoe.arms.lookup import attach_from_alephllm, from_alephllm_state
+    sd = {k: v for k, v in load_file(path).items()
+          if k.startswith(LOOKUP_PREFIXES)}
+    _, sites, depth = from_alephllm_state(sd)
+    b = resolve(model, None)
+    n_blocks, d = len(list(b.layers(model))), b.hidden_size(model)
+    if max(sites) >= n_blocks:
+        raise ValueError(f"lookup arm sites {sites} outside a {n_blocks}-block trunk")
+    w = sd[f"lookup_arms.{sites[0]}.qkv.weight"]
+    if tuple(w.shape) != (3 * d, d):
+        raise ValueError(f"lookup arm width {tuple(w.shape)} does not fit d={d}")
+    return attach_from_alephllm(model, sd, name=name, attn_fp32=True)
+
+
 def mount(model, recipe: dict, path: str, member_paths=None):
     """Attach one arm recipe to the bare model. `path` is the local file of
     the row's own checkpoint; `member_paths` are the local files of a
     stack's members, inner first, or of a stage program's members."""
     kind = (recipe or {}).get("type", "anchor")
+    if kind == "lookup":
+        return _mount_lookup(model, path, (recipe or {}).get("name", "lookup"))
     if kind == "anchor":
         return _mount_anchor(model, path)
     if kind == "stack":

arms_catalog.json

@@ -3790,6 +3790,1821 @@
      "default": false
     }
    ]
+  },
+  "mini-beatrix-3": {
+   "rows": [
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gXA_close8",
+     "step": 245674,
+     "name": "stages-1-8",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gXA",
+     "close": 8,
+     "title": "Arm set · stages 1–8, on together · seed A",
+     "status": "two seeds · the packaged set",
+     "rank": 1,
+     "what": "The four arms of stages 1–4 held fixed and on, then a new arm for each of stages 5–8 fitted over them one after another, 4,000 steps each, each kept quiet on web text and on the other arms' stage text. Packaged as stages-1-8 in mini-beatrix-3.",
+     "score": "stage text, arms off → set on: perspective .554→.049 · concepts .721→.110 · rules .930→.224 · arithmetic 1.234→.328 · causal .660→.043 · try-fail .673→.055 · mixed .783→.720 · register .491→.021 · web text +0.0019",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s4_arith.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s5_causal.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s6_tryfail.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s7_mixed.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXA_close8_s8_register.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gXA_close8",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.049211667943427066,
+       "alone": 0.05251879489204885
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.11045867104531781,
+       "alone": 0.35026574371684355
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.2237152122866791,
+       "alone": 0.8236434891082838
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.32794756855052143,
+       "alone": 1.126693075548818
+      },
+      "s5_causal": {
+       "off": 0.6604376826115352,
+       "on": 0.04305856436254439,
+       "alone": 0.09109720145841224
+      },
+      "s6_tryfail": {
+       "off": 0.6728212611401647,
+       "on": 0.05483553152977349,
+       "alone": 0.16377145340459293
+      },
+      "s7_mixed": {
+       "off": 0.7829759286650222,
+       "on": 0.719981644980245,
+       "alone": 0.7241658592632068
+      },
+      "s8_register": {
+       "off": 0.4906504977761471,
+       "on": 0.02118320337400121,
+       "alone": 0.06783037737981043
+      }
+     },
+     "web": 0.0018905407874407892,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 109543680,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gCA_close9",
+     "step": 245674,
+     "name": "stages-1-8-caption",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gCA",
+     "close": 9,
+     "title": "Arm set · stages 1–8 + the caption arm (experimental) · seed A",
+     "status": "two seeds · experimental",
+     "rank": 2,
+     "what": "The eight held fixed and on, then a ninth arm fitted over them for 4,000 steps on image captions in a labelled frame (tags, caption, short, attributes, scene, photo, structure, medium, long, rating: one label per line). A prototype for the diffusion line, not a curriculum stage.",
+     "score": "stage text, arms off → set on: perspective .554→.050 · concepts .721→.111 · rules .930→.224 · arithmetic 1.234→.329 · causal .660→.043 · try-fail .673→.055 · mixed .783→.722 · register .491→.022 · captions 1.265→.783 · web text +0.0027",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s4_arith.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s5_causal.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s6_tryfail.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s7_mixed.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s8_register.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCA_close9_s9_caption.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gCA_close9",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register",
+      "s9_caption"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register",
+      "s9_caption"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.04959379525484903,
+       "alone": 0.05251879489204885
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.111269350234979,
+       "alone": 0.35026574371684355
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.22448037384928343,
+       "alone": 0.8236434891082838
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.328711851389269,
+       "alone": 1.126693075548818
+      },
+      "s5_causal": {
+       "off": 0.6604376826115352,
+       "on": 0.043431814413230005,
+       "alone": 0.09109720145841224
+      },
+      "s6_tryfail": {
+       "off": 0.6728212611401647,
+       "on": 0.0550433322549074,
+       "alone": 0.16377145340459293
+      },
+      "s7_mixed": {
+       "off": 0.7829759286650222,
+       "on": 0.7218170545791686,
+       "alone": 0.7241658592632068
+      },
+      "s8_register": {
+       "off": 0.4906504977761471,
+       "on": 0.02167318429763465,
+       "alone": 0.06783037737981043
+      },
+      "s9_caption": {
+       "off": 1.2648128906514393,
+       "on": 0.7829180887497539,
+       "alone": 0.7850811467964025
+      }
+     },
+     "web": 0.002653240848354624,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 123236640,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gRA_close4",
+     "step": 245674,
+     "name": "stages-1-4",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gRA",
+     "close": 4,
+     "title": "Arm set · stages 1–4, on together · seed A",
+     "status": "two seeds · the packaged set",
+     "rank": 3,
+     "what": "The arms of stages 1 and 2 from a co-trained run held fixed, then new arms for stages 3 and 4 fitted over them one after the other, 800 steps each, each kept quiet on web text and on the other arms' stage text. Packaged as stages-1-4 in mini-beatrix-3.",
+     "score": "stage text, arms off → set on: perspective .554→.048 · concepts .721→.112 · rules .930→.224 · arithmetic 1.234→.338 · web text +0.0017",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gRA_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gRA_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gRA_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gRA_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gRA_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.04815859600255551,
+       "alone": 0.05251879489204885
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.1122730718885469,
+       "alone": 0.35026574371684355
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.22363961516270922,
+       "alone": 0.8236434891082838
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.33837794280053096,
+       "alone": 1.126693075548818
+      }
+     },
+     "web": 0.001714742271511971,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gXB_close8",
+     "step": 245674,
+     "name": "stages-1-8 (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gXB",
+     "close": 8,
+     "title": "Arm set · stages 1–8, on together · seed B",
+     "status": "two seeds",
+     "rank": 4,
+     "what": "The second seed of the stages 1–8 set (the arms of stages 5–8 with their own seeds and data order).",
+     "score": "stage text, arms off → set on: perspective .554→.048 · concepts .721→.121 · rules .930→.222 · arithmetic 1.234→.327 · causal .660→.043 · try-fail .673→.054 · mixed .783→.720 · register .491→.021 · web text +0.0010",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s4_arith.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s5_causal.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s6_tryfail.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s7_mixed.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gXB_close8_s8_register.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gXB_close8",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.048373615296375044,
+       "alone": 0.05217516482213097
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.12122929684668586,
+       "alone": 0.36033454325401637
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.22223428311624405,
+       "alone": 0.8701872076558641
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.3266083503971684,
+       "alone": 1.1550061816504822
+      },
+      "s5_causal": {
+       "off": 0.6604376826115352,
+       "on": 0.042796246816605044,
+       "alone": 0.1417724646021276
+      },
+      "s6_tryfail": {
+       "off": 0.6728212611401647,
+       "on": 0.05430685618921398,
+       "alone": 0.14373820614727262
+      },
+      "s7_mixed": {
+       "off": 0.7829759286650222,
+       "on": 0.7197570947572544,
+       "alone": 0.7253837275330026
+      },
+      "s8_register": {
+       "off": 0.4906504977761471,
+       "on": 0.020783710349540914,
+       "alone": 0.05160327413789158
+      }
+     },
+     "web": 0.0010273276160133182,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 109543680,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gCB_close9",
+     "step": 245674,
+     "name": "stages-1-8-caption (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gCB",
+     "close": 9,
+     "title": "Arm set · stages 1–8 + the caption arm · seed B",
+     "status": "two seeds · experimental",
+     "rank": 5,
+     "what": "The second seed of the caption set.",
+     "score": "stage text, arms off → set on: perspective .554→.049 · concepts .721→.122 · rules .930→.223 · arithmetic 1.234→.327 · causal .660→.043 · try-fail .673→.055 · mixed .783→.722 · register .491→.021 · captions 1.265→.779 · web text +0.0017",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s4_arith.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s5_causal.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s6_tryfail.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s7_mixed.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s8_register.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gCB_close9_s9_caption.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gCB_close9",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register",
+      "s9_caption"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register",
+      "s9_caption"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.04877186900444792,
+       "alone": 0.05217516482213097
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.12184493024328064,
+       "alone": 0.36033454325401637
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.2225047903282199,
+       "alone": 0.8701872076558641
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.32716468740042043,
+       "alone": 1.1550061816504822
+      },
+      "s5_causal": {
+       "off": 0.6604376826115352,
+       "on": 0.04308597712065818,
+       "alone": 0.1417724646021276
+      },
+      "s6_tryfail": {
+       "off": 0.6728212611401647,
+       "on": 0.054676336729532454,
+       "alone": 0.14373820614727262
+      },
+      "s7_mixed": {
+       "off": 0.7829759286650222,
+       "on": 0.7215182454722101,
+       "alone": 0.7253837275330026
+      },
+      "s8_register": {
+       "off": 0.4906504977761471,
+       "on": 0.02129359624959004,
+       "alone": 0.05160327413789158
+      },
+      "s9_caption": {
+       "off": 1.2648128906514393,
+       "on": 0.7794967841315616,
+       "alone": 0.7818745625178125
+      }
+     },
+     "web": 0.0016882354454477305,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 123236640,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gRB_close4",
+     "step": 245674,
+     "name": "stages-1-4 (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gRB",
+     "close": 4,
+     "title": "Arm set · stages 1–4, on together · seed B",
+     "status": "two seeds",
+     "rank": 6,
+     "what": "The second seed of the stages 1–4 set.",
+     "score": "stage text, arms off → set on: perspective .554→.048 · concepts .721→.121 · rules .930→.222 · arithmetic 1.234→.338 · web text +0.0011",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gRB_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gRB_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gRB_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gRB_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gRB_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.047862855039216154,
+       "alone": 0.05217516482213097
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.12117190301141822,
+       "alone": 0.36033454325401637
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.22223902876251628,
+       "alone": 0.8701872076558641
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.33787596037663836,
+       "alone": 1.1550061816504822
+      }
+     },
+     "web": 0.0011034729346828115,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gEA_close8",
+     "step": 245674,
+     "name": "eight from scratch",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gEA",
+     "close": 8,
+     "title": "Arm set · all eight fitted from scratch · seed A",
+     "status": "two seeds · research row",
+     "rank": 7,
+     "what": "All eight arms fitted from scratch, frozen in turn, every arm kept quiet on every other arm's stage text from its first step, 4,000 steps per stage.",
+     "score": "stage text, arms off → set on: perspective .554→.048 · concepts .721→.077 · rules .930→.181 · arithmetic 1.234→.267 · causal .660→.043 · try-fail .673→.055 · mixed .783→.727 · register .491→.021 · web text +0.0012",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s4_arith.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s5_causal.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s6_tryfail.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s7_mixed.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEA_close8_s8_register.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gEA_close8",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.04782171591578037,
+       "alone": 0.04691673413754267
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.07664305728712961,
+       "alone": 0.07567364818783051
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.1810846217122526,
+       "alone": 0.18058990286813004
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.26691530056799195,
+       "alone": 0.2691548452113829
+      },
+      "s5_causal": {
+       "off": 0.6604376826115352,
+       "on": 0.04337998952399491,
+       "alone": 0.04574753796565191
+      },
+      "s6_tryfail": {
+       "off": 0.6728212611401647,
+       "on": 0.05485438983052493,
+       "alone": 0.07609357876388802
+      },
+      "s7_mixed": {
+       "off": 0.7829759286650222,
+       "on": 0.727499721452351,
+       "alone": 0.7315994411963898
+      },
+      "s8_register": {
+       "off": 0.4906504977761471,
+       "on": 0.02117565444411026,
+       "alone": 0.024590816056992
+      }
+     },
+     "web": 0.0012417254881451761,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 109543680,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gEB_close8",
+     "step": 245674,
+     "name": "eight from scratch (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gEB",
+     "close": 8,
+     "title": "Arm set · all eight fitted from scratch · seed B",
+     "status": "two seeds · research row",
+     "rank": 8,
+     "what": "The second seed of the from-scratch eight.",
+     "score": "stage text, arms off → set on: perspective .554→.051 · concepts .721→.076 · rules .930→.181 · arithmetic 1.234→.267 · causal .660→.044 · try-fail .673→.055 · mixed .783→.728 · register .491→.021 · web text +0.0018",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s4_arith.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s5_causal.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s6_tryfail.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s7_mixed.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gEB_close8_s8_register.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gEB_close8",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith",
+      "s5_causal",
+      "s6_tryfail",
+      "s7_mixed",
+      "s8_register"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.05064719369403434,
+       "alone": 0.05044332505661722
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.07633792378690858,
+       "alone": 0.07537300235990543
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.18140732028430745,
+       "alone": 0.18155743560983595
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.26739326722702894,
+       "alone": 0.26888096552711277
+      },
+      "s5_causal": {
+       "off": 0.6604376826115352,
+       "on": 0.043634570873777964,
+       "alone": 0.04677976809492565
+      },
+      "s6_tryfail": {
+       "off": 0.6728212611401647,
+       "on": 0.055141103048308444,
+       "alone": 0.07294846954948744
+      },
+      "s7_mixed": {
+       "off": 0.7829759286650222,
+       "on": 0.7276259943392891,
+       "alone": 0.7293689578889162
+      },
+      "s8_register": {
+       "off": 0.4906504977761471,
+       "on": 0.021085106922045453,
+       "alone": 0.02668958853390469
+      }
+     },
+     "web": 0.0018326793743410896,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 109543680,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gSA_close4",
+     "step": 245674,
+     "name": "four, quiet on each other",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gSA",
+     "close": 4,
+     "title": "Arm set · four, frozen in turn, each quiet on the others' text · seed A",
+     "status": "two seeds · research row",
+     "rank": 9,
+     "what": "Four arms frozen in turn, each kept quiet on every other arm's stage text from its first step, 800 steps per stage. Each arm also works alone.",
+     "score": "stage text, arms off → set on: perspective .554→.081 · concepts .721→.120 · rules .930→.376 · arithmetic 1.234→.392 · web text +0.0020",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gSA_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gSA_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gSA_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gSA_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gSA_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.08131032448166621,
+       "alone": 0.08115575641781772
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.12035538312970001,
+       "alone": 0.12445310894988028
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.3755476824693398,
+       "alone": 0.38051485045758343
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.39175397043604643,
+       "alone": 0.3967888377824649
+      }
+     },
+     "web": 0.0019989758488097864,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gSB_close4",
+     "step": 245674,
+     "name": "four, quiet on each other (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gSB",
+     "close": 4,
+     "title": "Arm set · four, frozen in turn, each quiet on the others' text · seed B",
+     "status": "two seeds · research row",
+     "rank": 10,
+     "what": "The second seed.",
+     "score": "stage text, arms off → set on: perspective .554→.080 · concepts .721→.120 · rules .930→.376 · arithmetic 1.234→.392 · web text +0.0022",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gSB_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gSB_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gSB_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gSB_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gSB_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.08042484560321708,
+       "alone": 0.08008908508319063
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.12043002091294555,
+       "alone": 0.1230374566007489
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.37645924695072,
+       "alone": 0.3801666447086225
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.3915001025455416,
+       "alone": 0.3959761283913549
+      }
+     },
+     "web": 0.002171506694372244,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gFA_close4",
+     "step": 245674,
+     "name": "four, frozen in turn",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gFA",
+     "close": 4,
+     "title": "Arm set · four, the earlier arms frozen while the newest trains · seed A",
+     "status": "two seeds · research row",
+     "rank": 11,
+     "what": "Four arms, the earlier ones held fixed while the newest trains, 800 steps per stage. Each arm works alone in part.",
+     "score": "stage text, arms off → set on: perspective .554→.081 · concepts .721→.109 · rules .930→.358 · arithmetic 1.234→.367 · web text +0.0016",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gFA_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gFA_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gFA_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gFA_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gFA_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.08097044108066967,
+       "alone": 0.08089993424008099
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.10885521632867315,
+       "alone": 0.23095238734534776
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.357637406521258,
+       "alone": 0.4788150924493114
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.36695632407946416,
+       "alone": 0.44643810080125335
+      }
+     },
+     "web": 0.0016101123262932948,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gFB_close4",
+     "step": 245674,
+     "name": "four, frozen in turn (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gFB",
+     "close": 4,
+     "title": "Arm set · four, the earlier arms frozen while the newest trains · seed B",
+     "status": "two seeds · research row",
+     "rank": 12,
+     "what": "The second seed.",
+     "score": "stage text, arms off → set on: perspective .554→.080 · concepts .721→.109 · rules .930→.356 · arithmetic 1.234→.367 · web text +0.0018",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gFB_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gFB_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gFB_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gFB_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gFB_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.08034933715780154,
+       "alone": 0.07990232670411268
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.10922296226272392,
+       "alone": 0.2265888059064517
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.35550140886983106,
+       "alone": 0.47156215410579966
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.36746155805034963,
+       "alone": 0.44645017720801855
+      }
+     },
+     "web": 0.0017539543159086901,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gA_close4",
+     "step": 245674,
+     "name": "four, co-trained",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gA",
+     "close": 4,
+     "title": "Arm set · four, co-trained (every attached arm training) · seed A",
+     "status": "two seeds · research row",
+     "rank": 13,
+     "what": "Four arms attached one stage at a time, each new arm over the earlier ones, every attached arm still training, 800 steps per stage. The set works with every arm on, but it does not divide its work one stage to an arm: the first arm keeps training under every later stage and takes up most of their text.",
+     "score": "stage text, arms off → set on: perspective .554→.048 · concepts .721→.111 · rules .930→.310 · arithmetic 1.234→.464 · web text +0.0009",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gA_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gA_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gA_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gA_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gA_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.04810219039572311,
+       "alone": 0.05251879489204885
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.11126926827449693,
+       "alone": 0.35026574371684355
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.3101908704224312,
+       "alone": 0.9002206024695304
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.46378667334993046,
+       "alone": 1.2284806419988383
+      }
+     },
+     "web": 0.0009262770597157494,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/group/gB_close4",
+     "step": 245674,
+     "name": "four, co-trained (seed B)",
+     "group": "arm sets",
+     "kind": "arm-set",
+     "family": "set",
+     "run": "gB",
+     "close": 4,
+     "title": "Arm set · four, co-trained (every attached arm training) · seed B",
+     "status": "two seeds · research row",
+     "rank": 14,
+     "what": "The second seed.",
+     "score": "stage text, arms off → set on: perspective .554→.048 · concepts .721→.121 · rules .930→.309 · arithmetic 1.234→.490 · web text +0.0008",
+     "mount": {
+      "type": "program",
+      "members": [
+       "mini-beatrix-3/arm_refit/group/anchors/gB_close4_s1_perspective.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gB_close4_s2_concept.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gB_close4_s3_rules.safetensors",
+       "mini-beatrix-3/arm_refit/group/anchors/gB_close4_s4_arith.safetensors"
+      ]
+     },
+     "mount_key": "mini-beatrix-3/arm_refit/group/gB_close4",
+     "members": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "live": [
+      "s1_perspective",
+      "s2_concept",
+      "s3_rules",
+      "s4_arith"
+     ],
+     "reads": {
+      "s1_perspective": {
+       "off": 0.5538333013185592,
+       "on": 0.04774676607807653,
+       "alone": 0.05217516482213097
+      },
+      "s2_concept": {
+       "off": 0.7211839326967642,
+       "on": 0.12105901118088586,
+       "alone": 0.36033454325401637
+      },
+      "s3_rules": {
+       "off": 0.9296131361815035,
+       "on": 0.30863669814056,
+       "alone": 0.9003206963723325
+      },
+      "s4_arith": {
+       "off": 1.2338748670942346,
+       "on": 0.4896058052868545,
+       "alone": 1.2247594533821196
+      }
+     },
+     "web": 0.0008299990219795828,
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the sets were measured greedy in fp32"
+     },
+     "params": 54771840,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s1_perspective_fresh_seed1_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s1_perspective seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 1: perspective · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 102,
+     "what": "one small event retold from each side: seen from a person, said to them, told about them. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .554 → .047 · web text +0.0003",
+     "probe_stage": "perspective",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s1_perspective_fresh_seed101_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s1_perspective seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 1: perspective · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 103,
+     "what": "one small event retold from each side: seen from a person, said to them, told about them. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .554 → .047 · web text +0.0003",
+     "probe_stage": "perspective",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s2_concept_fresh_seed2_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s2_concept seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 2: concepts · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 104,
+     "what": "kinds, properties and differences: what a thing is a kind of, what its kind can do, how two things differ. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .721 → .075 · web text +0.0001",
+     "probe_stage": "concept",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s2_concept_fresh_seed102_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s2_concept seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 2: concepts · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 105,
+     "what": "kinds, properties and differences: what a thing is a kind of, what its kind can do, how two things differ. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .721 → .075 · web text +0.0000",
+     "probe_stage": "concept",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s3_rules_fresh_seed3_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s3_rules seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 3: rule chains · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 106,
+     "what": "if-then rules over made-up words, followed step by step to what follows. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .930 → .180 · web text +0.0003",
+     "probe_stage": "rules",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s3_rules_fresh_seed103_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s3_rules seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 3: rule chains · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 107,
+     "what": "if-then rules over made-up words, followed step by step to what follows. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .930 → .179 · web text +0.0005",
+     "probe_stage": "rules",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s4_arith_fresh_seed4_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s4_arith seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 4: arithmetic · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 108,
+     "what": "small arithmetic worked out in text. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text 1.234 → .267 · web text +0.0002",
+     "probe_stage": "arith",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s4_arith_fresh_seed104_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s4_arith seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 4: arithmetic · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 109,
+     "what": "small arithmetic worked out in text. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text 1.234 → .267 · web text +0.0003",
+     "probe_stage": "arith",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s5_causal_fresh_seed5_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s5_causal seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 5: cause and effect · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 110,
+     "what": "short cause-and-effect text: what happened and why. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .660 → .043 · web text +0.0006",
+     "probe_stage": "causal",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s5_causal_fresh_seed105_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s5_causal seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 5: cause and effect · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 111,
+     "what": "short cause-and-effect text: what happened and why. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .660 → .043 · web text +0.0004",
+     "probe_stage": "causal",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s6_tryfail_fresh_seed6_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s6_tryfail seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 6: try, fail, revise · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 112,
+     "what": "an attempt, its failure and the revised attempt. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .673 → .057 · web text +0.0003",
+     "probe_stage": "tryfail",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s6_tryfail_fresh_seed106_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s6_tryfail seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 6: try, fail, revise · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 113,
+     "what": "an attempt, its failure and the revised attempt. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .673 → .057 · web text +0.0006",
+     "probe_stage": "tryfail",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s7_mixed_fresh_seed7_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s7_mixed seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 7: the mixed stage · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 114,
+     "what": "the mixed stage's diet: the earlier stages' text beside ordinary prose. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .783 → .715 · web text +0.0000",
+     "probe_stage": "mixed",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s7_mixed_fresh_seed107_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s7_mixed seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 7: the mixed stage · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 115,
+     "what": "the mixed stage's diet: the earlier stages' text beside ordinary prose. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .783 → .717 · web text +0.0002",
+     "probe_stage": "mixed",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s8_register_fresh_seed8_d20261005_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s8_register seed A",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 8: register · seed A",
+     "status": "two seeds · one at a time · packaged",
+     "rank": 116,
+     "what": "the same content in different registers of speech. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .491 → .021 · web text +0.0003",
+     "probe_stage": "register",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    },
+    {
+     "path": "mini-beatrix-3/arm_refit/solo_4000/anchors/s8_register_fresh_seed108_d20261006_step4000.safetensors",
+     "step": 245674,
+     "name": "solo s8_register seed B",
+     "group": "solo arms",
+     "kind": "solo",
+     "family": "solo",
+     "title": "Solo arm · stage 8: register · seed B",
+     "status": "two seeds · one at a time",
+     "rank": 117,
+     "what": "the same content in different registers of speech. Trained alone on the frozen final core for 4,000 steps, kept quiet on web text; mount one solo arm at a time.",
+     "score": "own stage text .491 → .021 · web text +0.0002",
+     "probe_stage": "register",
+     "mount": {
+      "type": "anchor"
+     },
+     "base_model_id": "alephllm/mini-beatrix-3@step245674",
+     "template": null,
+     "decode": {
+      "temperature": 0.0,
+      "top_p": 1.0,
+      "rep": 1.0,
+      "precision": "fp32",
+      "why": "the solo arms were measured greedy in fp32"
+     },
+     "params": 13692960,
+     "sites": 32
+    }
+   ],
+   "lookup": {
+    "core": {
+     "craft": "mini-beatrix-3",
+     "step": 245674
+    },
+    "crafts": {
+     "mini-beatrix-3-la2-6-12-20": {
+      "order": 5,
+      "short": "first training",
+      "what": "the first training: 4,000 steps from the finished core on web text mixed with far-recall rows (a value planted behind text, asked for later)"
+     },
+     "mini-beatrix-3-la2-6-12-20-c249k": {
+      "order": 4,
+      "short": "continued",
+      "what": "the first training continued 4,000 more steps on the same mix"
+     },
+     "mini-beatrix-3-la2-6-12-20-deep1k": {
+      "order": 3,
+      "short": "deep-mix pilot",
+      "what": "the deep-mix pilot: 1,000 steps at Adam 1e-3 on recall rows laid out to fill the window exactly (one draw in four), distances to 3,600 bytes; the reads peaked at 254,000 and slid after it"
+     },
+     "mini-beatrix-3-la2-6-12-20-deep-ctrl": {
+      "order": 2,
+      "short": "deep mix, one layer (pair control)",
+      "what": "the deep mix at Adam 3e-4 from the pilot's 254,000, one attention layer per site: the depth pair's control"
+     },
+     "mini-beatrix-3-la2-6-12-20-deep-d2": {
+      "order": 1,
+      "short": "deep mix, two layers (pair structure arm)",
+      "what": "the deep mix at Adam 3e-4 from the pilot's 254,000, two attention layers per site (the second born at zero): the depth pair's structure arm"
+     }
+    },
+    "bare": {
+     "fetch_1024": 0.0,
+     "fetch_2048": 0.0,
+     "fetch_3400": 0.0,
+     "trials": 128
+    },
+    "reads": {
+     "mini-beatrix-3-la2-6-12-20": {
+      "246000": {
+       "fetch_1024": 0.0078125,
+       "fetch_2048": 0.0,
+       "fetch_3400": 0.0,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "247000": {
+       "fetch_1024": 0.015625,
+       "fetch_2048": 0.0078125,
+       "fetch_3400": 0.0,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "248000": {
+       "fetch_1024": 0.5,
+       "fetch_2048": 0.1875,
+       "fetch_3400": 0.015625,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "249000": {
+       "fetch_1024": 0.6015625,
+       "fetch_2048": 0.359375,
+       "fetch_3400": 0.109375,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "249674": {
+       "fetch_1024": 0.6171875,
+       "fetch_2048": 0.3359375,
+       "fetch_3400": 0.1171875,
+       "trials": 128,
+       "instrument": "battery"
+      }
+     },
+     "mini-beatrix-3-la2-6-12-20-c249k": {
+      "250000": {
+       "fetch_1024": 0.625,
+       "fetch_2048": 0.4140625,
+       "fetch_3400": 0.125,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "251000": {
+       "fetch_1024": 0.7265625,
+       "fetch_2048": 0.5,
+       "fetch_3400": 0.1640625,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "252000": {
+       "fetch_1024": 0.8203125,
+       "fetch_2048": 0.5390625,
+       "fetch_3400": 0.203125,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "253000": {
+       "fetch_1024": 0.734375,
+       "fetch_2048": 0.4609375,
+       "fetch_3400": 0.171875,
+       "trials": 128,
+       "instrument": "battery"
+      },
+      "253674": {
+       "fetch_1024": 0.875,
+       "fetch_2048": 0.59375,
+       "fetch_3072": 0.3671875,
+       "fetch_3400": 0.265625,
+       "trials": 128,
+       "instrument": "curve"
+      }
+     },
+     "mini-beatrix-3-la2-6-12-20-deep1k": {
+      "253750": {
+       "fetch_1024": 0.9296875,
+       "fetch_2048": 0.8671875,
+       "fetch_3072": 0.6484375,
+       "fetch_3400": 0.5703125,
+       "trials": 128,
+       "instrument": "curve"
+      },
+      "254000": {
+       "fetch_1024": 0.9765625,
+       "fetch_2048": 0.9375,
+       "fetch_3072": 0.8515625,
+       "fetch_3400": 0.8359375,
+       "trials": 128,
+       "instrument": "curve"
+      },
+      "254500": {
+       "fetch_1024": 0.890625,
+       "fetch_2048": 0.890625,
+       "fetch_3072": 0.765625,
+       "fetch_3400": 0.75,
+       "trials": 128,
+       "instrument": "curve"
+      },
+      "254674": {
+       "fetch_1024": 0.8984375,
+       "fetch_2048": 0.875,
+       "fetch_3072": 0.703125,
+       "fetch_3400": 0.6796875,
+       "trials": 128,
+       "instrument": "curve"
+      }
+     },
+     "mini-beatrix-3-la2-6-12-20-deep-ctrl": {
+      "255000": {
+       "fetch_1024": 0.9609375,
+       "fetch_2048": 0.9453125,
+       "fetch_3072": 0.90625,
+       "fetch_3400": 0.7734375,
+       "trials": 128,
+       "instrument": "curve"
+      }
+     }
+    },
+    "instrument": "the planted value's first byte, fetched from the given distance back (128 planted trials per gap; the dense curve where read, the byte battery otherwise)"
+   }
   }
  },
  "skipped": [
@@ -3801,5 +5616,6 @@
    "btx-e003-2s-EG-rnn-s1.b2a4@step61422.recurrent.pt",
    "local file not on hub"
   ]
- ]
-}
+ ],
+ "generated_v3": "2026-10-11 22:51 UTC"
+}

requirements.txt

@@ -4,4 +4,4 @@ safetensors>=0.4
 huggingface_hub>=0.24
 numpy
 geolip-alephllm @ git+https://github.com/AbstractEyes/alephllm@c6fff9fa3a9423a18d522635d8f2c666093d64c6
-amoe-lora @ git+https://github.com/AbstractEyes/amoe-lora@5c934cfcf3da90f073472d8c63ac6a30127854fd
+amoe-lora @ git+https://github.com/AbstractEyes/amoe-lora@9b1942d0ea865c0119655eb8315e73a2027a7682