# Chronomata: developmental computation

**Independent research assessment · 14 October 2026**

**Recommendation: build the simpler conventional baseline first.** A compact contextual construction recipe is a plausible representation. The scientific claim is whether developmental construction improves transfer or adaptation beyond an equally informed modular builder and ordinary function-preserving growth. The inspected evidence does not settle that comparison. Use a tiny Python intermediate representation (IR) as a common audit format, not as a new language project. If a baseline already provides the desired composition and growth, retain it. If experience-dependent rewiring becomes the real research question, reproduce or extend LNDP before inventing another system.

This report supplies a minimal semantic design, one executed engineering witness, and exactly two draft experimental protocols. Neither protocol was executed or preregistered. No neural architecture search, training, measured-model inference, GPU work, new agents, or Chronomata integration occurred.

## 1. Scope, hypothesis, and evidence levels

The delegated attachment requests an external assessment, not participation in the persistent-versus-episodic memory trial. The explicitly supplied workspace `developmental-workspace` existed but was empty and is used as the unused independent workspace. The active `primary-workspace` tree, its Git metadata, experimental state, databases, sessions, budgets, and research agent were not inspected or modified. The earlier dossier was not supplied: its status as a proposal with elementary algebraic checks is attachment-provided context, not independently verified evidence.

Split the central hypothesis into three falsifiable claims:

1. **Construction:** a fixed program produces executable heterogeneous systems at held-out component sizes without editing its runtime or inserting task solutions into it.
2. **Growth:** an explicit transfer map expands a particular parent while preserving declared interfaces and its old behavior at zero adaptation steps.
3. **Utility:** under matched information, historical training, search, and deployment resources, the construction or growth procedure improves a specified learning outcome over conventional methods.

Construction does not imply utility. Mathematical confluence, Turing completeness, a short syntax, and attractive geometry are not primary outcomes. Exact fractality is unnecessary for these claims.

| Evidence level | What would count | What would not follow |
| --- | --- | --- |
| Executable construction | Operators, parameters, state, scheduling, and valid ports execute together | An adjacency matrix alone is insufficient |
| Useful before task-specific learning | A frozen child solves an untouched task; all prior optimization is disclosed | Hand-coded task logic is not an emergent algorithm |
| Useful initialization | Faster acquisition than matched initializations | Better initial accuracy alone is not faster learning |
| Immediate inherited behavior | Paired parent/child outputs and trajectories agree before updates | A larger independently generated sibling is not that parent's descendant |
| Economical new capabilities | Added units contribute after adaptation, beyond continuation and ordinary growth | Duplicating a parent or raising total compute is insufficient |
| Structural repair / information recovery | Test topology restoration and retained/recovered learned information separately | Regrowth cannot reconstruct arbitrary erased information without a surviving information source |

The last statement is an information constraint: two parents with different memories can share the same recipe and topology. Regrowing from that recipe alone cannot identify which erased memory to restore.

## 2. Closest prior art and inspection record

All links below refer to primary papers or their institutional copies. Access and version checks were made on 14 October 2026. **Reported results are the authors' results, not reproductions.** “Methods” means selected relevant methods/results/limitations, not a complete-paper audit. No source code was inspected or executed.

| Primary source and inspected version | Depth | Already demonstrated or reported | Boundary relevant to this proposal |
| --- | --- | --- | --- |
| Daniel Coore, [*Botanical Computing*](https://pdos.csail.mit.edu/~micahbro/junk/coore-phdthesis%5B2%5D.pdf), MIT dissertation, 1999; [institutional record](https://dspace.mit.edu/entities/publication/4cf81485-211d-4329-b87a-6b5709922df7) | Methods: selected GPL overview, signal-guided growth example, implementation and reliability discussion | Growing points use local signals and compose interconnect patterns, including circuit layouts. | Strong precedent for developmental construction. It does not establish the proposed learning advantage. PDF text is partly corrupted; page screenshots were unavailable, limiting detailed verification. |
| Jean-Louis Giavitto and Antoine Spicher, [*Topological rewriting and the geometrization of programming*](https://www.sciencedirect.com/science/article/abs/pii/S0167278908001267), **Physica D 237(9), 1302–1314 (2008)**, DOI 10.1016/j.physd.2008.03.039; [author-copy PDF](https://citeseerx.ist.psu.edu/document?doi=a08b9f4f39c6f24f73dff1da760470c9e4c520d4&repid=rep1&type=pdf) | Methods: topological collections, transformations, application examples | MGS expresses rule-based local changes on spaces and combines several computational formalisms. | A contextual rewriting language is not novel by itself. Heterogeneous learning transfer and inherited trained-state growth remain separate questions. Publisher metadata retrieved through indexed title record; direct opening failed. |
| Elias Najarro, Shyam Sudhakaran, Sebastian Risi, [*Towards Self-Assembling Artificial Neural Networks through Neural Developmental Programs*](https://arxiv.org/html/2307.08197v1), arXiv **v1, 17 July 2023** | Methods: evolutionary and differentiable approaches, algorithms, task setup | Shared developmental networks control node replication and weights; generated networks perform classification/control tasks. | Not the independently varying typed-module transfer test proposed here. Its evolutionary algorithm schedules message passing using graph diameter: local messages do not imply exclusively local orchestration. |
| Erwan Plantec et al., [*Evolving Self-Assembling Neural Networks: From Spontaneous Activity to Experience-Dependent Learning*](https://arxiv.org/html/2406.09787v1), arXiv **v1, 14 June 2024** | Methods: LNDP implementation, optimization, results/discussion | Reward/activity-dependent rewiring and weight changes yield adaptive controllers. The implementation keeps hidden-node count fixed. | Closest adaptation precedent. Structural-plasticity models have more parameters than controls; high-dimensional scaling remains open. It is not a demonstrated function-preserving node-growth scheme. |
| Alexander Mordvintsev, Ettore Randazzo, Eyvind Niklasson, Michael Levin, [*Growing Neural Cellular Automata*](https://distill.pub/2020/growing-ca/), Distill **2020 web article**, no numbered revision shown | Methods: cell state/update, growth, persistence, regeneration | A shared learned local rule grows, sustains, and repairs trained image patterns. | Pattern regeneration does not demonstrate heterogeneous executable task interfaces or restoration of arbitrary learned memories. |
| Mykola Glybovets, Sergii Medvid, [*MorphoNAS*](https://arxiv.org/html/2507.13785v2), **v2, 24 March 2026** | Methods: genome, morphogens, differentiation, execution, graph/control results | Morphogen-based growth targets graph properties and produces small CartPole controllers. | Topology targeting is not algorithm discovery; inspected tests do not settle held-out module transfer. The arXiv record now reports publication in **Kibernetyka i Systemnyj Analiz 62(2), 2026**, updating the attachment's preprint description. |
| Sergii Medvid, Andrii Valenia, Mykola Glybovets, [*Activity-Dependent Plasticity in Morphogenetically-Grown Recurrent Networks*](https://arxiv.org/html/2604.03386v2), **v2, 15 June 2026**; record reports GECCO Companion/EvoSelf acceptance | Methods: characterization, random-RNN control, discussion/limitations | Anti-Hebbian benefit also occurs in random RNNs. Co-evolution improves fitness in none of the tested conditions. | Random controls match node/edge counts but differ in weight distribution; only 65 are competent. Alternative optimized encodings were not compared. Higher topology-dependent regret is sensitivity to tuning, not demonstrated economical adaptation. |
| Dániel L. Barabási et al., [*Complex computation from developmental priors*](https://www.nature.com/articles/s41467-023-37980-1), **Nature Communications 14, 2226 (19 April 2023)** | Methods: abstract, encoding and MNIST methods | Neuronal compatibility factors generate weights; compact parameterization supports computation and regularization. | A strong weight-generator comparator. It does not by itself demonstrate this proposal's local growth, heterogeneous contracts, or parent-state transfer. Reported highest hold-out accuracy during training requires care about validation/test separation. |
| Sergey Shuvaev, Divyansha Lachi, Alexei Koulakov, Anthony Zador, [*Encoding innate ability through a genomic bottleneck*](https://pmc.ncbi.nlm.nih.gov/articles/PMC11420173/), **PNAS 121(38), e2409160121 (2024)** | Methods: indexed primary full-text passages on compression, MNIST/CIFAR methods, transfer results | Alternating task training and genomic-network compression yields useful initial weights; transfer benefits depend on the problem. | Generated weights carry previously acquired training information. MNIST-to-Fashion-MNIST transfer did not improve. This is not zero-information innate discovery or a demonstration of local, heterogeneous growth. Direct publisher/PMC fetches were access-limited. |
| Rasmus Berg Palm, Elias Najarro, Sebastian Risi, [*Testing the Genomic Bottleneck Hypothesis in Hebbian Meta-Learning*](https://proceedings.mlr.press/v148/palm21a.html), **PMLR 148:100–110 (2021)**, [paper](https://proceedings.mlr.press/v148/palm21a/palm21a.pdf) | Methods: shared-rule formulation, results and post-hoc diagnosis | Joint optimization of shared Hebbian rules and their synapse assignments performed poorly in the tested settings. | Direct warning that compression can make optimization harder. A bottleneck is not automatically a useful regularizer. |

Absence of a demonstrated result in inspected sections is a limit of this assessment, not a claim that every later extension lacks it. No biological morphology result is used as evidence of machine-learning performance.

### Comparison families that could dissolve the novelty claim

| Family / original source verified | Closest capability | Most threatening comparison |
| --- | --- | --- |
| CPPNs: Kenneth O. Stanley, [original 2007 paper](https://link.springer.com/article/10.1007/s10710-007-9028-8), **8:131–162**, publisher abstract. HyperNEAT: Stanley, D'Ambrosio, Gauci, **Artificial Life 15(2):185–212 (2009)**, [original-paper copy](https://www.ncheney.com/teaching/robotics_readings/AHypercubeBasedIndirectEncodingForEvolvingLargeScaleNeuralNetworks%28StanleyDAmbrosioGauci2009%29.pdf), selected substrate methods | Coordinate-conditioned repeated and varying structure without a local developmental rollout | Give a CPPN the same coordinates, operator inventory, task metadata, optimization and decoding cost. If it transfers equally well, local development is not necessary. |
| Graph grammars: Ehrig, Pfender, Schneider, [*Graph-grammars: An algebraic approach*](https://cris.fau.de/publications/121104104/?lang=de_DE), **SWAT 1973:167–180**, DOI 10.1109/SWAT.1973.11; institutional abstract/record | Explicit graph derivations and embeddings | A typed production grammar with the same rewrite choices and resource limits. Primary full-paper retrieval failed; no detailed theorem claim is made here. |
| Parameterized modular builder, specified in this report | Functions taking sizes and a port manifest emit heterogeneous modules and adapters | **The primary baseline.** Give it all public conditioning, shapes, local signals if useful, state-transfer primitives, and equal tuning effort. A Python loop can already compactly construct many sizes. |
| Chen, Goodfellow, Shlens, [*Net2Net*](https://arxiv.org/html/1511.05641v4), **v4, 23 April 2016**, selected function-preserving/widening methods; Wei et al., [*Network Morphism*](https://proceedings.mlr.press/v48/wei16.html), **ICML/PMLR 48:564–572 (2016)**, abstract | Transfer a trained network into a larger function-preserving network | Copy-and-split widening and an isolated, zero-readout new branch. Preservation must be checked for our operators and recurrent schedule, not borrowed as a universal theorem. |
| Ha, Dai, Le, [*HyperNetworks*](https://arxiv.org/abs/1609.09106v4), **v4, 1 December 2016**, abstract | Learn a compact generator of another network's weights | A size/context-conditioned weight generator using the same training history, output topology, effective parameters, and generation cost. Weight compression alone does not make developmental dynamics necessary. |

The modular builder is an explicitly designed comparator, not a literature claim attributed to a nonexistent original publication.

### Contribution-by-contribution assessment

| Proposed contribution | Closest existing capability | Untested discriminator / threatening baseline | Contribution remaining |
| --- | --- | --- | --- |
| Shared local rules differentiate cells | GPL, MGS, NCA, NDP | Same boundary cues and roles supplied to a conventional builder | Expressibility and implementation clarity; not broad novelty |
| Heterogeneous modules compose at new sizes | MGS supplies composition; builders supply size parameters | Independently vary memory and routing sizes, freeze generator and adapters; compare matched builder | A narrowly specified transfer result could remain |
| Small recipe produces useful computation | NDP, compatibility encodings, genomic compression, HyperNEAT | Match interpreter information, historical training, and conditioned weight generator | A practical encoding contribution; utility must be measured separately |
| A grown child retains its parent's behavior | Net2Net/network morphism | Same-parent ordinary preservation with identical state and scheduling contracts | A valid transfer rule for a specific operator family; no special developmental claim yet |
| Growth yields economical new capabilities | LNDP and ordinary growth offer relevant mechanisms | Compute-matched continuation, ordinary growth, same-topology random child, added-capacity ablation | Possible causal benefit only if development beats these controls |
| Regrowth repairs acquired knowledge | NCA establishes structural/pattern precedent | Erase different memories while preserving the same recipe | No general memory-recovery contribution without a declared surviving store |

These are assessments, not claims of exhaustive novelty clearance.

### Strongest objections

**The interpreter can contain the discovery.** Report the genome, runtime code/constants, seed, public cues, operator definitions, learned generators, inherited checkpoints, and task conditioning separately. A fixed task-specific table in the runtime invalidates a “compact genome discovered the task” claim. Code length, learned scalar count, and information content are different quantities; count precision and do not infer an information-theoretic bit bound from parameter count alone.

**Locality can be superficial.** Count signal propagation, neighbor discovery, candidate-pair enumeration, compiler passes, global arbitration, and normalization. Local rule predicates with a global scheduler are a legitimate design, but must be described that way. A diameter-based rollout or an all-pairs edge proposal can dominate cost.

**Shape compatibility can conceal behavioral failure.** Equal-sized ports can carry logits versus probabilities, sums versus means, or differently delayed values. A new branch can change feedback, fan-in normalization, or reset timing without a type error. Require declared meaning, boundedness, and execution tests.

**Preservation can prevent new capacity from doing work.** Exact copies can remain symmetric; permanently closed gates never contribute. Isolate preservation at step zero from the later optimization that opens a branch. Removing new units after adaptation must harm the new task if extra capacity is credited.

**The search bill can overwhelm reuse.** Count failed candidates, manual selection after validation feedback, inherited training, compilation, developmental messages, evaluation ticks, and adaptation. Show cold-start and amortized costs for declared numbers of uses. A smaller genome may generate a model with more parameters, state, ticks, or memory.

**A weak control can manufacture an advantage.** Match weight distribution, degree, active operators, tick count and timing; include the same-child-topology control and ordinary builder. Do not select only competent developmental networks but use an unconditional random control, or infer a development-specific mechanism from generic recurrent dynamics.

## 3. Smallest meaningful semantic design

### 3.1 Objects and information accounting

Use dataclasses, tuples, dictionaries and a serialized manifest. No parser, new compiler framework, dependency ecosystem or general-purpose language is needed.

```text
develop_R(g, s0, e, B)
  -> (cells, E_dev, E_exec, operator_types, parameters,
      initial_execution_state, schedule, external_ports,
      optional_learning_rules, provenance_and_costs)
  OR an explicit failure record
```

**R** is the frozen interpreter: primitive implementations, rule-observation restrictions, proposal validation, conflict policy, parameter initialization, scheduling and transfer operators. Hash it before evaluation. **g** is the ordered rule data and its numeric constants; it cannot redefine R on a test task. **s0** supplies an undecided seed, initial developmental state and lineage. **e** supplies an explicitly public boundary/port manifest, positions or local adjacency, tensor dimensions, declared role cues if used, and a random seed. It contains no task targets, undisclosed connectivity template, trained checkpoint, or held-out permutation. **B** caps nodes, developmental and execution edges separately and jointly, developmental observations/messages/ticks, execution ticks, parameter/state bytes, and compiler work. Exceeding a cap produces failure, not a silent partial model.

Count separately: bytes/scalars in g; R and its primitive library; seed/cue/port-manifest size; generator weights; generated independent and tied parameters; inherited checkpoint/optimizer state; transient messages and activations. A shared rule copied into every cell is one stored program but many executed applications. Immutable tying reduces independent degrees of freedom, not necessarily execution or activation cost.

### 3.2 Cells, operators, and local observation

A cell contains a stable lineage address, position/neighbor handles, phase, developmental state, typed input/output ports, operator tag, parameters, execution state and an optional declared learning-rule tag. Developmental state and execution state are distinct stores. Neither cell IDs nor parent pointers may secretly index a task solution.

The executed witness supplies just **Scale** and **LeakyAccumulator**. Scale computes `u = a*x`, has no temporal state, and is a special case of an affine operator. LeakyAccumulator computes `h_next = lambda*h + (1-lambda)*u` for `0 <= lambda < 1`. It has explicit vector state. These are genuinely different computations. The accumulator is a hand-designed memory primitive available to every baseline, not discovered memory.

The future protocols additionally require an openly declared **dense affine operator with specified elementwise nonlinearity** and a **gated accumulator** `h_next = (1-w)*h + w*z`, with `w` clipped or sigmoid-mapped into `[0,1]`. All conditions get exactly these operators, their initializers and numeric precision. Dense matrices and gating are substantial runtime information. They are specifications here, not implemented extensions of the witness.

A proposed rule can observe its own developmental state/phase, its lineage if declared, one-hop neighboring port offers, bounded local signals from the preceding tick, and boundary cues attached to its site. It cannot read the global graph, total target topology, task labels, arbitrary remote states, or a pretrained model through a “local” handle. Repeated message passing can convey distant information, but every hop, byte and tick is charged. The witness observes its own cell, own cue and adjacent occupied positions; it does not inspect neighboring execution values or global counts.

Allowed proposed actions are bounded own-state updates, adjacent replication, differentiation into a registered operator, connections to observed compatible ports or a just-created child, pruning of an incident connection, and phase transition. Arbitrary graph mutation is outside the rule API. The witness implements only differentiation, one adjacent child and its parent-child connection. Pruning and arbitrary rewrites remain unimplemented design fields.

### 3.3 Two edge sets and update order

`E_dev` transports developmental messages; `E_exec` transports task tensors. They can share endpoints while remaining separate channels, storage and charges. Development ends before task execution in the initial design. Keeping developmental signaling alive during execution is a distinct intervention that would require matched controls and accounting. The witness has one edge in each set; no developmental messages are used to solve its numeric example.

Proposed R uses synchronous snapshot/proposal/commit ticks:

1. Snapshot developmental cells and deliver messages from the preceding tick.
2. Each cell evaluates the ordered shared rules; first matching rule wins.
3. Validate local action scope, port types, occupancy and resource use.
4. Resolve proposals in declared lineage/action order; reject incompatible overlapping structural proposals as a recorded construction failure. Apply accepted nonconflicting proposals atomically. A newborn first acts on the next tick.
5. Stop after quiescence and contract validation. If quiescence is not reached under B, return failure.

The runtime's cap check and conflict arbitration have a global view; rule predicates do not. Ordering is reproducible and is not a claim of mathematical confluence or a fully distributed implementation. The witness rejects site collisions. An asynchronous or stochastic variant would be a separately versioned runtime: freeze scheduling distribution and derive pseudorandom draws from run seed, lineage, tick and action key, not wall time or a mutable global random stream. The witness is deterministic and uses no random draws.

At execution, topologically order zero-delay edges within each external input step. Commit recurrent state once after all required inputs are ready. Feedback must have declared positive delay and an initialized buffer; reject zero-delay cycles. The witness supports only Scale followed by LeakyAccumulator, with the accumulator's recurrence internal to its cell. It has no intercell feedback implementation.

### 3.4 Interface and dynamical contracts

| Contract field | Minimum declaration / enforcement |
| --- | --- |
| Shape and dtype | Symbolic width bound to a public integer, axis meanings, precision; no implicit broadcasting or silent padding |
| Direction | Producer output to consumer input; required ports have declared producer cardinality |
| Aggregation | Single, sum or mean explicitly; fan-in count and normalization are frozen and charged |
| Meaning | E.g. raw feature, scaled feature, probability, logit, gated-write value; equal shapes do not erase these expectations |
| Timing | External clock, within-step dependency, edge delay, and state-commit phase |
| Reset/carry | Episode reset, across-step carry, growth-pause state mapping, and delay-buffer treatment |
| Dynamics | Declared input/output ranges or Lipschitz/stability assumptions, plus operator-specific tests |

Public shape offers let adjacent modules instantiate an explicit affine adapter from width m to width r. The adapter's matrix, initialization and cost are counted; it cannot be a task-specific solution table. Independently varying m and r must be supported by the same frozen rule, not by enumerating test pairs in R. A semantic tag is an assertion checked at declared boundaries, not a proof that learned internal features have identical meanings.

For the witness, single-source float64 vectors have zero intercell delay and one external-step clock. Its internal edge means “scaled-feature”; the public output means “low-pass-feature.” For bounded input magnitude X, gain a, zero initial state and `0 <= lambda < 1`, the recurrence has magnitude at most `abs(a)*X`; sensitivity to initial-state error decays as `lambda**t`. This follows directly from the displayed recurrence. Adding feedback would require a new analysis; compatible tensors do not imply stability.

### 3.5 Differentiation and symmetry

Shared rules produce different roles because cells receive different declared cues or inherited developmental state. Here the source site has cue `source`, its adjacent child site has cue `memory`. The same genome is interpreted in those two contexts. Those cues already encode role information and must be supplied to the ordinary builder too.

Identical states and neighborhoods under deterministic equivariant rules remain symmetry-equivalent by induction over ticks. A role cannot appear solely because a cell happens to be earlier in a Python list. Boundary cues, lineage-dependent rule branches, signal gradients, or seeded randomness can break symmetry; each is information supplied to the construction process and must be disclosed. The witness's role decision ignores lineage and its identical-observation check returns identical proposals.

### 3.6 Replication, refinement, and inheritance

Fresh construction initializes execution state to zero and parameters from declared constants or a seeded initializer. A fresh larger sibling receives no learned parent information merely by sharing g.

For an actual parent, growth takes `(parent manifest, parameters, state, delay buffers, optimizer state policy)` and a declared transfer map T. Growth is paused at a specified external-step boundary. The map must say which old values copy, split, reset, or change. For the witness's accumulator, duplicating its parameter and current state and taking the **mean** of the two outputs preserves its trajectory under the same inputs. Taking their sum changes its output. Identical duplicates provide no demonstrated new capability.

A useful conventional starting point is an additional branch whose readout weights are zero and whose internal features are nonzero. Copy the old branch and its state unchanged, keep new-to-old feedback zero, and keep old normalization/scheduling unchanged. At step zero the output is exactly the old output. A trainable linear readout can receive gradients from nonzero new features; after it changes, those features may contribute. Permanently closing both the readout and its learning path does not establish usable capacity. This is a proposed operator-specific construction, not an executed learning result.

For a deterministic elementwise recurrent network `h_next = sigma(W*h + U*x + b)`, a widening map pi with multiplicities c has the candidate transfer:

```text
h_child[j] = h_parent[pi(j)]
U_child[j,:] = U_parent[pi(j),:]
b_child[j] = b_parent[pi(j)]
W_child[j,k] = W_parent[pi(j),pi(k)] / c[pi(k)]
V_child[:,k] = V_parent[:,pi(k)] / c[pi(k)]
```

Grouped sums then equal the parent sums, and elementwise activation preserves the copied-state invariant at each tick in exact arithmetic. This is our restricted derivation inspired by ordinary widening, not a claim that the original papers established arbitrary recurrent-module preservation. Normalization across units, stochastic masks, altered delays, extra commits, finite-precision summation and arbitrary learning rules can invalidate it. Report zero-step error before introducing symmetry-breaking perturbations. Optimizer moments are reset in all grown/continued arms for the primary comparison; retaining them is a separately matched secondary analysis.

### 3.7 Executed transparent example

The complete bounded witness is in [checks.py](checks.py); recorded output is in [check_results.json](check_results.json). Every cell receives these ordered data rules:

```python
g = (
    Rule(cue="source", operator="scale", parameter=2.0, replicate_offset=1),
    Rule(cue="memory", operator="leaky_accumulator", parameter=0.5),
)
s0 = Cell(lineage=(0,), position=0, width=2)
e = {0: "source", 1: "memory"}
```

Tick 1 differentiates the seed and creates an undecided adjacent child. Tick 2 differentiates that child. Tick 3 observes quiescence and validates the model. The executable path is `raw-feature -> Scale(2) -> LeakyAccumulator(0.5) -> low-pass-feature`. The model contains two operator types, parameters, a zero initial state, an explicit schedule and ports, plus separate developmental/execution edges.

| External step | Input x | Scaled u | Output/state h |
| --- | --- | --- | --- |
| 1 | `[2, -2]` | `[4, -4]` | `[2, -2]` |
| 2 | `[0, 4]` | `[0, 8]` | `[1, 3]` |

**Executed result:** 17 checks passed. They cover numeric composition, deterministic construction, separate edge accounting, carry/reset behavior, cap failures, missing cues, shape/semantic/delay errors, invalid numeric input, symmetry, explicit state duplication with mean readout, the naive-sum counterexample, erased-state nonrecovery and widths 1/3/8. Varying a common width is not Experiment 1's independently varying component-size transfer.

The successful process used about **14.7 MiB peak RSS**, **0.0402 seconds process CPU**, and **0.00067 seconds for the check body**. One worker, a 30-second wall alarm and CPU cap, an outer 40-second timeout, and finite node/edge/tick/vector/sequence bounds were used. Darwin rejected the requested address-space limit; the memory ceiling was instead checked using measured whole-process RSS and bounded structures. JSON records this limitation and two earlier startup failures (Python 3.9 annotation compatibility and the rejected memory-limit request), both before checks ran. All attempts and artifact validation were small local operations, well below five minutes; no substantial workload or dependencies were installed.

The witness establishes only expressibility and engineering behavior. It has no training, learned generator, growth search, arbitrary pruning, intercell feedback, or general-purpose graph engine. It does not reproduce any cited experiment.

## 4. Shared protocol rules and accounting

Everything below is a **draft specification requiring a separately authorized pilot**. The pilot must resolve variance, independent replicate count, sample size/power, attainable task difficulty and finalized decision margins before any confirmatory freeze. No numerical sample size is asserted here. Provisional resource ceilings bound a proposed pilot, not authorization to run it.

Both protocols use a synthetic **last-write-and-route** task. Each episode starts with a zero bank of K values. WRITE events replace one address with an independent bit `v in {-1,+1}`. QUERY events supply context c and route index j; the target is the last value at address `pi_c(j)`, or zero if unwritten. Each context's pi is an independently sampled permutation over K addresses. Targets are available to the task learner during calibration/training, never to developmental rule observations. The same event streams, feedback, public dimensions and calibration budgets are supplied to every condition.

Use a fixed maximum external schema with eight address and eight context positions plus WRITE/QUERY flags, write address/value and requested route. Inactive positions are masked in every arm. Knowing this upper schema bound is disclosed: tests extrapolate beyond development sizes within an announced finite domain, not to unbounded scale. Initialize each address before scored queries so targets are balanced signs. Generate 128-event episodes, reserve at least half the events for queries, sample intervening writes and overwrite repetitions, and stratify scored queries by last-write delay (1–8, 9–32, 33–64 events). Choose scored queries only from addresses with a last-write age of 1–64 events; refresh an address if none is eligible. Freeze the per-bin sampling weights and report realized counts. Reinitialize bank and model state at episode boundaries. All conditions predict before feedback on the event; no teacher-forced target can enter recurrent state before prediction.

Development/calibration use K,C in `{2,3,4}`; validation includes 5 without confirmatory evaluation; transfer tasks use fresh permutation seeds and, as a separate increased-demand stratum, K,C in `{6,8}`. To isolate scale from task difficulty, primary scale tests keep K=C=4 while varying component widths. Episode/event seeds are disjoint across development, validation, calibration and scored tests. Calibration and scored episodes can share a task permutation, but not event realizations. Freeze the event generator, delay distribution and seed derivation before testing. An exact symbolic bank plus permutation oracle checks target generation only; it is not credited as discovered developmental computation.

Task learning is part of the declared experiment. Pre-adaptation performance, feedback-based acquisition and construction validity are separate measurements. A network grown without seeing a new random permutation cannot be assumed to know it. Role cues and memory/gating primitives give substantial inductive bias to every arm.

| Resource item | Matching / reporting requirement |
| --- | --- |
| Operator inventory and metadata | Same primitives, precision, masks, dimensions, conditioning, boundary cues and transfer operators |
| Generated capacity | Match target widths, active operator counts, independent/tied scalars, degree/edge counts where applicable, and persistent-state bytes; report realized totals |
| Time within a task | One declared external update per event; count every internal operator evaluation, message and recurrent tick |
| Data exposure | Log every labeled event in search, parent training and adaptation; scored episodes never feed optimization |
| Construction/search | At most 32 candidate configurations per condition in a provisional pilot; charge unsuccessful evaluations and manual revisions informed by scores |
| Candidate selection | Provisional aggregate ceiling of `2**18` labeled development events and `10**9` scalar multiply-add equivalents per condition; deterministic validation rule; record selection exposure separately |
| Development/compilation | Provisional model ceilings: 64 computational cells, 1,024 edges in each channel set, 64 developmental ticks; cap messages, bytes and compilation wall time in the pilot manifest |
| Test adaptation | Joint ceiling of `2**15` labeled events and `10**8` scalar multiply-add equivalents per model/task; stop at the first ceiling reached |
| Evaluation and memory | Same held-out episodes; log evaluation compute, parameter/optimizer/activation/message bytes, peak resident memory, and compilation latency |
| Historical cost | Include generator selection and parent training; no “free” inherited checkpoint or pretrained primitive |
| Amortization | Report cold cost, per-child/per-event cost, and totals for U=1,10,100 declared deployments; break-even reuse only if empirical cost differences permit it |

A multiply-add ledger does not capture all interpreter/communication cost. Report CPU wall time and bytes as well. First compare models at matched inventory and state budgets, then present data-matched and compute-matched learning curves. A condition does not receive extra labels just because it is cheaper. If resources cannot simultaneously match, show the tradeoff and narrow the claim rather than compressing all costs into one misleading number.

All drafts must specify actual message/byte/wall ceilings and replicate count before execution. Missing pilot resources mean retaining these specifications, not launching a larger workload.

## 5. Experiment 1: contextual development and heterogeneous interface transfer

**Question.** Does frozen contextual construction transfer executable memory/routing compositions to independently varied component sizes better than an equally informed ordinary builder?

**Design and freeze.** Construct a memory module of width m and a routing module of width r from the common operator library, with explicit adapters and timing. During development use the full Cartesian product `m,r in {4,8}`; validate only on `{4,8,12}` pairs including 12. Freeze R, g, initialization, adapters, selection rule and learner before inspecting tests. The primary held-out-size grid is `m,r in {4,8,16,24}` with at least one component in `{16,24}`: this tests memory-only changes, routing-only changes and both together. Neither held-out width appears in development or validation. Do not substitute a separate g for each pair.

The primary task stratum has K=C=4 and fresh permutations, so larger models are not confounded with harder tasks. The secondary increased-demand stratum uses K,C in `{6,8}` with both one-factor and two-factor changes. Report this stratum separately, with an explicit unknown-task calibration phase. Publish actual operator counts: m/r are tensor widths, not a claim that node count alone matches compute.

**Conditions.** Use the contextual developer; the parameterized modular builder; and a matched typed graph control sampled under the same operator counts, edge/degree inventory, parameter distribution, adapter shapes, timing and resource caps. The builder receives all public size/role information and may generate the same adapters with ordinary loops. Include two context/type ablations: remove or shuffle role cues while preserving the public input schema, and replace semantic matching with shape-only matching while retaining crash safety and numeric bounds. Also test single-type substitution if parameter/state/MAC matching is feasible; otherwise report that mismatch instead of treating it as a clean causal ablation. CPPN or weight-generator controls are follow-up comparators only if the core three-way result survives; they are not a third experimental campaign here.

**Information policy.** Development receives port offers, public dimensions, permitted cues and its fixed initial state, not permutation labels or feedback. Each task learner receives identical calibration examples and labeled events. All arms receive the same hand-designed gated memory. Test learning adapts model parameters, not R/g/adapter definitions; any learned generator's optimization must finish before test freeze.

**Primary outcome.** Mean final held-out query-sign accuracy under the joint adaptation ceiling, macro-averaged equally across the held-out-size grid and task manifests. A construction failure or invalid/nonfinite execution gets score zero in the unconditional outcome. Report interface-valid fraction independently and report conditional task accuracy as a secondary measure; never remove invalid constructions to inflate performance. Construction validity includes ports, finite bounded execution, termination and correct clocks/reset behavior; it does not imply correct task answers.

**Additional outcomes.** Zero-adaptation accuracy; acquisition curves at the declared data/compute checkpoints; validity by failure class; reset/carry tests; latency, signal traffic, effective parameters and state bytes; context and type ablation differences. A mean improvement concentrated in one large width pair must be visible in the per-pair results.

**Replication and analysis.** Pair conditions on task/permutation/event seeds. The independent unit for a fixed hand-authored generator is an independently trained model/task-manifest replicate, with episodes and width pairs nested within it. If generator optimization is used, independently selected generator runs are the outer replication unit. Do not count cells, queries or sibling widths as independent generator discoveries. Estimate uncertainty using that outer clustering and show task variation. Sample size, power and number of outer runs remain unresolved pending a pilot.

**Confounds and controls.** Public cues may already specify decomposition; arbitrary adapters may encode the solution; graph controls may differ in weight distribution or path length; developmental training may consume more feedback; width increases may alter fan-in or effective ticks. Equalize or explicitly stratify these. Validate the task oracle on overwrites, long delays and all route contexts. The exact bank oracle identifies a task ceiling and prevents accidentally grading storage alone without routing.

**Exclusions and stopping.** Exclude only predeclared corrupted inputs, oracle bugs, or independently documented infrastructure failures affecting a pair; fix and rerun the pair without changing the frozen methods. Poor learning, invalid construction and resource exhaustion are outcomes, not exclusions. Complete the fixed pilot matrix up to its resource cap; stop for deterministic contract/oracle violations before learning. Do not expand grids or candidates after seeing a promising test cell. Confirmatory replicate counts and stopping rules must be frozen after pilot variance estimates, not adapted to significance.

**Go/no-go.** First require valid construction across every target pair. That grants engineering feasibility only. Proceed toward a developmental utility claim only if it improves unconditional accuracy over both core controls under the declared resource envelope, with a pilot-finalized meaningful margin and clustered uncertainty, and the context/type intervention explains the effect. A provisional margin is two percentage points; it must be finalized before confirmatory testing. If the builder matches the result, use it and report that developmental rollout was unnecessary for this task. A control failure caused only by denied public information is not a go result.

## 6. Experiment 2: inherited growth and useful new capacity

**Question.** Can developmental growth improve economical acquisition of new task demands beyond ordinary preservation-based growth from the same trained parent?

**Parents and held-out boundary.** Train common parent architectures at `(m,r)=(8,8)` on old tasks with K=C=4. Parent training uses disjoint development manifests and the same historical resource ceilings. Determine learner/growth policies on `8 -> 12` transformations only, then freeze. Test child widths 16 and 24 with memory-only, routing-only and joint growth. These transformations are absent from policy selection. Increased-demand tasks introduce new contexts/permutations and K,C in `{6,8}`; preserve a fixed old-task evaluation set of fresh episodes. Use the same maximum external schema before and after growth so changing output labels or input dimensions cannot masquerade as retention failure.

**Paired interventions.** For each parent checkpoint create:

1. **Continue parent:** same architecture, further adaptation.
2. **Ordinary growth:** explicit function-preserving widening or isolated zero-readout branch; use the supported operator/state transfer and unchanged old schedule.
3. **Developmental growth:** frozen local rewrite policy and explicit T; no regeneration from a seed in place of inherited state.
4. **Same-child-topology/random initialization:** the developmental child's topology and schedule, with fresh parameters/state and no parent information.
5. **Target-size normal training:** conventional target-size model from scratch, trained on the parent's old training stream followed by the identical adaptation stream under a matched total historical data/compute envelope.

For the primary causal comparison, arms 2 and 3 receive identical parent weights, state snapshots, new-branch initial random seeds, old/new training mixture and optimizer reset policy. Wherever possible ordinary growth also receives the developmental child's final topology with the ordinary transfer map; this isolates development from merely selecting a better topology. If the proposed developer just implements the same ordinary map on the same graph, predict equality and report an engineering implementation, not a new growth mechanism.

**Zero-step retention.** Pause growth between external events. Evaluate both episode-reset and live carried-state settings before any updates or calibration feedback. Restore parent state into every arm according to its policy, including delay buffers. Compare old-task predictions, maximum output error, accuracy, and trajectories over bounded long sequences. The draft numeric tolerance is `1e-6` for matched float32 operator schedules; report exact-arithmetic preservation arguments separately from finite-precision measurements. No post-growth fine-tuning may precede this test. Parameter transfer alone does not certify state retention.

**Adaptation stream and capacity test.** Feed all arms an identical shuffled 50:50 mixture of old-task and increased-demand episodes, with feedback only after prediction. Evaluate old and new tasks at fixed resource checkpoints, never train on scored episodes. After adaptation, remove the added branch or clamp added state to its declared initial value, keeping the old path, timing and normalization unchanged. Compare to a parameter/count-matched duplicate-only child. A new-task decline with preserved old-task performance supports use of added capacity; it does not alone prove a unique developmental advantage. Check sensitivity to clamping rather than only weight magnitude. Use a separately evaluated permanently closed/readout-frozen branch as a negative control if preservation seems to succeed without added units contributing.

**Primary outcome.** The paired difference, developmental minus ordinary growth, in area under the **new-task query-accuracy versus adaptation-compute curve**, normalized to `[0,1]`, under an old-task noninferiority gate. Use common checkpoints `0,10**6,10**7,10**8` multiply-add equivalents; stop at `2**15` labeled events or the compute ceiling, whichever occurs first, and carry the last evaluated score to the ceiling for area calculation. The old-task accuracy must remain within a provisional one percentage point of that parent's pre-growth accuracy at each checkpoint. Report gate failures explicitly; for a joint primary score set the failing arm's gated area to zero. Report raw areas, zero-step errors and old-task trajectories separately so a gate failure cannot be concealed. Finalize tolerances and meaningful margins after the pilot and before confirmation.

**Cost and baseline interpretation.** Both growth arms share identical inherited training and generator-selection charges. Report adaptation-only cost and total historical cost. The target-size normal arm gets the actual historical exposure envelope, not just the much shorter post-growth window; its final checkpoints need not align in age with the grown child. A secondary same-deadline scratch comparison is useful but cannot establish a lifecycle saving. Count extra child inference/state/compilation costs. Continuing the smaller parent can win on deployment cost even when a larger child learns faster. Choose the task difficulty after a pilot showing room for improvement; extra tensor width is not proof that the parent could not encode the task.

**Replication and analysis.** The independently trained parent checkpoint/seed is the paired outer unit, with its children, held-out width pairs and episodes nested. Use independently generated old/new task manifests across outer units. If several checkpoints come from one training trajectory, they share one cluster. Analyze paired effects and the capacity ablation with clustered intervals. Leave parent count, power and episode count unresolved until the pilot quantifies between-parent variance; do not treat thousands of query events as thousands of independent growth experiments.

**Largest confounds.** Unequal parent quality, optimizer-state carry, different zero-step states, new normalizers, extra recurrent updates, arbitrary perturbation timing, changed supervision, ceiling effects, and a child topology advantage mistaken for a transfer mechanism. Control the parent and stream by pairing; log exact transfer manifests; distinguish topology selection from initialization and initialization from development. A zero-step branch that stays unused can pass retention without satisfying the capacity claim.

**Exclusions and stopping.** The same objective infrastructure/oracle exclusions apply. Failed retention, invalid children, poor parent performance and budget exhaustion remain recorded outcomes. If the pilot uses a predeclared competent-parent threshold, publish all discarded-parent counts and historical cost, and also show the unconditional result. Stop a defective transfer before adaptation when its contract test fails; retain that failure in the primary accounting. Freeze the finite parent/growth matrix after pilot planning; no sequential significance-based extension or new task hunting.

**Go/no-go.** A go requires zero-step retention, noninferior old-task learning, positive paired acquisition advantage beyond ordinary growth at matched cost, and evidence that added units contribute. Compare against parent continuation and total-cost normal training before claiming practical savings. The draft meaningful margin is a two-point normalized-area improvement, finalized before confirmation. If ordinary growth matches or wins, retain ordinary growth. If both preserve but added capacity is inert, the growth claim fails. Better average accuracy with extra compute alone does not support a growth-specific causal effect.

## 7. Decision and smallest next step

The present evidence supports **a conventional baseline first**, with the two-operator witness retained as an auditable semantic example. It does not justify a new parser or broad language, scaling campaign, architecture search, or integration into the live memory trial. The strongest reason to stop is that shared recipes, contextual roles and preservation can all be supplied cheaply by ordinary construction, leaving no necessary developmental mechanism.

The observation that would change this recommendation is a reproducible, resource-matched benefit on independently varying held-out component sizes or paired inherited-growth acquisition, surviving the ordinary builder/ordinary growth and same-topology controls. If the benefit is specifically lifelong structural adaptation, prioritize an LNDP reproduction/extension with matched costs. If it is only interface validity or compact configuration, adopt a tiny common IR as engineering infrastructure and stop calling it evidence of a learning advantage.

The next implementation and operational handoff are in [handoff.md](handoff.md). Future integration is a separately authorized import of static specifications/results, with its own controller and resources if eventually needed; it is not an action taken in this assignment.

Artifact validation confirmed that the HTML embeds the Markdown assessment verbatim, all section anchors and companion-file links resolve, all five deliverables are present, and the recorded witness source hash matches `checks.py`. The HTML has no external script, stylesheet, image or media loads. A visual preview could not be completed because the browser URL policy disallows local file URLs; visual layout is therefore unverified.