Joakimpalm-Zen/Xyntetik-Genesis-Language-record

Xyntetik GENESIS: Language record

The language track's full record: Genesis I and the later language studies, and the training record of Xyntetik-Blad-Genesis-0.7M. Renamed on 2026-10-08 from Xyntetik-Blad-Genesis-0.7M-training-record to match the existence and crossing records; the old URL redirects.

Research evidence dataset. Part of the collection Xyntetik Research: GENESIS on this account (https://huggingface.co/collections/Joakimpalm-Zen/xyntetik-research-genesis-6abcfa50b6707dec9bfee356). The released model is Xyntetik-Blad-Genesis-0.7M. This dataset holds the whole generation-I record: 18 preregistrations, their decisions and reports, raw archives, code, the synthesis, and the continuous-medium checkpoints of GL-002d. It also holds the later studies on the same branch: GII-001 (2026-09-30), GL-008, GL-009 and GL-010 (2026-10-02), GL-010-D, GL-010b, GL-018 and GL-019 (2026-10-03), GL-014 and GL-020 (2026-10-04), GL-019b (2026-10-06), GL-021 with its feasibility stage GL-021-F (2026-10-13) and its certification (2026-10-14), and GL-021b, GL-022's feasibility stage (GL-022-F, two launches) and GL-022's preregistration while it runs (2026-10-15).

Read first: GENESIS I: what survived 18 preregistered experiments on machine-only learning, the article, in this dataset as GENESIS-I.md.

Dataset summary

Question tested. GENESIS set out to test the study's thesis: a native AI language made for AI, with no human in the data, the labels, the reward or the reader. The judge is execution truth, meaning what the host computes when it runs something. Generation I tested the thesis's narrow forms at toy scale on one CPU host:

• S1 and S1b (GL-003, GL-003b): can a tiny model trained from scratch, with no human text, learn to propose programs in a synthetic DSL that beat the best blind search at equal executions?
• GL-003c to GL-003f: does that gain grow with training, survive with training CPU charged at equal CPU-seconds, replicate on a second grammar, and improve with a larger core?
• S2 and S2b (GL-004, GL-004b): can a learned per-host cost adapter beat measurement?
• S3, reframed (GL-005): does the core improve while it runs?
• GL-007: do words the core extracts from its own solutions pay?
• The medium line (GL-001, GL-002a-g): does a small model trained only on final answers form its own intermediate medium, and does that medium beat an explicit step-by-step trace?
• Genesis II, GII-001 (after the freeze): does the core result survive on human-written list tasks, with a stricter correctness check and stronger blind searches? One locked study, with no rescue.
• The parked hypotheses, tested 2026-10-02: does the continuous medium beat an equally trained terse trace at the same pass count (GL-008)? Do deeper words, of two operations with arguments, pay (GL-009)? Does the soft-sample discrete medium form reliably with 4× the budget, and is the soft-hard gap the cause (GL-010)?
• Measurement and a medium follow-up, 2026-10-03: how much of the core's hidden-input failure do five-example specs force (GL-018)? Does an opcode n-gram trained on the same data, one that never reads the task's examples, do as well as the core (GL-019)? Why do formed discrete media collapse (GL-010-D, an exploratory diagnosis), and does dropping the learning rate at formation stop it (GL-010b)?
• The larger core and the choice of claim, 2026-10-04: with a longer budget and a tuned learning rate, does a larger core overtake more iterations of the recipe (GL-014)? Among the programs the core's search finds that match the five examples, does a rule other than the first found leave fewer wrong claims (GL-020)?
• The example-reading baseline, 2026-10-06: does a proposer without a transformer that reads the five examples reach the core's solve rate at equal compute (GL-019b)?
• A field benchmark, 2026-10-13: on DeepCoder's own DSL and data protocol, with every cost charged and a tuned blind search, does a learned proposer still solve more, and does an example-reading MLP again come within δ of a transformer (GL-021, after its feasibility stage GL-021-F)?
• The transformer against the MLP, and a second field benchmark, 2026-10-15: on fresh DeepCoder tasks, does the example-reading MLP come within δ of the transformer (GL-021b)? Can GL-021's comparison be posed faithfully on LambdaBeam's benchmark and resolved inside its compute cap (GL-022-F), and does it hold there (GL-022, running)?

Every study wrote its kill criteria before its own data. The two measurement studies of 2026-10-03 (GL-018, GL-019) registered readings instead, and GL-010-D, an exploratory diagnosis, had neither.

Models involved.

• Produced artifact: https://huggingface.co/Joakimpalm-Zen/Xyntetik-Blad-Genesis-0.7M, the three GL-003c program-proposal cores (686,756 parameters; seeds 29093641-43 at 160, 320 and 640 meta-iterations). They are also inside genesis-language/runs/GL-003c/GL-003c-raw-ckpt-{160,320,640}.tar.gz here.
• Parent: none. Everything after GL-001 was trained from scratch on synthetic tasks.
• Sibling cores in the raw archives: GL-003's and GL-003b's cores, GL-003e's grammar-2 cores, GL-003f's larger cores, GL-005's promoted candidates, and GL-007's library and plain cores.
• The medium models: 2-layer models of 438,288 parameters on a synthetic 8-state lookup task. GL-002d's 42 checkpoints are in medium-checkpoints/. GL-002c, GL-002e, GL-002f and GL-002g weights are in the raw archives (GL-002g's best-dev checkpoints only). GL-002a's and GL-002b's weights were never committed to the branch and are not here.
• GL-001 only: a frozen, prompted Qwen2.5-1.5B (Q4_K_M, CPU). Its weights are not distributed; its requests and responses are in genesis-language/runs/GL-001/.
• Controls: blind searches in four families (random R-k, bottom-up enumeration, HEAP, genetic algorithms). In the core line the best, chosen on calibration tasks, was GA-64-graded throughout. S2 also used best-of-N and measuring autotuners (atlas, plan-ref).

Method. Each study followed the same order: preregistration (genesis-language/prereg/), harness and unit tests, instrument checks, runs, then a decision computed by a script (runs/*/decision.json) and a report (genesis-language/report/). Amendments are recorded in each preregistration with their timing against the data. The core was trained by hindsight relabelling: its own sampled programs, executed by the host and labelled with the outputs the host computed for them. It searched with Stochastic Beam Search, and its answers were judged on 20 hidden inputs. Solve rates are "first answer final". Comparisons are at equal executions (50,000 per task) or at equal CPU-seconds with training charged. Everything ran on one AMD Ryzen Threadripper 9980X under co-tenant load. GL-002f, GL-002g, GL-008, GL-010, GL-010b, GL-014 and GL-020 used a 24 GB slice of the same box's GPU; everything else ran on CPU. SYNTHESIS-GENESIS-I.md is the whole-programme reading, written after the freeze with no new runs.

What each file contains.

• README.md: this card.
• GENESIS.json: the released model's sidecar (architecture, recipe, checkpoint hashes, source commits, headline measurements with their files).
• PUBLIC-COPY-CHANGES.md: every change this public copy makes to the record. It lists 83 paraphrases of the owner's words (42 for Genesis I, 1 added on 2026-10-02, 2 on 2026-10-03, 2 on 2026-10-04, 1 on 2026-10-09, 18 on 2026-10-13, 3 on 2026-10-14 and 14 on 2026-10-15) and the one withheld file, and records the GII-001, 2026-10-02, 2026-10-03, 2026-10-04, 2026-10-08, 2026-10-13, 2026-10-14 and 2026-10-15 updates and the 2026-10-09 cleanup, which replaced machine and session names by role names throughout the record and the local commit identity by a placeholder.
• genesis-language/: the shade branch genesis-language at 4a70b24b4 (Genesis I at 6bf599e25, plus GII-001, GL-008 to GL-010, GL-010-D, GL-010b, GL-018, GL-019, GL-014 and GL-020), with GL-019b's files from 153978dcd, GL-021's from 06c6472f1 (added from 36176a3ba on 2026-10-13, its certification on 2026-10-14) and GL-021b's and GL-022's from c09f537cb (2026-10-15), research/cognition/genesis-language/, with the two changes above:
  • PLAN.md (start here), QUEUE-2026-10-01.md (the queue of the parked items and the measurement branches, with their status), RESEARCH_STATE.md, PRIOR_ART.md, LITERATURE.md and the study's own README.md;
  • SYNTHESIS-GENESIS-I.md: the ledger of all 18 studies, per-thesis evidence against and for, the case against GENESIS, what survives it, and Genesis II candidates;
  • GII-001 (Genesis II): prereg/GII-001.md, report/GII-001.md, runs/GII-001/ (the decision, the mapped external functions and the oracle, manifests, compute records, and 10 raw archives, one with the three fresh cores' weights), the gii001_* harness with test_gii001.py, and the second-host package (gii001_host2.py, GII-001-HOST2.md), not yet run;
  • GL-008, GL-009 and GL-010 (2026-10-02): prereg/ and report/ for each; runs/GL-008/ and runs/GL-010/ (the decision, per-run configs, logs and results, the pool logs, GL-008's latency and FLOPs records, and one archive of delivered checkpoints per run, with checkpoints.sha256); runs/GL-009/ (the decision, the words, the FLOP match and 8 raw archives, three with the deep arm's weights); the gl008*, gl009* and gl010* harnesses with their tests; and INTAKE-GL-009-2026-10-02.md;
  • GL-010-D, GL-010b, GL-018 and GL-019 (2026-10-03): report/ for each and prereg/ for the three preregistered studies (GL-010-D is an exploratory, post hoc diagnosis with no preregistration); runs/GL-010-D/ (the diagnosis's derived data); runs/GL-010b/ (the decision, per-run configs, logs and results, the pool logs, and one archive of final and delivered weights per run, with checkpoints.sha256); runs/GL-018/ (the decision, the prepared task sets and the enumeration archive); runs/GL-019/ (the decision, the fitted n-grams, the replayed hindsight buffers as *.jsonl.gz.part-00 files, and the search and task archives); the gl010b*, gl010d_*, gl018_* and gl019_* harnesses, gl018_019_chain.sh and test_gl010b.py;
  • GL-014 and GL-020 (2026-10-04): prereg/ and report/ for each, with GL-014's first registered report (report/GL-014-attempt1.md); runs/GL-014/ (the decision and the first registered decision, the learning-rate selection, the FLOP match, per-run configs, checkpoint logs and results, the paired readings, the rerun's records, the checkpoints' sha256 (the weights themselves are not in the record) and 6 raw archives); runs/GL-014-attempt1-phase0/ (the first attempt's Phase 0, kept aside); runs/GL-020/ (the decision, the rule selection, the search status, the rule picks' hashes and 4 raw archives) and runs/GL-020-prereg/ (its power calculation); the gl014_* and gl020_* harnesses with test_gl014.py and test_gl020.py;
  • GL-019b (2026-10-06): prereg/ and report/; runs/GL-019b/ (the decision, the task manifest and exclusions, the audit, the fits and their selection, the budgets, the search status, and 2 raw archives with raw/SHA256SUMS); runs/GL-019b-prereg/power.json; the gl019b_* harness with test_gl019b.py; and the two lane gates that launched it and the later chains (lane_gate.sh, laneg_gate.sh). QUEUE-2026-10-01.md and PLAN.md stay at 4a70b24b4;
  • GL-021 and its feasibility stage GL-021-F (2026-10-13), and GL-021's certification (2026-10-14): prereg/ and report/ for GL-021 and GL-021-F, with the certification's amendment (Amendment 2) at the end of prereg/GL-021.md and its note report/GL-021-cert.md; PRIOR_ART-GL-021.md (the choice of benchmark) and its pointer section at the end of PRIOR_ART.md; runs/GL-021/ (the decision, Phase 0's record, the corpus, generation and prior records, the task manifests, the fits and their selection, the calibration and the budgets, the instrument checks and the fits' load exposure, the chain and sibling-load logs, and 2 raw archives, the task archive in two .part-NN pieces, with raw/SHA256SUMS); runs/GL-021-F/ (the feasibility verdict, checks F1-F12, the pilot's corpus, fits, probes, costs and budgets, the harness hashes, the transformer's configuration, the amendments' measurements and scripts, the chain and sibling-load logs, and 1 raw archive with raw/SHA256SUMS); runs/GL-021-cert/ (the certification run: the harness pins, Phase 0's record and the input checks, the refits' records and their selection, the budgets, the three W runs, the decision and certification.json, the fits' load exposure, the pool, chain, sibling-load and lane logs, and 1 raw archive with raw/SHA256SUMS); runs/GL-021-prereg/power_plan.json; the gl021_* harness with test_gl021.py, including the certification's launch gate gl021_cert_gate.sh; and test_gl019b.py, whose seed scan GL-021-F's Amendment 3 changed. QUEUE-2026-10-01.md and PLAN.md still stay at 4a70b24b4;
  • GL-021b, GL-022-F and GL-022 (2026-10-15): prereg/ for each (GL-022-F's Amendments 1 and 2 and GL-022's at their ends); report/GL-021b.md, and GL-022-F's three reports (GL-022-F.md, the first launch; GL-022-F2.md, the second; GL-022-F2-a2.md, the second launch's decision rerun under Amendment 2); PRIOR_ART-GL-022.md (the choice of benchmark); runs/GL-021b/ (the decision, Phase 0's record, the task generation and manifests, the budgets and the certified alternative, the instrument checks, the W runs, the chain, pool and sibling-load logs, and 2 raw archives, the task archive in four .part-NN pieces, with raw/SHA256SUMS) and runs/GL-021b-prereg/ (the design, pins and power calculation); runs/GL-022-F/ and runs/GL-022-F2/ (each launch's feasibility verdict, checks, corpus, pilot fits, probes, calibration and task sets, the harness hashes, the pool and chain logs and 2 raw archives, the pilot's marked DISCARDED, with raw/SHA256SUMS; F2 also holds the Amendment 2 decision, feasibility-a2.json, with its harness hashes and log); runs/GL-022/ (Phase 0's record of the running launch: the harness hashes, the fetch and input checks; no result) and runs/GL-022-prereg/ (the design, pins and sizing); and the gl021b_*, gl022_* and gl022s_* harnesses with test_gl021b.py, test_gl022.py and test_gl022s.py;
  • prereg/: 33 preregistrations (18 for Genesis I, plus GII-001, GL-008, GL-009, GL-010, GL-010b, GL-018, GL-019, GL-014, GL-020, GL-019b, GL-021-F, GL-021, GL-021b, GL-022-F and GL-022) with their amendments;
  • report/: 39 reports (30 studies, GL-021-F's feasibility report and GL-022-F's three, GL-021's certification note, GL-014's first registered report, the GL-010-D diagnosis, the GL-003 post hoc note and the GL-004 status note);
  • runs/<study>/: per-study decision.json, manifests, compute and timing records, instrument and phase-0 test results, per-run configs, logs and results, and 376 archives (*.tar.gz, each under 50 MB; GL-021's task archive is stored in two .part-NN pieces and GL-021b's in four), plus GL-019's three gzipped buffers. They hold the search and judge records, training logs and most arms' weights;
  • the harness at the top level: 203 Python files (generators, learners, searches, judges, analyses, pools and 32 unit-test files), 52 shell launchers, waiters, chains and commit scripts, and 3 C files (the S2 cost driver, a forward-pass counter and GL-018's enumerator).
• medium-checkpoints/GL-002d/runs/<arm>-s<seed>/{model.pt, model_best.pt}: the continuous-medium confirmation's checkpoints (6 seeds × the E_continuous_half, E_continuous_half_stable and E_direct arms, plus the 6 trace references), with medium-checkpoints/SHA256SUMS. They match the record's runs/GL-002d/checkpoints.sha256. Their configs, logs and results are under genesis-language/runs/GL-002d/<arm>-s<seed>/.
• Withheld: gl004_attacks.py, the S2 judge's attack suite, withheld by the publisher as a precaution, a choice the owner accepted at card review. It is executable attack code against the S2 cost judge, and reading the record needs only its verdict, which stays: 18 of 18 attacks rejected and the honest control accepted (report/GL-004-status.md, runs/GL-004/instrument/attack_suite.json, runs/GL-004/phase0/attack_verdict.json). gl004_run.sh still names the file, so Phase 0 of GL-004 does not re-run from this copy.
• Paraphrased: the owner's words, per the owner (PUBLIC-COPY-CHANGES.md). The study's thesis is stated as the study's thesis.
• Neutralised: machine and session names, replaced by role names such as "the existence host", "the GPU host" and "the runner maintainers' session" (three mentions in QUEUE-2026-10-01.md from the 2026-10-04 update, the rest of the record in the 2026-10-09 cleanup, GL-021's files as they were added on 2026-10-13 and 2026-10-14, and GL-021b's and GL-022's on 2026-10-15), and the local commit identity in the commit and chain scripts, replaced by <commit-identity>. Since 2026-10-15 the GPU slice's device identifier is replaced throughout, archives included, by a placeholder of the same length, MIG-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (PUBLIC-COPY-CHANGES.md).

Reproduction. Each study's run script (gl0xx_run.sh; GL-001: experiment.py) runs its phases in order, and its preregistration names the exact seeds, budgets and thresholds. The model card's Reproduce section gives GL-003c's commands. Tasks are generated from fixed seeds (gl003_tasks.py, gl003c_tasks.py), so no external data is needed. Each study's *_analyze.py recomputes its decision from the run records and raw archives. The core line ran on CPU with Python 3.12 and torch 2.11.0; GL-014 and GL-020 also used the GPU slice.

Result. The synthesis's surviving claim, as narrowly as the record requires: on one shared CPU host, in one synthetic list-program DSL, a 0.69 M-parameter model trained from scratch only on its own executed programs, relabelled with the outputs the host computed for them, solved more held-out size-6 to 8 tasks than the best blind search tried (a genetic algorithm) at equal executions, in every study that measured it after the first attempt was killed. In one confirmatory study, with its whole training CPU charged to a single 1,800-task stream, it also led at equal CPU-seconds by +0.037 [+0.018, +0.056], a margin not resolved on the first 1,200 tasks or at size 8. Separately, and never combined with that model, a 438,288-parameter model trained only on the final answer of a synthetic 8-state lookup task, under a depth curriculum, formed a continuous intermediate medium. That medium matched the program-supplied state trace's accuracy in 7 of 9 fresh seeds across two studies, answered about 1.6× faster at batch 1 on this CPU through 5 serial passes instead of 9, and stayed readable by a simple outside probe.

Correction, 2026-10-02 (GL-008): the medium's 1.6× is a pass-count effect. An explicit terse trace on the medium's own schedule, trained the same way, keeps it (1.60× over the full trace), formed on 24 of 24 seeds against the medium's 20 of 24, and came within 3% of the medium's latency. On this task the medium adds nothing measurable beyond brevity. What it contributed is the schedule it found, and it still forms from the final answer alone.

The case against, from the same synthesis:

• Scale and scope. Everything is a small synthetic DSL or lookup task, with no non-synthetic domain.
• The equal-CPU win. It is narrow, needs a long stream, and is level over 450-task streams.
• Hidden inputs. 45-65% of every arm's spec-consistent claims fail them, because "solved" means agreement on sampled behaviour, not proven equivalence.
• The second grammar was easy for grammar-1 cores.
• Size. A 4× larger core lost at equal FLOPs. (2026-10-04: with up to 4× the training FLOPs and a tuned learning rate it came level and never beat the recipe: GL-014.)
• Adaptive mechanisms. None paid: the per-host adapter lost to measurement (1.40× and 1.38× atlas), online updates were killed (GL-005), and a self-extracted vocabulary was killed (GL-007).
• The medium. It is readable by a probe, not machine-native in the strong sense. Discrete media form only about half the time, and the RL-trained-brevity control was never run.
• Adaptive programme. 15 of 18 studies were designed after earlier results.
• Load. Co-tenant load distorted CPU-seconds.
• Prior art already covers most parts.
• The thesis as a whole (a native medium inside a shared, portable, self-evolving core) was never run.

Since the synthesis (2026-10-02): the medium's control ran and matched it (GL-008); discrete formation reached 22 of 24 on a best-dev checkpoint with 4× the steps, but 17 of 24 on final weights (GL-010); and a deeper vocabulary was killed as well (GL-009).

Since then (2026-10-03): the core's hidden-input failures are more than the five examples force (GL-018); on fresh tasks its lead over the genetic algorithm at equal CPU-seconds was +0.085, with 45% of its claims wrong (GL-019); and a learning-rate fix for the medium's final-weight losses was killed (GL-010b). The core clearly beats a trivial opcode prior trained on its own data (GL-019).

Since then (2026-10-04): with up to 4× the training FLOPs and a tuned learning rate, a larger core came level with the recipe and never beat it (GL-014, killed by K2); GL-019's comparison covers only an opcode prior that never reads the task's examples; and claiming the fewest-opcode match instead of the first found lowered the core's wrong claims from 0.434 to 0.387 (GL-020, a narrow pass).

Since then (2026-10-08): an MLP that reads the examples, with no attention, matched the core at equal executions, 0.442 against 0.456 (GL-019b, killed by K1: "matched"); its lead at equal CPU-seconds is not certified.

Since then (2026-10-13): on DeepCoder's own benchmark, with every cost charged, a small transformer and an example-reading MLP each led a tuned blind search by about 0.18-0.20 at equal CPU-seconds, while DeepCoder's own method trailed it (GL-021, P-A survives; a rerun with the fits and the searches in one window certified that reading on 2026-10-14).

Since then (2026-10-15): on 3,925 fresh DeepCoder tasks, with fitting charged, the MLP was ahead of the transformer, 0.350 against 0.276 (GL-021b, MATCHED); GL-022, the same comparison on LambdaBeam's benchmark, is running.

On the track's kill-switch stages plus GL-007, the count is one pass against five kills.

Genesis II (GII-001, 2026-09-30): killed. One locked external replication, with no rescue by design, tested the surviving core result on 127 human-written list functions (LambdaBeam's handwritten tasks and Rule et al.'s list functions), judged on up to 77,437 inputs each. At equal executions the cores solved 0.247 against GA-512-graded's 0.249, −0.002 [−0.039, +0.036]; at equal CPU with training charged they were behind, −0.047 [−0.080, −0.015]. The in-distribution control reproduced (+0.273 [+0.232, +0.314]), so the advantage is specific to the synthetic generator's tasks. As secondaries, the cores led on LambdaBeam's tasks (+0.073 [+0.020, +0.133]) and trailed on Rule et al.'s (−0.053 [−0.101, −0.010]). The study cannot rule out a small advantage of about +0.03. The registered second-host check is deferred, and the genesis-language line stops here (genesis-language/report/GII-001.md; the update at the end of GENESIS-I.md).

Update, 2026-10-02: the parked hypotheses tested. On 2026-10-01 the owner queued the hypotheses parked at the freeze, each as a new preregistered study that reopens no earlier kill. Three on this branch have finished, unflattering results first:

• GL-008, killed, corrects the medium claim above. An explicit terse trace on the medium's own schedule, trained the same way, matched the continuous medium. It formed on 24 of 24 seeds against 20 of 24, with mean depth-8 accuracy 1.000 against 0.854, and its batch-1 CPU latency was 1.030× the medium's [1.023, 1.033], inside the 10% margin. The 1.6× is the pass schedule.
• GL-009, killed. Words of two operations with arguments do not pay against the same cores trained to the same FLOPs: 0.456 against 0.457, −0.001 [−0.020, +0.016]. GL-007's kill stands.
• GL-010, reliable with budget, on a knife edge. With 4× the steps, the soft sample's best-dev checkpoint held a discrete code in 22 of 24 runs, up from 16 (p 0.031, the minimum that rejects). On final weights it was only 17 of 24: five runs lost the code after forming it. The soft-hard gap is not the cause (K2 killed).

Reports: genesis-language/report/GL-008.md, GL-009.md and GL-010.md; the update at the end of GENESIS-I.md.

Update, 2026-10-03: the surviving result, measured; the medium line paused. On the genesis-crossing branch, GX-007 put the published cores in a propose-test-revise loop on GII-001's human-written tasks and was killed: −0.033 [−0.075, +0.008] against GA-512-graded, with 15% of the cores' accepted answers wrong, against 3.5% for a 7B code LLM in the same loop (crossing record; model card). The language queue then wound down by the owner's rule. On 2026-10-03, after an outside review, the owner reopened it for measurement only. Unflattering results first:

• GL-019, the lead is small and the claims are often wrong. On 900 fresh band tasks at equal CPU-seconds with training charged, the core solved 0.459 against GA-64-graded's 0.374 (+0.085 [+0.056, +0.114]), and 45% of its 2,259 claims fail the hidden inputs.
• GL-018, "headroom (resolved)". On the tasks the core claimed, the best rule reading only the five examples would be wrong on 0.291; the core is wrong on 0.469 (+0.179 [+0.163, +0.195]). Over all 1,800 band tasks that best rule passes 0.742; two well-chosen labels raise it to 0.963.
• GL-010b, killed (K1, K2). Dropping the learning rate to its floor at formation, the fix suggested by the exploratory diagnosis GL-010-D, cut drops after formation from 8 to 4 of 22 (p 0.125; at most 2 predicted) and moved final-weight formation from 17 to 16 of 24 (bar 20). It delayed the losses and did not prevent them. GL-010-D had found that 4 of GL-010's 5 final-weight losses never held a medium.
• GL-019, an opcode prior that ignores the examples falls far short. A 4-gram opcode prior fitted on the core's own hindsight buffers, never seeing the task's examples, charged its fitting, solved 0.180 at equal CPU-seconds against the core's 0.459 (+0.279 [+0.249, +0.310]). (Narrowed 2026-10-04; see below.)
• The medium line is paused. The owner paused it on 2026-10-02: GL-011 (the medium inside the core) and GL-012 (curriculum gates) are paused, not killed, and GL-010b was the one exception. The remaining language items run only on the owner's request.

Reports: genesis-language/report/GL-010-D.md, GL-010b.md, GL-018.md and GL-019.md; the update at the end of GENESIS-I.md.

Update, 2026-10-04: a larger core, the choice of claim, and a narrower GL-019 reading. Two more preregistered studies of the core ran on this branch with the owner's approval, and an outside review narrowed one reading of the update above. Unflattering results first:

• GL-019, narrowed. Its opcode 4-gram never saw the task's examples, so the core's lead over it shows that an unconditional opcode prior is not enough. It does not show that a transformer is needed: no non-transformer proposer that reads the examples was run. The registered label ("the transformer matters") stays in the record with this limit. Such a baseline (GL-019b) is queued and has not started.
• GL-014, killed (K2, level at 4×). At equal training FLOPs, GL-003f's width-×2 core (2.55 M parameters), with its learning rate chosen on a held-out split, trailed the 0.69 M recipe at 1×, 2× and 4× the budget: −0.040, −0.024 and −0.013 [−0.036, +0.011] (0.464 against 0.477 at 4×; every large seed below every small seed). A gain of 0.05 or more is ruled out at 4×; beyond 4× was not measured. The first registered verdict, "inconclusive" after 15 search shards crashed on the GPU slice, is kept; only those shards were rerun, under a written amendment, and they reproduced the crashed partial records exactly.
• GL-020, PASS, narrowly. With the published cores frozen and each search run to the full 50,000 executions, claiming the match with the fewest opcodes (chosen on a selection split) instead of the first found lowered the wrong-claim share on 1,500 fresh band tasks from 0.434 to 0.387: +0.047 [+0.031, +0.062], against a margin of 0.045. Under GII-001's stricter judge it read "unresolved" (+0.045 [+0.027, +0.062]). The rule spends the whole budget on every claim. It closes about 28% of the gap to GL-018's floor, and a program that passes the hidden inputs was among the matches for 82% of claims.

Reports: genesis-language/report/GL-014.md (with the first registered report, GL-014-attempt1.md) and GL-020.md; the update at the end of GENESIS-I.md.

Update, 2026-10-08: an example-reading MLP matches the core (GL-019b). The baseline that the update above said was queued ran with the owner's approval. The unflattering result first:

• GL-019b, killed by K1 ("matched"). Varied: only the proposer that orders programs for the same search (one sampling pass without replacement; the first program matching the 5 examples is final), on 1,500 fresh band tasks judged on 25 inputs. The proposers were the frozen cores (640 iterations); an MLP over the raw examples with an MLP decoder over the program prefix (no attention, no recurrence), fitted on the cores' own hindsight buffers; a nearest-neighbour proposer over the same buffers; and GL-019's 4-gram as a reference. At equal executions (one pass of 50,000 programs) the MLP solved 0.442 against the cores' 0.456: D = +0.015 [−0.003, +0.034], inside the registered margin of 0.05. At equal CPU-seconds with fitting charged, the registered primary axis, the MLP was ahead (0.546 against 0.456), but that reading is not certified: the phase that spent the CPU budgets ran under lighter load than the phase that set them (ratio 0.61, outside the registered [0.85, 1.15]). The nearest-neighbour proposer (0.198) and the 4-gram (0.007) stayed far behind at equal executions. The MLP's claims fail the hidden inputs as often as the cores' (44.3% against 43.8%).
• What it changes: the core's lead over blind search is reproduced, per execution, by a much simpler proposer that reads the same examples without attention. One DSL, one generator, synthetic band tasks, and two proposer families tried.

Report: genesis-language/report/GL-019b.md; the update at the end of GENESIS-I.md.

Update, 2026-10-13: DeepCoder's claim with every cost charged (GL-021), not certified. GL-019b's comparison was repeated on a field benchmark, DeepCoder's DSL and data protocol (Balog et al., ICLR 2017) through PCCoder's public implementation. It ran on CPU under the owner's pre-approval, after its feasibility stage (GL-021-F) read GO.

• Varied and measured. The proposer: a small transformer (tf) and an example-reading MLP (mlp) that write programs, DeepCoder's own method (dc, a learned attribute predictor ordering an enumeration), and five blind searches, DeepCoder's saa-prior baseline among them (the best on calibration tasks, B*, was bottom-up enumeration). The accounting: every cost charged (the corpus, the fitting and B*'s tuning, over a 1,800-task stream; primary), the field's (nothing charged), and equal executions. The criterion: the hidden inputs (primary) or the field's agreement with the examples. 1,500 fresh test tasks, c = 30 CPU-s per task, δ = 0.05.
• Observed, the unflattering results first. R0, DeepCoder's comparison in the field's terms, reproduces (+0.313 [+0.280, +0.350]), but its saa-prior baseline solved 1 task of 1,500. DeepCoder's own dc arm is behind B* at the primary axis: 0.236 against 0.307 (−0.071 [−0.107, −0.032]). The searches ran under heavier load than the fits (J7b: r_FS 1.25, outside the registered band [0.85, 1.15]), so the learned arms' fitting was charged at the lighter load.
• Survived, not certified: P-A. At equal CPU-seconds with every cost charged, tf solved 0.492 and mlp 0.505 against B*'s 0.307: +0.184 [+0.132, +0.243] and +0.198 [+0.163, +0.233], both lower bounds above δ. By the registered rule the load mismatch makes this SURVIVES, not certified. An exploratory recomputation, outside the registered set, keeps the pass with the learned arms' charge raised 1.3×.
• Failed or unresolved. Nothing was killed. P-B, the transformer minus the MLP at the primary axis, is unresolved: −0.014 [−0.071, +0.050], an upper bound 0.0002 above δ.
• Next. A certification rerun under matched load is under way (amendment, 2026-10-13); its result will be added as an addendum.

Reports: genesis-language/report/GL-021.md and GL-021-F.md (the feasibility stage); the choice of benchmark: genesis-language/PRIOR_ART-GL-021.md; the update at the end of GENESIS-I.md.

Update, 2026-10-14: GL-021 certified. The certification rerun named above finished on 2026-10-14, under an amendment registered before any of its data (GL-021 Amendment 2, 2026-10-13). GL-021's 12 fits and all 660 of its test searches were run again side by side in one window, so that the fits' charge was measured in the same window as the searches. B*, its tuning charge and the corpus charge were carried over.

• The rule, registered before the rerun. Certified only if no instrument check fires, r_FS falls within the registered band [0.85, 1.15], and the registered P-A rule, applied to the rerun, gives exactly GL-021's registered reading without its load phrase. Otherwise the registered reading stands, not certified, and there is no third run.
• Observed, the unflattering results first. r_FS was 1.124: inside the band, near its upper edge. Against GL-021's calibration phase the ratio r_AS was 1.40; by the registered rule only a value below 0.85 would have blocked. DeepCoder's own dc arm again trailed B* (−0.073 [−0.109, −0.034]). No instrument check fired, and R0 reproduced again (+0.314 [+0.280, +0.351]).
• Certified: P-A. With the refits' charges and the new searches, tf solved 0.481 and mlp 0.496 against B*'s 0.309: +0.172 [+0.144, +0.202] and +0.187 [+0.156, +0.217], both lower bounds above δ. That is the registered reading, SURVIVES, which now stands without its "not certified" qualifier. GL-021's decision.json is not rewritten.
• Unchanged: P-B. It stays unresolved, as registered. The rerun's own transformer-minus-MLP difference, −0.014 [−0.046, +0.018], is reported only and changes no reading.

Report: genesis-language/report/GL-021-cert.md (rendered from runs/GL-021-cert/certification.json); the amendment at the end of genesis-language/prereg/GL-021.md; the update at the end of GENESIS-I.md.

Update, 2026-10-15: GL-021b settles the transformer against the MLP; GL-022's feasibility stage; the line closes. Both studies ran on CPU under the owner's approval of 2026-10-14.

• GL-021b, observed, the unflattering results first. The searches ran under much heavier load than the fits (r_FS 2.421, outside the registered band [0.85, 1.15]); by the registered rule that adds no qualifier to this reading, because the bias runs against it. The time cap stopped the searches at 3,925 of 4,500 fresh tasks, and the reading uses the complete prefix, as registered. With three fits per arm the seed-level sign-flip test cannot decide (p 1.000). At equal executions, with no CPU in the reading, the transformer was ahead of the MLP by δ or more (secondary S1).
• GL-021b, survived: MATCHED (K1-B). On DeepCoder's benchmark, at equal CPU-seconds with fitting charged, the transformer minus the MLP was −0.074 [−0.101, −0.045] (0.276 against 0.350): the MLP comes within δ = 0.05 of the transformer, and is ahead of it. GL-021's P-B, unresolved by 0.0002, is resolved in this direction, on fresh tasks with GL-021's fits and budgets. With the certification's charges (SC, reported only) the reading is the same, −0.106 [−0.148, −0.061].
• GL-022-F, LambdaBeam's benchmark: AMEND, AMEND, then GO. The feasibility stage makes no claim about any arm, and every pilot rate is discarded. Its first launch failed only the band check: the tuned blind search solved 0.816 of the pilot's test tasks against [0.05, 0.60]. The owner chose harder tasks (Amendment 1: program weights 7 to 9). The second launch (GL-022-F2) passed the band (0.492) and failed the power rule: the MLP's four pilot fits differed (0.495 to 0.581), and no (N, K) in the registered grid met its bars. The owner chose to widen the grid of fits per arm (Amendment 2, which discloses F2's power table and an exploratory check on the same records). Only the decision was rerun, on F2's records, and it read GO at N = 2,000 tasks and K = 20 fits per learned arm (projected 25.9 h). The choice sits close to the bar: the MLP's power share is 0.875 and 0.89 against 0.85, with an SE of about 0.025.
• GL-022: running. Its preregistration with both amendments, its sizing and Phase 0's record are here. No result exists yet, and none is in this record.
• The line closes. On 2026-10-15 the owner closed this chapter of GENESIS: the comparison of learning with search, with every cost charged, ends with GL-022. The synthesis records what was learned on the way.

Reports: genesis-language/report/GL-021b.md, and GL-022-F.md, GL-022-F2.md and GL-022-F2-a2.md (GL-022-F's two launches and the second's decision under Amendment 2); the choice of benchmark: genesis-language/PRIOR_ART-GL-022.md; the update at the end of GENESIS-I.md.

Update, 2026-10-22: GL-022's result, the line's last study. The study ran on CPU and is reported as preregistered.

• The setting: LambdaBeam's benchmark, 2,000 fresh tasks of program weight 7 to 9, every cost charged over 1,800 tasks at c = 30 CPU-s.
• Survived, narrowly (P-A): the example-reading MLP solved 0.541 against the tuned blind search's 0.473. That is E = +0.067 [+0.040, +0.094], with a Bonferroni lower bound of +0.037. It passes the registered rule (lower bound above 0, estimate at least δ = 0.05), but its lower bound does not reach δ.
• The transformer was not ahead: +0.007 [−0.016, +0.031].
• The registered load check qualifies it: the searches ran under heavier load than the calibration (r_AS 1.556, outside [0.85, 1.15]), so the blind search's tuning charge is not certified.
• The secondaries are mixed:
  • it survives at equal candidates and under the field's criterion;
  • it is killed in the field's accounting (nothing charged), at c = 7.5, and over 18,000 tasks;
  • the field's own model is ahead in its own terms (+0.132) and behind under the hidden criterion (−0.165).
• Reading: a narrow, conditional result about the economics of search. On its own it does not advance a native machine language, and it closes the comparison of learning with search as planned.

Report: genesis-language/report/GL-022.md (rendered from genesis-language/runs/GL-022/decision.json).

Links.

• The whole programme: GENESIS: one research arc, the one-page synthesis of all three tracks
• Model card: https://huggingface.co/Joakimpalm-Zen/Xyntetik-Blad-Genesis-0.7M
• Collection: Xyntetik Research: GENESIS (https://huggingface.co/collections/Joakimpalm-Zen/xyntetik-research-genesis-6abcfa50b6707dec9bfee356)
• Later evaluations of the published cores (GX-002 to GX-007): the crossing record, https://huggingface.co/datasets/Joakimpalm-Zen/Xyntetik-Genesis-Crossing-record
• Start with genesis-language/SYNTHESIS-GENESIS-I.md, then genesis-language/PLAN.md
• Language-Extended (LX-001, 2026-10-30): genesis-language-extended/report/LX-001.md

The model repository carries only the released weights, a minimal CPU runner, three unchanged harness modules and GENESIS.json. This dataset is the first-class home of the evidence, so the record can be cited and browsed without the weights. The continuous-medium checkpoints and the raw archives are distributed here only.

Addendum (2026-10-10): RK-001 reproduced on a second architecture

The reproduction kit (repro-kit/, RK-001) also ran on an Apple arm64 host (Apple Accelerate), macOS. It was an additional host under RK-001's Addendum A: the kit was unchanged, its six code files were hash-checked, and the record was pinned at 5d11dc30.

• Part R: every re-derived number matches the published records to the printed digit.
• GL-003d: reproduced. Over 300 fresh tasks, the core minus GA-64-graded at 50,000 executions is D = +0.320 [+0.266, +0.376]; published +0.276 [+0.254, +0.298].
• GL-019b: reproduced. Over 900 fresh tasks, the core minus the refitted MLP at equal executions is D = +0.013 [−0.011, +0.037]; published +0.015 [−0.003, +0.034].
• The results pack: repro-kit/results/additional-host-arm64/ (sha256 in its file name's .sha256). CPU-seconds are descriptive only and do not transfer across hosts.

The registered reproduction host (Windows, x86-64) runs the same kit separately; its result follows in a later addendum.

Addendum (2026-10-11): RK-001 on the registered reproduction host

The registered reproduction host also ran RK-001: Windows 11, Intel x86-64 with AVX2, torch 2.11.0+cpu. The kit was unchanged, with its six code files hash-checked. Part S finished on 2026-10-11 at 01:14.

• Part R: every re-derived number matches the published records to the printed digit.
• GL-003d: reproduced. Over 300 fresh tasks, D = +0.323 [+0.270, +0.378]; published +0.276 [+0.254, +0.298].
• GL-019b: reproduced. Over 900 fresh tasks, D = +0.014 [−0.010, +0.037]; published +0.015 [−0.003, +0.034].
• The results pack: repro-kit/results/registered-host-x86-64/ (sha256 in its .sha256 file).
• The run's one interruption: the operator's pre-run scan flagged one published module that calls a subprocess. On review it is a read-only git log used for listing commits, with its hash matching the kit's pin. Part S then ran unchanged.

With the arm64 run above, both published results now reproduce on three hosts across two architectures and three operating systems.

Addendum (2026-10-30): Language-Extended (LX-001), a typed interface loses to code

A later track tested whether a language model does better writing a typed operation structure, checked and run by an interpreter, than writing code, with GL-021's tuned blind search as a third arm. Preregistered, with a feasibility stage first. Unflattering first: it does not.

• K1: Qwen2.5-Coder-7B solves 3.9% of 3,000 generated tasks in the typed form and 25.8% in Python, D = −0.219 [−0.236, −0.202].
• K2, on both task sets: blind search solves 64.3% of the generated tasks and 87.0% of the 46 human-written ones at the matched budget, ahead of both model arms.
• Typing: 47.9% of the typed arm's final answers were ill-typed; the schema constraint fixes shape, not types.
• Limits: one model read (the Qwen3-4B replication was stopped by the owner after 606 tasks, its rows unread), and the human-written set is the 46 tasks the language can express.

The track is closed. The full reading is the last section of GENESIS-I.md; the record is under genesis-language-extended/.

About Xyntetik

This repository is published by Xyntetik, the Zenova AB program for running capable language models on hardware you own and proving what they did. Its released engine is Xyntetik Runner: a free, single-binary GGUF engine in C for CPU, CUDA and Metal that serves, scores and trains through the quantized file it deploys and records every run as a receipt. The measurements behind the program's claims are collected at xyntetik.com/evidence. The program's organization on Hugging Face is Xyntetik.