Many Minds Architecture

1Where Many Minds sits in the single-mind UEMA architecture

The single-mind UEMA specification (UEMA_Spec_v3_5, Version 3.5, header date February 2026, status "Working Specification") defines one program: encoders, a forward model, prediction heads, wellness evaluators, a motor controller, intention by model inversion, a body schema and a training pipeline. The Many Minds source states that "every mind in the hierarchy is a complete instance of the UEMA core loop", so a single mind is the hierarchy with one member, and every Many Minds statement is a statement about several copies of that loop.

The Many Minds source amends Part VIII of UEMA Spec v3.4 (Sections 13–18, "Many Minds Architecture"). UEMA Spec v3.5 already carries those amendments, and cites "ManyMinds_Spec v2" and its gap resolutions by name (v3.5 Part VIII, §5.6, §7.4, §11.4, §20.5, §23.3 and §29.3). Its §18 records the hierarchy as "NOT IMPLEMENTED".

2The words this page uses

These terms appear from the next section on. Each is given once here; the glossary in section 15 repeats them with every other term.

3Design principles

The source: "The Many Minds architecture must follow the same philosophy as the rest of UEMA: capabilities emerge from prediction and wellness gradients, not from programmed protocols." Specifically:

• No hardcoded message types, alert enums or communication protocols.
• No explicit override or release commands.
• No ownership flags on motor channels. The source carries an open author's note here: "should maybe various levels of imagined wellness change help drive this? For example a sudden drastic negative change imagined. not sure."
• Inter-mind communication is learned, not prescribed.
• Motor control transitions emerge from attention and confidence, not from arbitration rules.

Why: UEMA v3.4 specified a fixed protocol (alert → urgency threshold → override → release). A fixed protocol is a rule written by an engineer, which the project's thesis excludes; v2 "replaces it with emergent dynamics grounded in prediction error and learned internal state sharing".

6One command from many minds

Several minds may produce a command for the same handle. This section gives the source's answer to how those commands become the one command the body receives, during training and during inference.

6.1 Motor control is confidence-weighted competition

A higher mind is any mind above another in the hierarchy (its parent, or the parent's parent); its wellness evaluators cover a wider scope of body sets and sensors than the lower mind's. There are no ownership flags and no override/release protocol. Every mind produces commands for its handles with a confidence, and control transitions follow from that:

• "Override" is not a command. The higher mind's PE rises in the lower mind's domain. The higher mind's commands for those handles become stronger and its confidence higher. The lower mind's own PE is also high there, so its confidence drops. In the blend of section 6.2 the higher mind's commands then carry more weight, through competition, not a flag.
• "Release" is not a command. When the situation has passed, the higher mind's commands for those handles fade (the source: "Its attention drifts elsewhere"), and the lower mind's steady-state commands carry the blend again because nothing competes with them.
• Ceding control needs no signal. The lower mind never receives a "you're overridden" signal; it keeps producing commands throughout, and they are outweighed only while the higher mind's commands for those handles are strong.

6.2 Combining wellness gradients and commands (Gap B, resolved)

The problem: when several minds compute wellness gradients for the same handles, a rule is needed to combine them. The source's resolution has two stages that run in different execution contexts.

Stage A, training: one unified system wellness gradient. All minds' wellness evaluations are summed into one scalar, W_sys, and one gradient is taken with autograd. By linearity of differentiation this equals the sum of the individual gradients, but no separate gradient vectors ever exist that would need a combination rule.

W_sys = sum(mind.wellness_evaluator(P_t, pe_i).sum() for mind in hierarchy.all_minds())
system_grad = torch.autograd.grad(W_sys, motor_commands, create_graph=True)[0]

Each motor controller is trained on the unified gradient. What it is meant to learn is when to yield (the parent's broader wellness is threatened) and when to act (only its own domain has signal). "Scope IS the weighting": when the parent's broader-scope wellness evaluators detect a problem, more of its channels are active, so it contributes more to the gradient; no explicit priority weighting is needed.

Stage B, inference: a confidence-weighted blend, forward pass only (no backward pass). For each handle h, over the minds whose handle set contains h:

weights_h = softmax([conf_i for mind_i if h in mind_i.handles] / temperature)
final_cmd[h] = sum(weights_h[i] * cmds_i[h] for i in competing_minds)

The confidence is the output of each motor controller's confidence head (single-mind spec §9.2). The softmax temperature should be per handle and learned. Whether higher minds actually produce the higher confidence on contested handles is "an empirical consequence of the training mechanism, not independently guaranteed at runtime".

Oscillation between minds is damped by three existing mechanisms: continuous physical inputs change smoothly; the context buffer gives temporal context; and fluctuating wellness produces low confidence, which triggers deeper imagination (temporal smoothing).

Contradiction resolved: UEMA v3.4's §17 (binary arbitration with override flags) is fully incompatible with this and is replaced entirely.

6.3 Attending-mind engagement: escalation without override

The attending mind is the present-world motor coordinator. The top mind has no handles and produces no command, so its influence on the body acts only through the attending mind's inputs: z_intermind, and through it the engagement signal below, not by entering the per-handle blend. The attending mind computes a learned engagement signal at every model step:

g_engage is a forward-pass quantity only: not a runtime wellness gradient, not an override flag, not a programmed protocol. The source intends it to raise, at the current model step, the attending mind's computation depth and coordination gain, and to lower the share of contested handles taken by routine lower-level commands (the two boxes above), for imminent danger, route-critical events or unstable novel tasks; it gives no formula for any of the three (section 12). The result is a continuous transition between guidance and strong re-engagement, without top-mind commands and without hardcoded override logic.

6.4 Disagreement between confident minds (Gap E)

Two minds may both be confident within their scopes and still pull behavior in different directions: a lower mind may be confident locally while a higher mind's wider-scope wellness channels score a larger consequence as bad.

• Training: resolved by Gap B. The single system wellness sum and its one autograd call give every motor controller a gradient that includes the higher minds' wellness channels, so a lower mind's commands are trained to change when a higher mind's wellness would fall.
• Inference: no runtime gradients; forward-pass quantities only. The higher mind's readable state, which reflects its lower wellness, travels through z_intermind and changes the receiving mind's latents, predictions, wellness predictor's estimate, confidence and command. Between the top mind and the attending mind the concrete path is g_engage (section 6.3): a large shift in the higher mind's state raises g_engage; a small shift leaves routine lower-level control largely undisturbed.

So disagreement is resolved by (1) unified wellness during training, (2) readable inter-mind state during inference and (3) learned attending-side engagement for the apex relation, "not by override flags, ownership rules, or runtime gradient combination".

6.5 Imagination scope is the higher mind's authority

When confidence is low the motor controller runs imagination (section 4.7): it predicts the consequences of candidate commands with the forward model, scores them with the wellness predictor, and picks the best. This is where the hierarchy matters most. Each mind imagines within its domain:

• Hand mind: candidate finger commands in, predicted tactile tokens out.
• Arm mind: candidate reach commands in, predicted proprioception tokens out.
• Top mind: a reach, grasp and lift sequence in, predicted total wellness over 30 model steps out.

The higher mind's advantage is not better motor execution; the lower mind is better at that, since it mastered the domain, which is why it was split off. The advantage is broader imagination scope combined with broader-scope wellness evaluators. The source's example: a driving mind can imagine "take exit → road curves → maintain lane", which domain-local wellness scores as fine; the higher mind can imagine "take exit → wrong destination → 30 minutes lost", which broader wellness scores as bad.

When a mind splits, the child gets domain-scoped wellness channels:

The parent keeps the broader-scope evaluators. The wellness predictor must also be per mind, trained to match that mind's wellness evaluators, so a lower mind's wellness predictor becomes specialized: good at scoring imagined grasps, poor at scoring imagined navigation decisions.

The higher mind does not need better commands to override. It needs a wellness gradient that points in a different direction from what the lower mind is doing. In UEMA the wellness gradient is the motor drive signal, so broader wellness scope gives a broader gradient and authority over the lower mind's narrower gradient. This is the source's §2.10; its later Gap B and Gap E resolutions (6.2, 6.4) use this gradient only in training, so at inference the higher mind's authority acts through z_intermind and the confidence blend. For the top mind this authority acts through z_intermind and attending-side engagement, not through top-mind commands.

6.6 Radius and hierarchy are complementary

Radius (section 2) and the mind hierarchy act on different dimensions. Radius is within-mind motor synergy: how far one command spreads to nearby joints, fine (radius → 0, a single fingertip) or gross (radius → 1, a whole-arm sweep), inside one mind's handle set. The hierarchy is across-mind coordination in time: the arm reaches, then the hand grasps, delegated in sequence and in parallel.

They compose: the Arm_L mind uses a high radius for gross reaching; the Hand_L mind uses a low radius for fine finger positioning. Neither has to learn the other's policy, and the inter-mind channel lets the hand pre-shape during the reach from the arm's motor intent.

7Splitting a mind

7.1 Splitting crystallizes stable weights

When a set of handles has near-zero PE and near-zero gradients over a sustained period, all of the mind's weights are copied into a new mind that takes over those handles (7.5). The parent's capacity is freed for new learning. The child's weights are already near-optimal, so "frozen" describes their state, not an imposed constraint.

7.2 What triggers a split (Gap C, resolved by a programmed trigger)

The single-mind spec's §15.1 defines a mastery detector (MasteryDetector), and MasteryTracker in curriculum.py:111-178 already implements its tracking logic with the same thresholds:

PE_THRESHOLD = 0.05       # mean PE below this
VARIANCE_THRESHOLD = 0.01 # PE variance below this
WINDOW = 50,000 steps     # evaluation window
CONSISTENCY = 0.95        # fraction of window meeting criteria

The tracker keeps a rolling window of 50,000 PE records, one per curriculum step in the released code (curriculum.py line 416), and checks these criteria for advancing the curriculum phase, so the trigger itself exists. The remaining gap is per-domain PE input: MasteryTracker receives one scalar, mean_pe, not per-handle or per-domain values. To support splitting it needs per-handle PE from the loss manager, so that mastery can be detected within a body region and not only globally.

7.3 Which handles go to the child (Gap D, resolved)

Domain boundaries come from the model's own learned coordination, not from predefined groups. The _get_domain_groups() dictionary of the Implementation Plan (an earlier planning document, not in this release) is removed, because a predefined grouping is a prescribed protocol, which the foundational constraint forbids.

Input

Per-handle PE over the mastery window; the body schema's EMA correlation buffers, correlation_matrix of shape [n_handles, n_handles × n_proprio_per_handle] in body_schema.py.

Computation

The revised find_mastered_domains(): (1) compute per-handle PE over the evaluation window; (2) keep the handles whose PE is consistently below threshold; (3) among those, cluster by motor-to-proprioception correlation, using simple thresholding on the correlation matrix (not spectral clustering or k-means), threshold a hyperparameter with initial value 0.6.

Output

Each correlated cluster, as a candidate domain for splitting.

The four sub-questions, answered:

1. Clustering algorithm: simple thresholding on the body schema's correlation matrix. Why it suffices: the body's physics makes the right handles correlate.
2. Kinematic chain constraints: emergent, not prescribed. Handles on the same kinematic chain show high motor-to-proprioception correlation because moving one moves the others through the skeleton. Thumb_L will never split away from Hand_L, because their activations are always correlated during grasping.
3. Several children at once: yes. If distinct clusters are found at the same time, all can split. The source expects this to be rare, because developmental constraints stagger mastery.
4. Minimum mind size: one handle. A low-PE handle whose correlation with every other handle stays below the threshold forms its own domain, for example the head handle used for gaze.

clone_for_domain(), the split function that UEMA v3.4 §15.2 calls but never defines, is resolved as a full deepcopy of the parent's weights (section 7.6). "for_domain" refers to domain-scoped wellness training, not architectural pruning; sensor scoping uses handle_set_to_sensor_scope() (section 7.7). Contradiction resolved: the Implementation Plan's §13.10 note 3 ("Domain groups are predefined, not discovered") is reversed; the plan itself had acknowledged it was a stopgap.

7.4 Splits follow kinematic chains

Any mind can split, not only the top one: the arm mind can split off a hand mind; the posture mind can split off a balance mind. Why: this gives anatomically meaningful hierarchies rather than flat clusters of skills. The source's growth example, step by step:

1. [Top] → all 23 handles.
2. [Top] splits off [Posture] (legs, feet, spine).
3. [Top] splits off [Arm_L] (UpperArm_L, LowerArm_L, Wrist_L and fingers).
4. [Arm_L] splits off [Hand_L] (Thumb_L to Pinky_L).
5. [Posture] splits off [Balance] (feet, ankles).

7.5 What is copied at a split

The child receives a complete instance of the core loop of section 4:

The parent keeps its full-scope versions. After the split:

• The parent's motor controller no longer produces commands for the child's handles. The source's reason: those handles' wellness gradients are near zero in the parent's broader-scope wellness evaluators, because the child keeps them in good state.
• The parent's forward model still predicts the full sensory stream, so it can imagine what the child's domain will do.
• The child's forward model is a full deepcopy of the parent's and keeps all 6 sense inputs, including global vision and audio.

7.6 The child's forward model and the top mind's imagination depth (Gap H, resolved)

The child receives a full deepcopy of the parent's forward model; no pruning is done at the split. It keeps all 6 sense inputs. Why: predicting the domain still depends on context outside the domain; a hand mind needs vision to predict contact, and a local controller may need broader body context to predict the sensory consequences of its commands.

Specialization therefore comes from training, not from cutting inputs or shrinking the model. The child's wellness channels are domain-scoped, so learning pressure falls on its own handles, body sets and sensory consequences; it uses the global senses as context while its role becomes more specialized to its domain. The parent keeps full-stream prediction. This resolves clone_for_domain(): clone means a full deepcopy; "for_domain" means functional specialization through domain-scoped learning.

Top-mind specialization is a separate question. After the apex split (section 9), the top mind diverges through longer imagination chains: the attending mind keeps the standard depth of 3–5 steps, while the top mind uses a larger per-mind depth (initial: 16+, subject to tuning). Imagination loss at those horizons is expected to bias it toward longer-timescale structure. Whether it does "remains an empirical question to validate"; the architectural definition of the child's scope is resolved.

7.7 Mapping a handle set to sensors (source §2.13 and Gap K, resolved)

A mind's motor domain is a set of handle indices, but its wellness channels and forward model also need to know which sensors belong to that domain. The mapping chain is: handle index → the handle's body set → that body set's sensors. The source states that this mapping already exists in the codebase; in this release that mapping is lem/model/body_sets.py (section 13).

The source's target function, which it states does not yet exist (the Python-side handle-to-body-set mapping, body_sets.py, is the foundation for it):

# TO BE BUILT — this function does not yet exist in the codebase.
def handle_set_to_sensor_scope(handle_indices: Set[int], handle_defs) -> SensorScope:
    """Given a mind's handle set, compute which sensor dimensions belong to it."""
    # handle_defs: one definition per handle, giving its body_set and bone_name
    body_sets = {handle_defs[i].body_set for i in handle_indices}
    bones = {handle_defs[i].bone_name for i in handle_indices}
    return SensorScope(
        body_sets=body_sets,
        bone_names=bones,
        # Tactile: filter patches by bone_hash ∈ bones
        # Proprio: filter entries by bone_index ∈ bones
        # Body set state: filter by body_set ∈ body_sets
        # Vision/Audio: always included (global)
    )

It runs once, at split time, and sets the scopes of the child's wellness channels listed in 6.5: tactile_comfort over the patches of SensorScope.bone_names, capability over SensorScope.body_sets, motor_state over the handles in handle_indices, and coherence over the body schema correlations of those handles only.

7.8 Starting the inter-mind channel (Gaps G and J, resolved)

Gap G (after a split the child cannot use inter-mind signals) and Gap J (the system goes from no inter-mind content to active inter-mind content) are the same cold-start problem at two scales. Three mechanisms remove it:

1. Pre-split self-reading. During single-mind training the one mind reads its own last hidden layer through the inter-mind channel instead of zeros, so the inter-mind encoder processes real activations from step 0. Its loss_weight is nonzero from the start (initial: 0.1). The target encoder of section 5.6 uses cross-attention with a learned identity embedding as query over projected states, which is not a trivial identity mapping. The current SelfAttentionPoolEncoder stub must be replaced or extended to accept the forward model's last hidden layer as input.
2. Deepcopy continuity. At a split the child is a deepcopy, so its internal state is nearly identical to what the parent produced for that domain; the token the parent reads from the child looks almost the same as what it read from itself. The distribution shift at the split is minimal.
3. Gradual divergence. After the split the child specializes and the parent keeps learning; their states diverge gradually, so both inter-mind encoders adapt through normal training without an abrupt shift. This holds for every split, including the top-mind split.

8Freezing and thawing

If freezing is natural (gradients go to zero when PE goes to zero), thawing should be natural too: gradients increase when PE increases because the domain changed. A mastered domain meeting novel conditions produces real PE and real gradients, and the mind adapts because there is something to learn again, not because a programmed trigger re-enables learning.

8.1 Optimizer mechanics (Gap I, resolved)

Ordinary gradient descent with no freeze switch (the source calls it "natural gradient dynamics"; it is not the natural-gradient method), with eviction of optimizer state to save memory. There is no is_training flag and no learning_rate = 0.0: a mastered mind has near-zero PE, produces near-zero gradients, and its weights stop changing.

Input

Each mind's gradient norm over the mastery detector's window (50,000 steps); each mind's PE.

Computation

If the gradient norm has stayed below threshold for the whole window, evict the mind's Adam optimizer state from GPU memory. The mind keeps running inference, computing wellness, producing commands and monitoring its domain; its weights do not update because the gradients are near zero. If PE rises (a novel situation), gradients become nonzero, the optimizer state is reinitialized with fresh Adam momentum, and training resumes.

Output

GPU memory freed while a mind is mastered; training restored when its domain changes.

The cost of the memory saving: reinitializing Adam loses its accumulated variance estimates, which can cause larger weight updates while the fresh estimates restabilize. Gradient clipping (grad_clip=1.0) bounds them, and the source considers this appropriate for a mind meeting novel conditions, where the old estimates were stale. So ordinary gradient descent is kept, and the memory optimization adds a small training discontinuity at thaw that uninterrupted dynamics would not have. Contradiction resolved: UEMA v3.4's §15.2 explicit freeze (is_training = False, learning_rate = 0.0) is replaced.

9The two-level apex: top mind and attending mind (Gap F)

The source's Gap F began as "left brain / right brain": should the first split be left/right or functional? Its answer: the architecturally important split is not between hemispheres but between attention to the present and broader thought, a present-world attending mind and a broader top mind.

• Top mind: broadest perception space; longest temporal horizon; deepest self-model (Levels 1 to 3, defined in the box below); no handles and no direct motor output; changes behavior only by shifting the attending mind's computation through z_intermind.
• Attending mind: full-body perception space of the present; its own grounded self-model; the present-world motor coordinator, responsible for navigation, situational judgment, route decisions, gaze allocation and overall coordination of the body; reads the top mind every model step through z_intermind.

Below the attending mind sits the motor hierarchy, whose shape comes from the correlation-based discovery of section 7.3. Child minds take mastered local domains, but the attending mind stays the coordinator for the present embodied situation.

The top mind can spend capacity beyond the immediate physical present only while the attending mind's PE is low enough that its engagement stays low. When the physical situation becomes urgent or unstable, the attending mind's high-PE state reaches the top mind's forward model through z_intermind, and the top mind reshapes present-world behavior at once by raising the attending mind's engagement through z_intermind. The question the source poses is "when does the system benefit from separating broad present-world coordination from broader long-horizon cognition?"

10Register of the source's gaps

The source numbers its open questions as Gaps A to K. Their state as the source records it:

"Resolved" in this table is the source's design status: a mechanism is specified. In the released code only two inputs exist: the mastery tracker's thresholds (Gap C) and the body schema's correlation buffer (Gap D's input). No gap's mechanism has run or been measured with more than one mind (section 13).

11What v2 removed from v1, and what it keeps from UEMA v3.4

Kept from UEMA v3.4 and compatible with v2:

• SensoryBus with shared broadcast of the sensory tokens (5 senses).
• Per-mind forward model over the shared tokens.
• Mastery detection (low PE and low variance over a window); trigger resolved as the programmed mastery detector of §15.1 (Gap C).
• InterMind encoder, reinterpreted as a reader of internal state, not a message encoder.
• Growth trajectory from one mind to a hierarchy, extended to allow splits below the top.
• Mind data structure core fields: mind_id, parent, children, depth, forward_model, motor_controller, wellness_evaluator, pe_history.

12Questions the source leaves open

Collected from the source and the later gap analysis; each is stated in the source at the place named.

1. Whether broader-scope minds produce the higher confidence on contested handles: "an empirical consequence of the training mechanism, not independently guaranteed at runtime" (Gap B). The per-handle learned softmax temperature is "Open for empirical validation" (gap analysis).
2. Whether longer imagination chains make the top mind specialize in longer timescales: "the highest-priority validation target for Many Minds experiments" (Gap H; gap analysis).
3. The scope of the coherence channel in a child: marked "scope unclear — Gap" in the source's §2.10 (6.5 here), while its §2.13 (7.7 here) states "body schema correlations for handles in handle_indices only".
4. Per-domain PE input to the mastery tracker (Gap C).
5. The correlation threshold for domain discovery, initial 0.6, a hyperparameter (Gap D); the self-reading loss weight, initial 0.1 (Gaps G and J); the top mind's imagination depth, initial 16+ (Gap H); the gradient-norm threshold for optimizer eviction, no value given (Gap I).
6. Whether imagined wellness change should help drive control transitions (the source's author's note, section 3 here).
7. What "wash out" means in cross-simulation attention (the source's author's note, 4.7 here).
8. The body of select_goal() (4.8; a Stream 4 feature, not a Many Minds prerequisite).
9. Why rising PE raises the higher mind's confidence on a handle but lowers the lower mind's, and how a parent produces commands for handles it stopped commanding at the split (sections 2.5 and 2.11 of the source do not say).
10. How g_engage acts: the source says high g_engage raises computation depth and "coordination gain" and reduces "domination by routine lower-level outputs on contested handles", but gives no formula connecting g_engage to the depth, to any gain, or to the blend weights of section 6.2; nor does it say what quantity "capacity beyond the immediate physical present" (section 9) names.
11. Which mind is the copy at the apex split. The gap analysis says "The top mind is the last split", but a split gives the child a set of mastered handles (7.3) and the top mind has none; neither document says whether the top mind or the attending mind is the new copy.
12. What one unit of the motor controller's depth is (4.6: "depth 1 ... depth 2 up to a maximum"), and whether it is the same quantity as the imagination depth of 4.7; the source uses "depth" for both.

13The specification and the released code

What the released Python code under Source/Python contains for each component, from files opened for this edition. A search of the whole tree for MindHierarchy, MasteryDetector, PerMindIntermindEncoder, SensoryBus, MotorArbitrator, handle_set_to_sensor_scope, find_mastered_domains, clone_for_domain and g_engage found none of them: the hierarchy, splitting, the blend and attending engagement are not implemented, which matches the single-mind spec v3.5 §18 ("NOT IMPLEMENTED").

14The two gap-analysis copies

The gap analysis exists as manyMindGapAnalysis.docx and manyMindGapAnalysis (4).docx. Both carry the same title page (status "In progress", March 2026) and the same figure. The copy named "(4)" is the later one: its internal file dates are March 30, 2026 against March 29; its wording is the wording of this source and of single-mind spec v3.5 where the two copies differ (g_engage, motor-to-proprioception correlation, the Adam thaw caveat); and it is the longer copy. This page uses the later copy.

The gap analysis names two products, ManyMinds_Spec_v3.md and UEMA_Spec_v5.docx; neither is in the released specification folder.

15Glossary

16Changes in this edition

Reordered

• The source's sections 2.1–2.13 and its gap entries are regrouped by topic: what minds share (5), combining commands (6), splitting (7), freezing (8), the apex (9). Each resolved gap now sits with the established idea it completes: Gap A with 2.9 (5.5), Gap B with 2.5 (6.2), Gap E after 2.5.1 (6.4), Gaps C, D, H, G/J and K with splitting (7), Gap I with 2.8 (8), Gap F as section 9.
• Section 2.9 (what the state contains) now precedes 2.4 (per-mind filtering). The source's section 2.13, placed before 2.12, is section 7.7.

Merged

• The Gap B text and the gap analysis's Gap B text, which repeat each other, appear once (6.2), with the gap analysis's additions in its box.
• The three statements that the child is a full deepcopy keeping all 6 inputs (2.11, Gap D, Gap H) are kept once in 7.5 and once, with the reason, in 7.6.
• The source's duplicate entry "Gap J — RESOLVED (merged with Gap G)" is folded into 7.8.

Left out

Passages that describe a body which is not part of this release are left out: the last two stages of the source's core loop (its output path to that body), the type names and the 23-row handle table of section 2.13, the handle number in Gap D, and the gap analysis's Figure 2.1, which is redrawn in 6.2. The rules for each sense are kept. The released handle-to-body-set map is lem/model/body_sets.py.

Added

• The setting, the source table, section 1 (relation to single-mind UEMA v3.5), the word list of section 2, section 10 (gap register), section 12 (open questions collected), section 13 (released code), section 14 (gap-analysis copies), the glossary.
• Eight diagrams: the whole architecture, one mind's loop, the inter-mind channel, the two stages of Gap B (redrawn), attending engagement, the split pipeline, the two hierarchy shapes, freezing and thawing.
• Input / computation / output blocks for the encoders, forward model, prediction heads, wellness predictor, wellness gradient, motor controller, planner search, body schema, per-mind filtering, domain discovery and optimizer eviction, built from the source's own statements.
• The "Gap analysis" boxes, from the later copy of the gap analysis.