Architectural Specification for Generational Parent Pool Evolution and Provenance Lineage in Model Breeding Schedules

Full report

On this page

The paradigm shift from training static machine learning architectures on isolated datasets to continuous, open-ended neuroevolution, population-based training, and systematic model breeding has introduced significant engineering complexity.1 Within this operational landscape, trained parameter matrices are no longer viewed merely as static weights of a mathematical function.3 Instead, they are treated as structured data points residing within a continuous, high-dimensional weight space.3 This weight space exhibits its own geometric constraints, symmetries, and functional regularities that can be modeled, mapped, and mathematically navigated to synthesize novel capabilities.3 To govern this process at scale, metadata lineage systems must track how metadata about these data assets is captured, propagated, and versioned over generations.5 Without detailed point-in-time reconstruction of evolving parent pools, AI operations are vulnerable to silent data corruption, unidentifiable model degradation, and audit failures under emerging global AI compliance frameworks.5 This report provides a formal technical specification for managing metadata within model breeding schedules, defining parent relatedness metrics, multi-objective fitness structures, behavioral novelty algorithms, weight space operators, and schema-gated provenance receipts. The operational and governance requirements of a modern model breeding pipeline require a clear division between data lineage and data provenance, as detailed in the comparison below:

Schedule Orchestration and Hierarchical Execution IDs

Model breeding schedules operate as distributed, hierarchical workflows executed across multi-tenant GPU environments.13 Managing the parent pool over generations requires representing these schedules as parent and child runs.15 Within this architecture, the overall breeding schedule is assigned a unique, immutable Schedule ID.15 This ID is logged as a Parent Run inside a centralized experiment tracking engine, such as MLflow or Databricks Unity Catalog.15 Each distinct generation [Figure omitted from source export] or hyperparameter optimization loop is executed as a nested Child Run using the nested=True programmatic context.15 This hierarchical arrangement ensures that the parameters, scores, and parent-child relationships of each generation remain bound to the overarching schedule.15 In practice, executing nested runs in custom experiment locations can cause child runs to dissociate from their parents in the graphical user interface.17 This occurs because child processes may resolve a different experiment\_id associated with local workspace directories.17 To prevent this UI dissociation and ensure complete lineage, the orchestrator must programmatically retrieve the parent's experiment\_id during initialization and explicitly pass it to the child runs.17 The parent\_run\_id is then stored in the child's metadata search space.17 This pattern maps directly to the OpenLineage object hierarchy.18 Here, the Job represents a static, design-time lineage mapping (such as a template model breeding schedule), and the Run represents a specific, time-bound execution of that schedule.18 Each Run is assigned a universally unique identifier (UUIDv4) that acts as the anchor for all emitted lifecycle event metadata.18

Theoretical Genetics, Pedigree Metrics, and Realized Relatedness

Managing a parent pool requires monitoring the genetic variation, coancestry, and inbreeding rates of the candidate models.21 In early evolutionary algorithms, genetic metrics were computed post-hoc from simple pedigree tables.22 However, using only pedigree information introduces significant upward bias in heritability and genetic gain estimations compared to using genome-wide distributed molecular markers.22 To prevent this bias and control inbreeding depression, modern model breeding systems utilize both pedigree-based relationship models and marker-based realized genomic relationship models.21

Pedigree-Based and Marker-Based Matrices

The pedigree-based relationships are represented via the standard Numerator Relationship Matrix, or [Figure omitted from source export]\-matrix, whose inverse is used in solving mixed model equations to compute genomic-estimated breeding values (GEBVs) via Best Linear Unbiased Prediction (BLUP).22 The mathematical structure of the [Figure omitted from source export]\-matrix is defined such that its diagonal elements represent [Figure omitted from source export], where [Figure omitted from source export] is the inbreeding coefficient of individual model [Figure omitted from source export].22 Its off-diagonal elements represent twice the coancestry coefficient between individual models [Figure omitted from source export] and [Figure omitted from source export], tracking the probability of identical genes by descent.22 For high-dimensional parameter spaces, the standard pedigree-based [Figure omitted from source export]\-matrix is replaced by the marker-based Realized Genomic Relationship Matrix, or [Figure omitted from source export]\-matrix.22 This substitution enables Genomic Best Linear Unbiased Prediction (GBLUP) or single-step GBLUP (ssGBLUP) models to blend genotypic and pedigree signals.22 The [Figure omitted from source export]\-matrix is computed using centered allele content and origin matrices derived from the model parameter snapshots.24 Software frameworks such as the R-package SimpleMating consume these matrices to execute optimal cross selection.21 This optimization maximizes a target performance criterion (such as the mid-parental value or cross usefulness) while applying hard constraints to coancestry and the maximum allowable parental relationship.21

Decentralized Phylogenetic Tracking via Hereditary Stratigraphy

While centralized relationship matrices are effective for local populations, they become bottlenecked in distributed, large-scale parallel simulations.25 In systems where model lineages migrate across independent processing nodes, maintaining a centralized record of every birth, mutation, and termination introduces extreme communication overhead.25 To resolve this limitation, the system integrates Hereditary Stratigraphy via the hstrat library.25 This decentralized technique allows phylogenetic history to be inferred post-hoc from heritable, neutral genetic annotations—termed hereditary stratigraphic columns—attached directly to the model genomes.25 At each generation, an active model appends a new chronological marker, known as a differentia, to its stratigraphic column.26 When offspring are generated through mutation or crossover, they inherit this stratigraphic column.25 Because appending a differentia at every step would cause the columns to grow indefinitely, the library implements a stratum retention policy to systematically discard older strata.27 This policy manages the trade-off between annotation memory footprint and historical inference accuracy.25 For example, a recency-proportional resolution policy downsamples older historical records while maintaining fine-grained resolution for recent generations.25 This allows annotations to fit within tight budgets (e.g., 64 bits per column).25

Distance Reconstruction

By comparing the stratigraphic columns of two extant models, [Figure omitted from source export] and [Figure omitted from source export], the system reconstructs their shared evolutionary tree.25 Divergences between differentia values are used to estimate the generation of their Most Recent Common Ancestor ([Figure omitted from source export]).25 The pairwise distance [Figure omitted from source export] is computed as the shortest path between the two models on the reconstructed phylogenetic tree 29: [Figure omitted from source export] For synchronized generations where [Figure omitted from source export], this simplifies to [Figure omitted from source export].29 In trie-building and tree reconstruction, missing marker time points resulting from the retention policy act as wildcard characters, requiring the reconstruction algorithm to evaluate multiple diverging string paths to resolve downstream relationships.26 The different tracing and tracking methodologies are compared below to highlight their trade-offs in distributed parent pool environments:

Multi-Objective Fitness Vectors, Performance Gates, and Explanatory Analytics

Model breeding systems operate under continuous resource constraints, making scalar fitness evaluations deceptive and insufficient.2 Instead, the breeding schedule evaluates candidates using a multi-objective fitness vector [Figure omitted from source export]: [Figure omitted from source export] These objectives are derived from target execution environments and subjected to hard performance gates to filter viable parents.2

Benchmark Environments and Evaluation Gates

In population-based training and evolutionary recipe optimization, several standard task environments provide the metrics and constraints used to construct these fitness vectors 2:

• Parameter Golf: This environment evaluates models on fine-web datasets.2 The primary fitness objective is to minimize validation bits per byte (bpb).2 To remain viable, the model must satisfy a strict size cap ([Figure omitted from source export] MB) and execute within a tight computational budget ([Figure omitted from source export] minutes on 8 H100 GPUs).2
• NanoChat-D12: This setup measures a model's CORE pretraining score, targeting a baseline of 0.1618 CORE.2 The main fitness objective is maximizing computational efficiency within a fixed wallclock budget.2 Speed gains are translated into training on more tokens to improve final performance.2
• CIFAR-10 Airbench96: This environment rewards minimizing cold-process execution wallclock time.2 Crucially, the wallclock timing is subjected to an accuracy gate.2 A model's score is considered valid only when its mean accuracy reaches a minimum threshold ([Figure omitted from source export]).2

AutoML Optimization and Explanatory Analytics

During parent evaluation, AutoML tools are deployed to automate data preprocessing, neural architecture search, and hyperparameter tuning.32 For instance, frameworks like AutoKeras split datasets into inner training and inner validation sets to optimize hyperparameters before predicting on an outer validation set.35 To prevent target leakage and ensure explainability, the evaluation pipeline integrates game-theoretic metrics.34 In classification and regression runs (such as those orchestrated via Databricks AutoML using PyPI's databricks-automl-runtime), SHapley Additive exPlanations (SHAP) are calculated to estimate the impact of individual features on model predictions.34 These SHAP values are logged directly as part of the parent's evaluation metadata.13 This step ensures that any target leakage is identified before deployment, making the entire evolutionary process reproducible and auditable.13

Behavioral Space Modeling, Dominated Novelty, and Diverse Exploratory Search

A major limitation of purely objective-based selection is its susceptibility to local optima.31 To address this deception, the breeding engine integrates Novelty Search, a paradigm that prioritizes behavioral exploration over direct optimization.38 Each candidate model is mapped to a low-dimensional descriptor vector [Figure omitted from source export] within a continuous behavior space [Figure omitted from source export], representing the observable output of the model.38 In a classic novelty search, the novelty score of a model [Figure omitted from source export] is calculated as the average distance to its [Figure omitted from source export]\-nearest neighbors within the active population [Figure omitted from source export] and an archive of past novel behaviors [Figure omitted from source export] 38: [Figure omitted from source export] where [Figure omitted from source export] represent the [Figure omitted from source export]\-nearest neighbors in [Figure omitted from source export] based on a behavioral distance metric, such as Euclidean, Manhattan, or Hamming distance.38

Dominated Novelty Search

Traditional quality-diversity algorithms (like MAP-Elites) rely on partitioning the behavior space into predefined grid structures.42 This discretization requires knowing the bounds of the behavior space in advance, which is impractical in unsupervised quality-diversity systems where the descriptor space is learned dynamically during evolution.42 To overcome this, the breeding engine implements Dominated Novelty Search, an unstructured algorithm that structures local competition without requiring predefined grids or fixed distance thresholds.42 Dominated Novelty Search executes through a three-step dynamic transformation 42:

[Figure omitted from source export]

[Figure omitted from source export]

[Figure omitted from source export] where [Figure omitted from source export] is the set containing the indices of the [Figure omitted from source export] solutions in [Figure omitted from source export] with the smallest behavioral distances [Figure omitted from source export].42 If the count of fitter solutions is less than [Figure omitted from source export], all available fitter solutions are used.42

1. For each model [Figure omitted from source export] in the population, the system identifies all models that exhibit superior objective fitness 42:
2. The pairwise distances in the continuous behavior space between model [Figure omitted from source export] and all fitter solutions are calculated 42:
3. The competition fitness [Figure omitted from source export] is computed as the average distance to the [Figure omitted from source export]\-nearest fitter solutions 42:

This formulation creates dynamic, self-organizing niches within the parameter space, allowing promising but currently underperforming models to survive if they explore unique behavioral regions.39

Alternative Exploratory Strategies

The framework can also utilize alternative search techniques 41:

• Evolution-Guided Reinforcement Learning (ERL): This hybrid approach periodically inserts deep reinforcement learning agents into the evolutionary loop, reusing historical off-policy samples to improve diversity and sample efficiency.43
• Surprise Search: Rather than measuring absolute distance to historical points, surprise search evaluates the deviation of a model's behavior from local prediction trends.41 This strategy has been shown to produce greater behavioral coverage and more robust navigation in complex environments.41

The primary features of these exploratory search strategies are compared below:

Weight Space Representation, Merging, and Interpolation Seeds

Generating descendant models from selected parent pools requires operators that can recombine neural network parameters while preserving functional properties.3 Weight Space Representation (WSR) and Weight Space Generation (WSG) provide the mathematical frameworks for direct reasoning and manipulation of models as geometric objects.3 This allows for operations such as model retrieval, model editing, and evolutionary model merging.3

Backward Compatible Weight Interpolation (BCWI)

When a model is updated to incorporate new training data, standard retraining can introduce negative flips, causing previously correct predictions to become incorrect.44 This regression and prediction jitter can be mitigated using Backward Compatible Weight Interpolation (BCWI).44 BCWI interpolates between the parameters of the ancestral base model ([Figure omitted from source export]) and the newly optimized model ([Figure omitted from source export]) 44: [Figure omitted from source export] where the interpolation seed weight $\\alpha \\in $ determines the blending ratio.44 By moving the new model closer to the old model post-training, BCWI reduces the Negative Flip Rate (NFR) over evaluation datasets 44: [Figure omitted from source export] This formulation minimizes prediction churn without sacrificing the performance gains of the new model.44 This post-training weight interpolation differs from online weight regularization techniques such as Prior Weight Decay or Mixout, which adjust the weights at each training step.44

Diffusion Crossover and Evolutionary Model Merging

For generative models (such as Denoising Diffusion Probabilistic Models), linear interpolation of weights can lead to out-of-distribution artifacts.45 The engine instead utilizes Diffusion Crossover, applying Spherical Linear Interpolation (Slerp) to the step-wise noise sequences ([Figure omitted from source export]) in the reverse denoising process 45: [Figure omitted from source export] where [Figure omitted from source export] represents the angular distance between the parent noise sequences.45 This ensures that the generated offspring inherit structural characteristics from both parents while maintaining the geometric properties of the diffusion manifold.45 To scale model breeding to consumer-grade hardware, evolutionary model merging frameworks such as MERGE^3 and Mergenetic incorporate lightweight fitness estimators.30 These systems extract a reduced dataset for evaluation and estimate candidate model capabilities using Item Response Theory (IRT).30 This IRT-based performance estimation reduces fitness computation costs 50-fold, allowing the evolutionary search to proceed on a single GPU.30

Promotion Lifecycles, Failure Auditing, and Unified Lineage Feedback

Managing the parent pool requires a structured promotion lifecycle governed by state transitions.2 Candidates are processed through several states to determine their suitability for the parent pool 2:

\[ Unvalidated Candidate \] | v \[ Validation Pipeline \] | \--------------------------------------- | | v (Executes Successfully) v (Fails Validation)

| v \[ Evaluation Gates \] | \------------------------------------------------- | | | v (Passes All Gates) v (Misses Performance Gate) v (Violates Size/Time Limit)

• PROMOTED: The candidate passes all performance gates, size constraints, and latency budgets, and is added to the active parent pool.2
• NEAR\_MISS: The candidate executes within resource constraints but fails to meet a performance gate (e.g., scoring [Figure omitted from source export] accuracy against a [Figure omitted from source export] threshold on CIFAR-10 Airbench96).2
• BUDGET\_OVERRUN / SIZE\_FAILURE: The candidate violates resource limits, such as exceeding the 10-minute GPU budget or the 16 MB size cap in Parameter Golf.2
• CRASHED / FAILED: The candidate run encounters execution-level errors or system failures.2
• EVICTED: An active parent is removed from the pool to accommodate a more fit or novel candidate.38

Traditional hyperparameter optimization and neural architecture search frameworks treat evaluations as independent trials.2 In contrast, a breeding engine with Lineage Feedback utilizes the cross-trial history—including crashes, overruns, and near-misses—to guide subsequent generations.2 Near-misses are kept in the lineage history rather than discarded.2 This ensures that fast, near-compliant models can be used by the mutation operators to guide recipe edits, converting historical failure states into informative search steps.2

Schema-Gated Provenance Receipts and OpenLineage Integration

To establish an auditable record of the model breeding process, the orchestrator generates a Provenance Receipt at each generation.14 These receipts integrate the W3C PROV-DM conceptual model, the SLSA Provenance v1.0 specification, and the OpenLineage custom facets framework.14

OpenLineage Custom Facet Architecture

In OpenLineage, custom metadata is structured as a custom facet.19 This facet is defined as a JSON object and attached to the run, job, or dataset entities.19 To integrate model breeding metadata, the system implements a custom run facet:

• Naming Conventions: The facet class is defined as ModelBreedingScheduleRunFacet.19 In the OpenLineage event payload, the facet is represented as a snake\_case key: model\_breeding\_schedule.19
• Mandatory Keys: To be accepted and stored by compatible backends (such as Marquez), the custom facet must inherit from BaseFacet and include the \_producer and \_schemaURL properties.50
• SDK Implementation: In Python, the custom facet class is implemented using the @attr.define decorator, extending BaseFacet and overriding the static \_get\_schema() method to return the versioned URI of its JSON Schema 50:

Python @attr.define class ModelBreedingScheduleRunFacet(BaseFacet): schedule\_id: str generation: int parent\_pool\_metadata: dict

def \_\_init\_\_(self, schedule\_id, generation, parent\_pool\_metadata): super().\_\_init\_\_() self.schedule\_id \= schedule\_id self.generation \= generation self.parent\_pool\_metadata \= parent\_pool\_metadata

@staticmethod def \_get\_schema() \-\> str: return "https://raw.githubusercontent.com/openlineage/facets/1-0-2/ModelBreedingScheduleRunFacet.json"

To ensure backward compatibility and prevent client code generation failures during compilation, any modifications to the facet's schema must bump the version number in the $id URL (e.g., from 1-0-1 to 1-0-2).51 All changes must be validated locally using prek run and committed with GPG signatures (git commit \-s).51

Upstream Parser Extraction and Bounding Box Grounding

To prevent target leakage and document the origin of the features, the lineage system utilizes abstract syntax tree (AST) parsing.5 The parser reads upstream SQL queries, dbt models, and feature extraction scripts, converting the source code into syntax trees to map column-level dependencies before training occurs.5 To support rigorous audits, the provenance receipt incorporates grounded-extraction metadata based on the Reducto standard.52 This grounds all extracted parameters with calibrated confidence scores and source citations.52 For document-based sources (such as model cards or papers), citations use normalized coordinates (value, confidence, page index, and bounding boxes).52 For tabular data, citations map to 1-indexed spreadsheet coordinates (sheet index, row, column, and cell spans).52

JSON Schema Specification

The complete, schema-gated structure of the breeding run receipt is defined by the JSON Schema below. This schema integrates SLSA v1.0 parameters (identifying the trusted build platform and resolved dependencies) with the HDI-Project model-provenance-json standard to document predictions, features, data splits, and modeling budgets 14:

JSON { "$schema": "http://json-schema.org/draft-07/schema\#", "$id": "https://raw.githubusercontent.com/openlineage/facets/1-0-2/ModelBreedingScheduleRunFacet.json", "title": "ModelBreedingScheduleRunFacet", "description": "JSON Schema governing generational parent pool metadata and evolutionary model breeding provenance.", "type": "object", "properties": { "\_producer": { "type": "string", "format": "uri", "description": "URI of the generating metadata producer." }, "\_schemaURL": { "type": "string", "format": "uri", "description": "Versioned canonical URL of this schema." }, "schedule\_id": { "type": "string", "format": "uuid", "description": "Schedule ID logged as the parent run." }, "generation": { "type": "integer", "minimum": 0, "description": "Evolutionary generation cycle index." }, "slsa\_provenance": { "type": "object", "required": \["builder\_id", "build\_type", "external\_parameters", "system\_parameters", "resolved\_dependencies"\], "properties": { "builder\_id": { "type": "string", "format": "uri" }, "build\_type": { "type": "string", "format": "uri" }, "external\_parameters": { "type": "object" }, "system\_parameters": { "type": "object" }, "resolved\_dependencies": { "type": "array", "items": { "type": "object", "required": \["uri", "digest"\], "properties": { "uri": { "type": "string", "format": "uri" }, "digest": { "type": "object", "additionalProperties": { "type": "string" } } } } } } }, "hdi\_provenance": { "type": "object", "required": \["prediction\_engineering", "feature\_engineering", "data\_splits", "modeling\_budget"\], "properties": { "prediction\_engineering": { "type": "object", "required": \["target\_variable", "prediction\_type"\], "properties": { "target\_variable": { "type": "string" }, "prediction\_type": { "type": "string", "enum": \["classification", "regression"\] } } }, "feature\_engineering": { "type": "object", "required": \["method", "parameters", "training\_window"\], "properties": { "method": { "type": "string" }, "parameters": { "type": "object", "properties": { "aggregate\_primitives": { "type": "array", "items": { "type": "string" } }, "transform\_primitives": { "type": "array", "items": { "type": "string" } } } }, "training\_window": { "type": "string" } } }, "data\_splits": { "type": "array", "items": { "type": "object", "required": \["id", "start\_time", "end\_time", "label\_search\_parameters"\], "properties": { "id": { "type": "string" }, "start\_time": { "type": "string", "format": "date-time" }, "end\_time": { "type": "string", "format": "date-time" }, "label\_search\_parameters": { "type": "object", "required": \["offset", "strategy", "examples\_per\_instance", "gap"\], "properties": { "offset": { "type": "string" }, "strategy": { "type": "string" }, "examples\_per\_instance": { "type": "integer" }, "gap": { "type": "string" } } } } } }, "modeling\_budget": { "type": "object", "required": \["max\_time\_seconds", "max\_models"\], "properties": { "max\_time\_seconds": { "type": "integer" }, "max\_models": { "type": "integer" } } } } }, "parent\_pool\_metadata": { "type": "object", "required": \["parent\_relatedness", "fitness\_vectors", "novelty\_scores", "seed\_weights", "promotion\_history"\], "properties": { "parent\_relatedness": { "type": "object", "required": \["stratum\_retention\_policy", "pairwise\_distances"\], "properties": { "stratum\_retention\_policy": { "type": "string" }, "pairwise\_distances": { "type": "array", "items": { "type": "object", "required": \["parent\_a\_id", "parent\_b\_id", "distance"\], "properties": { "parent\_a\_id": { "type": "string" }, "parent\_b\_id": { "type": "string" }, "distance": { "type": "number" } } } } } }, "fitness\_vectors": { "type": "array", "items": { "type": "object", "required": \["model\_id", "vector"\], "properties": { "model\_id": { "type": "string" }, "vector": { "type": "object", "required": \["f\_perf", "f\_size", "f\_latency", "f\_comp"\], "properties": { "f\_perf": { "type": "number" }, "f\_size": { "type": "number" }, "f\_latency": { "type": "number" }, "f\_comp": { "type": "number" } } } } } }, "novelty\_scores": { "type": "array", "items": { "type": "object", "required": \["model\_id", "score", "k\_neighbors"\], "properties": { "model\_id": { "type": "string" }, "score": { "type": "number" }, "k\_neighbors": { "type": "integer" } } } }, "seed\_weights": { "type": "array", "items": { "type": "object", "required": \["model\_id", "interpolation\_coefficient", "parent\_ids"\], "properties": { "model\_id": { "type": "string" }, "interpolation\_coefficient": { "type": "number" }, "parent\_ids": { "type": "array", "items": { "type": "string" } } } } }, "promotion\_history": { "type": "array", "items": { "type": "object", "required": \["model\_id", "status", "timestamp", "evicted\_model\_id"\], "properties": { "model\_id": { "type": "string" }, "status": { "type": "string", "enum": }, "timestamp": { "type": "string", "format": "date-time" }, "evicted\_model\_id": { "type": \["string", "null"\] } } } } } }, "grounded\_citations": { "type": "array", "items": { "type": "object", "required": \["field\_path", "value", "confidence", "citations"\], "properties": { "field\_path": { "type": "string" }, "value": { "type": "string" }, "confidence": { "type": "number", "minimum": 0.0, "maximum": 1.0 }, "citations": { "type": "array", "items": { "type": "object", "required": \["page", "bbox"\], "properties": { "page": { "type": "integer" }, "bbox": { "type": "object", "required": \["left", "top", "width", "height"\], "properties": { "left": { "type": "number" }, "top": { "type": "number" }, "width": { "type": "number" }, "height": { "type": "number" } } }, "cell\_coordinates": { "type": "object", "required": \["column", "row", "col\_span", "row\_span"\], "properties": { "column": { "type": "integer" }, "row": { "type": "integer" }, "col\_span": { "type": "integer" }, "row\_span": { "type": "integer" } } } } } } } } } }, "required": }

Security Enforcement, Tamper-Evidence, and Compliant Verification

Because provenance receipts serve as verifiable evidence for compliance audits, they must be protected against retroactively altered metrics and unauthorized modifications.48 The system runs each emitted receipt through a standardized verification pipeline before persisting it in the registry 48:

| v \---\> Sort keys, strip spaces | v \---------\> Generate digital fingerprint | v \------\> Encrypt hash with Private Key | v

1. Deterministic Serialization: The JSON document keys are sorted alphabetically, and all redundant whitespace is removed.48 This step ensures a consistent string representation regardless of formatting differences across software environments.48
2. Cryptographic Hashing: A SHA-256 hash is computed over the normalized string, establishing a unique digital fingerprint of the generation's state.48
3. Digital Signature: This hash is encrypted using the private key of the authorized breeding engine agent.48
4. Validation: Downstream verification engines decrypt the signature using the breeding engine's public key.48 If the decrypted hash matches a newly computed hash of the receipt, the document's integrity and authenticity are confirmed.14

This verification pipeline prevents retroactive modification of evaluation results.48 By tracing the chain of signed receipts back through preceding generations, compliance teams can reconstruct the complete evolutionary path of a model.7 This level of traceability is critical for demonstrating adherence to regulatory requirements, such as those defined by the EU AI Act or GDPR, by proving that model parameters were derived from authorized datasets and through validated training processes.6

Works cited

1. Neuroevolution \- Wikipedia, accessed June 29, 2026, https://en.wikipedia.org/wiki/Neuroevolution
2. Auto Research with Specialist Agents Develops Effective and Non-Trivial Training Recipes, accessed June 29, 2026, https://arxiv.org/html/2605.05724v1
3. A Survey of Weight Space Learning: Understanding, Representation, and Generation \- arXiv, accessed June 29, 2026, https://arxiv.org/pdf/2603.10090
4. A Survey of Weight Space Learning: Understanding, Representation, and Generation \- arXiv, accessed June 29, 2026, https://arxiv.org/html/2603.10090v1
5. What Is Metadata Lineage? \- DataHub, accessed June 29, 2026, https://datahub.com/blog/metadata-lineage/
6. Metadata Lineage: Complete Guide to Tracking Data Journey \- Promethium's AI, accessed June 29, 2026, https://promethium.ai/guides/metadata-lineage-complete-guide-tracking-data-journey/
7. Model Lineage and Reproducibility: Tracking Provenance Across the ML Lifecycle, accessed June 29, 2026, https://agility-at-scale.com/ai/governance/model-lineage-and-reproducibility/
8. Data Provenance vs. Data Lineage: Differences & AI Use Cases \- Snowflake, accessed June 29, 2026, https://www.snowflake.com/en/data-governance/data-lineage/data-provenance/
9. What is data lineage (and why does it matter)? \- Twilio, accessed June 29, 2026, https://www.twilio.com/en-us/blog/insights/data/data-lineage
10. Data Lineage vs Data Provenance: Best Practices and Insights \- OvalEdge, accessed June 29, 2026, https://www.ovaledge.com/blog/data-lineage-vs-data-provenance
11. The Ultimate Guide To Data Lineage \- Monte Carlo Data, accessed June 29, 2026, https://montecarlo.ai/blog-data-lineage/
12. Lineage \- OpenMetadata Standards, accessed June 29, 2026, https://openmetadatastandards.org/lineage/lineage/
13. AI Pipeline System Design: Data Ingestion, Training, and Serving | InfraSketch Blog, accessed June 29, 2026, https://infrasketch.net/blog/ai-pipeline-system-design
14. Provenance \- SLSA.dev, accessed June 29, 2026, https://slsa.dev/spec/v1.0-rc1/provenance
15. Understanding Parent and Child Runs in MLflow, accessed June 29, 2026, https://mlflow.org/docs/latest/ml/traditional-ml/tutorials/hyperparameter-tuning/part1-child-runs/
16. ML Model Registry | MLflow AI Platform, accessed June 29, 2026, https://mlflow.org/docs/latest/ml/model-registry/
17. Nested runs don't group correctly in MLflow \- Databricks Community, accessed June 29, 2026, https://community.databricks.com/t5/machine-learning/nested-runs-don-t-group-correctly-in-mlflow/td-p/104616
18. Data Lineage | Pentaho Academy, accessed June 29, 2026, https://academy.pentaho.com/pentaho-data-catalog-en/data-catalog/getting-started/data-lineage
19. Facets & Extensibility \- OpenLineage, accessed June 29, 2026, https://openlineage.io/docs/spec/facets/
20. OpenLineage integration \- IBM, accessed June 29, 2026, https://www.ibm.com/docs/en/ws-and-kc?topic=lineage-openlineage-integration
21. SimpleMating: R‐package for prediction and optimization of breeding crosses using genomic selection \- PMC, accessed June 29, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC11726409/
22. Metadata analysis indicates biased estimation of genetic parameters and gains using conventional pedigree information instead of genomic-based approaches in tree breeding \- PMC, accessed June 29, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC8913692/
23. Tutorial \- ALIFE 2024 Copenhagen \- Artificial Life, accessed June 29, 2026, https://2024.alife.org/tutorials.html
24. A Review of Genomic Models for the Analysis of Livestock Crossbred Data \- PMC, accessed June 29, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC7332767/
25. Overview — hstrat 1.25.0 documentation, accessed June 29, 2026, https://hstrat.readthedocs.io/
26. A Scalable Trie Building Algorithm for High-Throughput Phyloanalysis of Wafer-Scale Digital Evolution Experiments \- MIT Press Direct, accessed June 29, 2026, https://direct.mit.edu/isal/proceedings-pdf/isal2025/37/62/2567097/isal.a.890.pdf
27. hstrat: a Python Package for phylogenetic inference on distributed digital evolution populations \- Open Journals, accessed June 29, 2026, https://www.theoj.org/joss-papers/joss.04866/10.21105.joss.04866.pdf
28. Analysis of Phylogeny Tracking Algorithms for Serial and Multiprocess Applications \- arXiv, accessed June 29, 2026, https://arxiv.org/pdf/2403.00246
29. Phylogeny-Informed Interaction Estimation Accelerates Co-Evolutionary Learning \- MIT Press Direct, accessed June 29, 2026, https://direct.mit.edu/isal/proceedings-pdf/isal2024/36/66/2461071/isal\_a\_00796.pdf
30. Daily Papers \- Hugging Face, accessed June 29, 2026, https://huggingface.co/papers?q=evolutionary%20model%20merging
31. Chapter 1 NOVELTY SEARCH AND THE PROBLEM WITH OBJECTIVES \- Computer Science, accessed June 29, 2026, https://www.cs.swarthmore.edu/\~meeden/DevelopmentalRobotics/lehmanNoveltySearch11.pdf
32. Automatic machine learning \- agua \- tidymodels, accessed June 29, 2026, https://agua.tidymodels.org/articles/auto\_ml.html
33. Train and Deploy Models with AutoML (Automated Machine Learning) \- Domo, accessed June 29, 2026, https://www.domo.com/docs/s/article/360048127854
34. ExAutoGP: Enhancing Genomic Prediction Stability and Interpretability with Automated Machine Learning and SHAP \- PMC, accessed June 29, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC12024354/
35. Automated Machine Learning: A Case Study of Genomic “Image-Based” Prediction in Maize Hybrids \- Frontiers, accessed June 29, 2026, https://www.frontiersin.org/journals/plant-science/articles/10.3389/fpls.2022.845524/full
36. What is AutoML? | Databricks on AWS, accessed June 29, 2026, https://docs.databricks.com/aws/en/machine-learning/automl/
37. Data Lineage for Machine Learning: Why Reliable ML Lives Upstream \- DataHub, accessed June 29, 2026, https://datahub.com/blog/data-lineage-for-ml/
38. Novelty Search Algorithm, accessed June 29, 2026, https://algorithmafternoon.com/novelty/novelty\_search\_algorithm/
39. Unveiling the Unknown: Evolutionary Algorithms for Novelty Search in AI \- Alphanome.AI, accessed June 29, 2026, https://www.alphanome.ai/post/unveiling-the-unknown-evolutionary-algorithms-for-novelty-search-in-ai
40. Critical Factors in the Performance of Novelty Search \- CMAP, accessed June 29, 2026, http://www.cmap.polytechnique.fr/\~nikolaus.hansen/proceedings/2011/GECCO/proceedings/p965.pdf
41. Surprise Search: Beyond Objectives and Novelty \- Georgios N. Yannakakis, accessed June 29, 2026, https://yannakakis.net/wp-content/uploads/2016/05/surprise\_search\_camera\_ready\_Final.pdf
42. Dominated Novelty Search:Rethinking Local Competition in Quality-Diversity \- arXiv, accessed June 29, 2026, https://arxiv.org/html/2502.00593v1
43. Efficient Novelty Search Through Deep Reinforcement Learning \- SciSpace, accessed June 29, 2026, https://scispace.com/pdf/efficient-novelty-search-through-deep-reinforcement-learning-4albf5f7mq.pdf
44. Backward Compatibility During Data Updates by Weight Interpolation \- ACL Anthology, accessed June 29, 2026, https://aclanthology.org/2024.eacl-long.174.pdf
45. \[2604.14790\] Diffusion Crossover: Defining Evolutionary Recombination in Diffusion Models via Noise Sequence Interpolation \- arXiv, accessed June 29, 2026, https://arxiv.org/abs/2604.14790
46. Tracing the Roots: A Multi-Agent Framework for Uncovering Data Lineage in Post-Training LLMs \- arXiv, accessed June 29, 2026, https://arxiv.org/html/2604.10480v1
47. Provenance \- SLSA.dev, accessed June 29, 2026, https://slsa.dev/spec/v0.1/provenance
48. Structuring JSON/XML Lineage Documents · Provenance Tracking, accessed June 29, 2026, https://www.provenance-tracking.com/storage-indexing-query-optimization/structuring-jsonxml-lineage-documents/
49. The PROV-JSONLD Serialization \- W3C, accessed June 29, 2026, https://www.w3.org/submissions/2024/SUBM-prov-jsonld-20240825/
50. Custom Facets | OpenLineage, accessed June 29, 2026, https://openlineage.io/docs/spec/facets/custom-facets/
51. Working with Schemas \- OpenLineage, accessed June 29, 2026, https://openlineage.io/docs/spec/schemas/
52. JSON Schema Extraction with Citations (Reducto), accessed June 29, 2026, https://llms.reducto.ai/json-schema-extraction-with-citations
53. Model Cards \- Hugging Face, accessed June 29, 2026, https://huggingface.co/docs/hub/model-cards
54. GitHub \- HDI-Project/model-provenance-json: A specification for the model provenance file that keeps track of the journey from raw data to deployed model in Machine Learning 2.0 projects., accessed June 29, 2026, https://github.com/HDI-Project/model-provenance-json
55. What is Lineage Tracking? \- Dremio, accessed June 29, 2026, https://www.dremio.com/wiki/lineage-tracking/
56. What is model lineage? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) \- AIOps School, accessed June 29, 2026, https://aiopsschool.com/blog/model-lineage/
57. 7.3. Lineage \- MLOps Coding Course, accessed June 29, 2026, https://mlops-coding-course.fmind.dev/7.%20Observability/7.3.%20Lineage.html