# De-scaffolded heterogeneous development V1: successful transfer, conventional costs favored

**Question.** Can one fixed, compact local developmental program choose cell roles, storage assignments, and legal connections on a role-unlabelled 3D substrate, producing working heterogeneous memory/routing systems across unseen layouts, physical sizes, and logical capacities?

**Result.** D and B each achieved **100% functional construction-transfer success** in the seven held-out settings: 84/84 cases per arm. The prespecified mean of seven case indicators within each of twelve outer groups, then equal outer-group mean, is D=100%, B=100%, D−B=0 percentage points. All 192 scheduled constructor cases completed, including the reference. Each arm answered 14,536/14,536 ordinary queries correctly and on time; each answered all 768 selected individual challenge queries and all 384 selected opposite-answer pairs correctly and on time. All 768 ordinary episodes across both arms passed exact compiled replay. This is a locally frozen, hand-authored exploratory construction experiment.

The three verdicts are separate:

- **Program-controlled construction: supported within this explicit rule/family.** Candidate interiors had no role, material, address, path or timing-compensation labels. From one seed, D chose a tree through charged local growth and registrations, assigned roles and address-bearing latches from legitimate terminal cues, and pruned unused cells. Its storage heuristic is deliberately simple: put each latch at its write attachment. These are computational cells grown by D, separate from passive external terminals. Boundary identities still supply task meaning. The rule does not discover an algorithm or optimize storage placement.
- **Transfer: supported for these fixed programs and conditional lattice distribution.** The same D function worked across independently varied L=4/6, K=4/8 and p=0/.15. L6 and K8 were absent from constructor development. B transferred equally well. Increasing K produced K independently writable latches, with K8 needing twice the logical scalar-value capacity of K4. A larger host produced more opportunity and exploratory occupancy, rather than automatically occupying every candidate in the final circuit.
- **Comparative utility: no developmental advantage demonstrated.** B placed storage closer to the query using stronger global access and achieved shorter read latency, fewer ordinary task messages, less routing state, and much less temporary computational occupancy. Mean active cells and wire length were similar; D sometimes used fewer cells/wire on particular settings. Equality of function does not imply equality of organization: none of the 96 paired complete executable hashes were equal. Tiny Python timings are descriptive, not a general performance claim.

Execution is complete. Publication delivery is tracked separately in the publisher receipt and study status. This report closes the constructor-only milestone. It is not public preregistration, peer review, or independent reproduction.

## How the interior blueprint was removed

The [completed context-to-dynamics study](https://chronomata.ai/experiments/developmental-computation--context-to-dynamics-transfer-v1-2026-10-14/) was read from local report/source/evidence after the supplied public URL was inaccessible through the web tool and initial DNS attempt. That source reported D=B=100%, identical executable circuit hashes and resources, and identical intervention effects. It supplied guide bonds, material/role cues and addresses. Its RULE descriptor was prose; the Python constructor was the actual executable rule. Failures under timing changes were lost exact-tick rendezvous, with correct emitted signs. That result calibrated assembly/transport in a programmed corridor family; it did not establish rule-selected internal organization. Earlier assessment, baseline and context-to-dynamics artifacts remain preserved by checked hashes. The separate primary workstream was not inspected.

The present host is generated independently of both constructors: a six-neighbor 3D lattice, coordinate jitter in [-.08,.08], and independently removed interior candidate sites. Every host manifest is in hosts.json. Boundary sites remain eligible. A frozen shuffled boundary procedure attaches one query, one response and K public write terminals at distinct locations. Write identities and command meanings are legitimate boundary information. Terminals only inject/receive events through one-tick links; they retain no values, routes or answers. Initially, every computational candidate except the uncommitted query seed is vacant.

Admissibility asks only whether all terminal attachments share a connected component, with at most 16 candidate attempts. All 96 scheduled paired hosts were accepted on the first attempt: **zero rejected draws**, so this realized conditional distribution contains no redraws. Boundary preservation makes this connectivity requirement easy; obstacles affect interiors rather than the boundary backbone. Accepted candidate sites ranged from 60 to 216. Obstacles removed an average 1.42 interior sites for L4 and 9.67 for L6 among p=.15 settings. Host size changes the physical lattice extent; jitter and detours change real transport lengths/delays. In 26/48 matched p0/p.15 D comparisons, selected physical wire length changed. The hand-built development detour also required four local hops where the unobstructed geometric separation was two; abstract detour behavior was therefore a known concept, not an unseen innovation.

The exact executable genome is **program.py**, a 2,105-byte Python file containing local_update and one immutable response-tag constant. There is no separately interpreted RULE string. The rule receives only one cell's state, locally attached terminal cues, adjacent permitted handles/delays and one delivered message. It has no imports, alternate whole-host handle, planner, oracle, future inputs or evaluator clock. It never parses opaque labels. Local birth offers explore every permitted non-parent bond. First-arrival conflicts retain the occupied cell; losing work is charged. Registrations propagate public write/response identities along local parent links and install descendant next hops. The program assigns the query cell an interface role, distinct write-bearing cells latch roles, retained intermediate cells router roles, and prunes terminal-free exploration.

construct.py contains the generic local scheduler and serialization plus an independent B algorithm. The scheduler knows the host to deliver messages, enforces occupancy/budgets, and signals construction quiescence. That global termination notification is a disclosed scheduling convenience; this is not a claim of fully decentralized termination detection. It never chooses D's roles or repairs D's topology. Global validation only accepts/rejects. B sees the whole host, runs weighted Dijkstra, shares root-to-terminal paths and greedily puts each distinct latch nearer the query on its write path. It excludes already used latches, the interface/response, and other write attachments. Its recorded planning visits include neighbor scans, heap pushes/pops and path/route visits. B was competent on the same development fixtures, with no forced topological equality or intentional handicap.

What remains hand-programmed is substantial: the signed last-write/select task and its public command/address meanings; the passive terminal distribution; the router, scalar latch, and control/value interface semantics; the two construction algorithms and their heuristics; and the runtime, budgets, stopping, generator and scoring. No learning, neural optimizer, trained inheritance, task-algorithm discovery, emergent intelligence, 3D necessity, unique developmental advantage or biological claim follows.

## Task V2 and unequal-arrival handshake

Task/runtime versions are signed-last-write-select-settled-v2 and bounded-latch-handshake-v2. Each 64-event episode initializes all K independent signs with a shuffled balanced bank, then mixes random overwrites, retained values, variable gaps and address-selecting queries, with at least 32 queries. The external-history oracle computes targets independently; it is never imported by either constructor or runtime. Development and scoring streams use disjoint namespaces. Corresponding task random uniforms/gaps are shared across settings; K changes initialization length and normalized addresses. Within L, layout jitter/opaque labels/terminal permutation and obstacle uniforms are shared across K and p, K4 terminals are a prefix of K8, and p=.15 thresholds the interior removal draws. L changes layout draws. D/B share the actual host and external input history, with no assumption of equal edge IDs, topology or execution traces.

Each latch carries one address and one independent scalar sign. Routers forward using explicit bounded next hops; those tables count as state. At a query the interface retains one six-bit transaction ID and three-bit address, sends a request, and buffers the control until the matching retrieved value returns. It clears the slot and forwards one answer toward the passive response terminal. It never holds the bank. Valid transaction IDs are 0..63; no unbounded associative join exists. Messages are padded four-byte payloads; finite in-flight records are charged sixteen bytes. The interface reserves four bytes, and a finite output buffer is drained after each transaction. Delivery/commit order is (tick,destination,source,sequence), with atomic processing and strictly positive delay on every local edge and terminal link. Writes commit before subsequent settled transactions. Reset clears signs, queue, interface, clocks and counters.

The common **1292-tick response window** derives before scoring from the independent physical bound: at most 215 bonds of at most two ticks for each of request, value and response paths, plus two terminal links. Writes settle within 431 ticks. Common transaction gaps are 1294..1394 ticks. Neither constructor's achieved latency sets the deadline. There is no exact-tick coincidence requirement and no delay-deletion/swapping arm. Actual ordinary query latency ranged D=7..43 and B=5..27 ticks, well inside the intentionally generous physical window. This produces ceiling accuracy, while actual latency and communication still differ.

## Complete finite matrix and outer groups

Each row contains twelve paired environment/task groups, four ordinary episodes and four selected dependent opposite-answer pairs per arm. Query denominators below are **per arm**. All ordinary errors, missing/duplicate/late responses, construction/resource failures and replay failures were zero. Missing, incorrect, duplicate and late flags are explicitly retained and may overlap; model failure would score all its scheduled queries zero. No scheduled case was dropped or left unobserved.

| Setting | D successful cases | B successful cases | Ordinary correct/on-time per arm | Mean active cells D / B | Mean query ticks D / B |
| --- | ---: | ---: | ---: | ---: | ---: |
| L4-K4-p0 | 12/12 | 12/12 | 1,878/1,878 | 16.83 / 16.92 | 17.29 / 11.05 |
| L4-K4-p0.15 | 12/12 | 12/12 | 1,878/1,878 | 16.92 / 16.92 | 17.62 / 11.08 |
| L4-K8-p0 | 12/12 | 12/12 | 1,756/1,756 | 24.25 / 24.50 | 17.83 / 12.25 |
| L4-K8-p0.15 | 12/12 | 12/12 | 1,756/1,756 | 23.92 / 24.25 | 18.10 / 12.42 |
| L6-K4-p0 | 12/12 | 12/12 | 1,878/1,878 | 26.50 / 25.83 | 24.05 / 12.66 |
| L6-K4-p0.15 | 12/12 | 12/12 | 1,878/1,878 | 26.17 / 25.92 | 24.34 / 12.78 |
| L6-K8-p0 | 12/12 | 12/12 | 1,756/1,756 | 42.92 / 42.33 | 25.47 / 14.06 |
| L6-K8-p0.15 | 12/12 | 12/12 | 1,756/1,756 | 42.67 / 41.92 | 25.85 / 14.24 |

The first row is the reference. Seven other setting indicators have equal weight within each group. The **four K4 rows** separately show spatial/obstacle transfer at fixed logical capacity: all 48 cases per arm succeeded, while mean active cells and latency increase with the larger host. K8 rows separately add logical storage demand; they are not larger redundant copies of one value. Every address has its own last-write target and sign variable.

| Outer group | D held-out cases | B held-out cases | D group mean | B group mean | Paired difference |
| --- | ---: | ---: | ---: | ---: | ---: |
| 0 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 1 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 2 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 3 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 4 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 5 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 6 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 7 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 8 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 9 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 10 | 7/7 | 7/7 | 100% | 100% | 0 pp |
| 11 | 7/7 | 7/7 | 100% | 100% | 0 pp |

These twelve nested environment/task groups are not twelve independently discovered developmental algorithms. All outer differences are zero. A zero empirical range supplies no powered equivalence claim or universal zero uncertainty over other rules/hosts/tasks; no artificial accuracy margin or deadline tuning was introduced.

## Resource tradeoffs and strongest counterexample

Costs below cover **all 96 cases per arm**. All 96 paired cases were mutually successful, so conditional cost coverage is 100% and equals unconditional coverage here. No costly failure is excluded. Means equally weight constructor cases except pooled query latency, which weights ordinary query observations. Ordinary message columns cover the four scored episodes, separate from replay and selected challenge work; exact replay repeats the same ordinary communication counts. Complete executed-job CPU includes fixtures, replay and challenge setup. Selected query-message counts are retained in pair records; challenge write-setup communication is not separately tabulated. Development and global planning work units are different measurements, not equivalent FLOPs.

| Metric | D | B |
| --- | ---: | ---: |
| Candidate sites (mean) | 137.23 | 137.23 |
| Peak occupied computational sites (mean) | 137.23 | 27.32 |
| Active/final occupied cells (mean) | 27.52 | 27.32 |
| Unused sites after pruning (mean) | 109.71 | 109.91 |
| Selected local edges (mean) | 26.52 | 26.32 |
| Physical wire length (mean) | 25.88 | 25.75 |
| Logical persistent state bytes (mean) | 282.29 | 220.33 |
| Next-hop entries, one-byte handles (mean) | 64.42 | 43.90 |
| Complete compiled JSON bytes (mean) | 5,047.05 | 4,794.50 |
| Development messages (mean) | 554.21 | 0.00 |
| Development logical bytes (mean) | 8,867.33 | 0.00 |
| Development ticks (mean) | 19.69 | 0.00 |
| Peak serialized developmental state bytes (mean) | 10,036.38 | 0.00 |
| Global planning work units (mean) | 0.00 | 1,051.86 |
| Ordinary task messages (total) | 269,412 | 200,583 |
| Ordinary task payload bytes (total) | 1,077,648 | 802,332 |
| Peak incoming queue records | 1 | 1 |
| Peak compact task buffers bytes | 28 | 28 |
| Peak serialized mutable state bytes | 227 | 226 |
| Mean query latency (ticks) | 21.30 | 12.54 |
| Construction CPU seconds (total) | 0.2580 | 0.0260 |
| Ordinary execution CPU seconds (total) | 3.2388 | 2.5776 |
| Ordinary execution wall seconds (total) | 3.2544 | 2.5889 |

Logical persistent bytes include roles/address flags, three-byte route entries, one-byte scalar storage allocation, the four-byte interface slot and a conservative 24-byte metadata/counter allowance. Scalar value payload alone is 2K bits (8 for K4, 16 for K8), distinct from byte allocation and routing state. Both reserve 8,324 compact bytes for queue/interface/output buffers; observed peak compact buffered allocation was 28 bytes, and peak complete serialized mutable state was D=227/B=226 bytes. Serialized state includes clock, sequence, counters, latch signs, pending interface, queue and current outputs; Python object/interpreter and trajectory-audit overhead are covered by RSS. These field-accounting and serialization quantities are not claims of exact Python memory size. Full construction/source/primitive ledgers are available in cases.json, analysis.json and resources.json.

The strongest counterexample to a developmental **utility** claim is B's better organization with equal function. In group9/L6/K8/p0, episode0/event28, a query of address4 after 32,131 retention ticks receives the correct −1 from D after 43 ticks and B after 21. Both meet the same deadline. Across ordinary episodes, D sent 269,412 messages versus B's 200,583; its mean latency was 21.30 versus 12.54. There is no functional failure to diagnose in the scored matrix; inventing one or adjusting deadlines would change the question.

The prespecified difficult-trace selection is maximum developmental messages, first run-order tie. It selected group5/L6/K8/p0: D temporarily occupied 216 candidates, sent 948 messages/15,168 developmental bytes in 28 ticks, then retained 51 active cells/50 edges, leaving 165 sites unused. B retained 49 cells/48 edges and used 1,761 global planning units. The complete D circuit and birth/registration/differentiation records are in difficult-trace.json; successful group0 reference and fully held-out D/B circuits/traces are in representatives.json. These show how the initially role-unlabelled substrate acquired executable roles and routes rather than supplying a decorative network rendering.

The frozen matrix job measured 15.030 CPU seconds and 13.527 wall seconds, including monitor overhead. All monitored fixture/freeze/matrix/rerun jobs measured 16.358 CPU/14.992 wall seconds. The initial monitor permission failure remains in attempts.json and its local log; its worker passed fixtures, but its usage was unmeasured, so the full 120-second reservation is conservatively charged. This study's recorded job ledger is therefore 136.358 CPU/134.992 wall seconds plus a 60-second setup/analysis allowance. Earlier inclusive costs remain separately labelled 248.178 CPU/214.930 wall seconds. Conservatively combined totals are 444.820 CPU/410.215 wall seconds, below 3600/5400 ceilings. Remote publication CPU is unmeasured.

Highest sampled process-tree RSS was 81,559,552 bytes (77.78 MiB). The watchdog samples every 100 ms and is not instantaneous hard RSS enforcement. Largest final circuit had 53 active cells/52 edges; temporary occupancy reached the 216-site host envelope. No GPU, extra agent, automation, paid service, model inference, external dependency or global installation was used. One numerical CPU worker ran Python 3.14.8 with library thread variables set to one. The selected source/evidence is about 10 MB locally before release duplication, safely below 128 MiB; final retained-byte closeout is separate from execution metrics.

## Freeze, author checks, evidence and reproduction

Local freeze SHA256: **c319ec4485948e87221a760ff29162bc35a8d5e5ac2ba258d5f77f18939dc845**, sealed at 2026-10-14T21:27:15.185445+00:00, before the matrix started at 2026-10-14T21:27:17.142732+00:00. Source, local rule/constants, primitive semantics, generator/admissibility, task/oracle, complete budgets/seeds/order, stopping, deadline/scoring and analysis plan are bound. No frozen byte changed after scoring. No added seeds, arms, parameter search, selected environments or deadline revisions followed. Pre-freeze development/history, final fixture evidence and all attempts are retained. Post-run verify_results.py, this report and derived tables are explicitly outside the frozen executable source.

The independent saved-score author audit recomputed every external-history target and retention age, every failure flag, case/pair gate, denominator and outer weighting from saved events/responses without importing experimental modules: 29,072 unique ordinary query rows, 768 episode replay records and 617,451 compared delivery/boundary trajectory steps. The actual prescribed author rerun copied frozen source to a disposable directory and launched a fresh interpreter for group0/L6/K8/p.15 D/B: two cases, eight ordinary episodes and eight selected pairs. Circuit hashes, full trajectory hashes/final states, outputs and pair records matched. It supplies an author check, not independent scientific reproduction. Compiled replay is a shared semantic gate: complete compiled structure and initial state are serialized, then instantiated with no development state/history. It shows that developmental state supplies no extra execution capability; history does not benefit an identical compiled system.

Evidence downloads include compact protocol/configuration/freeze; actual program, B, scheduler, primitives, generator and task/oracle; every accepted host and rejection record; all ordinary events/query outcomes; every case including pair outcomes, costs and replay hashes; complete representative circuits and traces; independent audit/aggregate tables, incremental ledger and the author-rerun record. Other circuits have reproducible hashes and regenerate from the frozen source/host seeds. All evidence is synthetic/project-authored scoped static material. No whole repository, private path, raw chat, unrelated log or separate-primary state is released. Preservation hashes are local provenance labels; in a standalone download, unavailable prior originals are explicitly unobserved rather than freshly verified.

For execution, download the source/config/protocol/history/final fixture files listed by freeze.json plus freeze.json and frozen-status.json into a disposable directory, preserving exact bytes. No external packages are needed. One small paired held-out smoke command:

```sh
python3 run_job.py smoke
```

One full-matrix command, after copying frozen-status.json to status.json and ensuring there is no results directory:

```sh
python3 run_job.py full
```

To audit the saved public scores without execution, put cases.json, queries.csv, summary.json, hosts.json and events.json in a results subdirectory beside the downloaded source, config, freeze, attempts and preservation files, then run python3 verify_results.py. For a direct local view, use report.md. The saved trajectory comparisons and executable author rerun are different checks from score reaggregation.

Content/source inspection, visual/browser inspection, saved-score reaggregation and executable author rerun are tracked separately. Content and numerical author checks passed before publication preparation; visual inspection and remote delivery verification are recorded separately at closeout. Publication never constitutes scientific replication.

At most one next scientific action is recommended: a separately specified test of **learned organization** under the same explicit host, task, physics and strong B. It is not executed here. A larger hand-authored corridor demonstration is not a next step; constructor-only construction/transfer is closed.