Training systems · E45 · Engineering practice

A research project needs a current state, not just a long history

A project-state ledger connects code, evidence and closed decisions so an old experimental queue does not silently become today’s plan.

Markdown state ledgerVersion / hash receiptsGit history
An experiment becomes useful project memory when its result remains connected to its source, checks and resulting decision.
Figure 1. Keep the decision, not just the log. An experiment becomes useful project memory when its result remains connected to its source, checks and resulting decision. Experiment provenance schematic. Original vector illustration.

Follow the information

From input to outcome

This is a provenance workflow, not a neural inference graph. Both positive and negative outputs enter verification and the current-state ledger, which constrains the next authorized action.

This is a provenance workflow, not a neural inference graph. Both positive and negative outputs enter verification and the current-state ledger, which constrains the next authorized action.
Figure 2. Information flow. Solid arrows carry observations, tensors or artifacts; other routes are explicitly labelled. Signal shapes, matrices and network icons are schematic, not measured samples or literal neuron counts. Open full-size SVG ↗ On narrow screens, scroll the diagram horizontally.

Read this alongside Figure 1: An experiment becomes useful project memory when its result remains connected to its source, checks and resulting decision. The module map and layer-level figures below expand the operations in this route.

A research project needs a current state, not just a long history: system and evaluation mapExperiment protocol: Question + fixed scope → Run artifacts: Code / configuration / outputs → Verification: Tests + source identity → Current state ledger: Completed / rejected / open → Next authorized action: Explicit boundary. A high-level module map; comparison branches and training details are explained in the article.TRAINING SYSTEMS / E45 / MODULE MAP01 INPUTExperiment protocolQuestion + fixed scope02 MODULERun artifactsCode / configuration / outputs03 MODULEVerificationTests + source identity04 MODULECurrent state ledgerCompleted / rejected / open05 OUTPUTNext authorized actionExplicit boundary
Source-grounded module map. Boxes summarize operations, not individual neurons; comparison arms and training paths are detailed below. On a small screen, scroll the diagram horizontally.
Experiment protocol — Question + fixed scope

The architecture in context

The system we are building

A long research archive accumulates instructions that were valid at different times. The selected project-state file opens with a current summary and links to dated reports, then explicitly marks older material as historical. That structure matters when a person or agent resumes work months later: old present-tense prose is not a new authorization to restart a closed search.

Who does what in the stack

Markdown state ledger
Summarizes current decisions and links to evidence.
Version / hash receipts
Identify code and runtime context.
Git history
Preserves intermediate conclusions rather than overwriting them.

The project adds closure decisions, resource boundaries and source-linked findings to its status record. The companion excerpt comes from a run’s dependency-receipt function, illustrating the lower-level evidence that a useful ledger points to. A Markdown summary is not itself a trained model.

Framework responsibility map. Each row maps a library or custom component to its job; rows are not a sequential inference graph.
Framework responsibility map. Each row maps a library or custom component to its job; rows are not a sequential inference graph. Open full-size SVG ↗

Open up the implementation

A project ledger is not a benchmark table

A concrete operation-level view of this implementation; no unobserved neural architecture is implied.
A concrete operation-level view of this implementation; no unobserved neural architecture is implied. Open full-size SVG ↗

The ledger connects research claims to actual experiments and preserves negative outcomes. Its role is to prevent a later implementation improvement from retroactively changing what an earlier run established. A closed experiment should retain its target and acceptance criteria even when a new experiment follows.

The mathematical contract

claimlongleftrightarrow(artifact,configuration,scope)\mathrm{claim}longleftrightarrow(\mathrm{artifact},\mathrm{configuration},\mathrm{scope})

A concise status record is useful only if readers can recover the artifact and its context. Numbers copied without units, seed count or benchmark identity become harder to audit than the original logs. A model card should link to evidence, not treat a progress narrative as measurement.

Implementation and resource card

Capacity / budget
Status evidence; no independent network, training run or parameter count.
Execution evidence
This revision inspects and explains the archived implementation. It does not rerun the original workload. No unrecorded convergence time, throughput or accelerator result is supplied.
Current reproduction context
Current workstation, supplied by the author: Apple M4, 128 GB unified RAM, 40 GPU cores and 16 CPU cores. This is context for prospective reproduction, not attribution of every archived run. Python and framework versions are not fully locked for these historical sources; declarations, when available, are identified separately.

From explanation to a reproducible check

Pick one result and follow it to source, configuration, output and conclusion. Require an explicit distinction between a test that passed, a hypothesis that remains open and a gate that failed.

Preserve input identities, configuration and failure records with the result. A successful numerical check only establishes the operation it exercises: it does not certify an entire dataset, model or deployed system. Reproduce the interface on a small deterministic input before optimizing throughput or increasing workload size.

A closer look at the implementation

The code that carries the idea

Dependency versions, source identity, configuration and numerical outputs serve different purposes. The receipt records a reproducibility context; the ledger explains which result governs the current interpretation. Neither should be replaced by a manually curated list of successes.

Python · file · lines 43–54
def dependencies():
    result=source.dependencies()
    for name in ('apps_industrial_breakthrough/locomotion_policy_learning333.py',
                 'apps_industrial_breakthrough/locomotion_policy_learning_gate333.py'):
        result[name]=hashlib.sha256((p.ROOT/name).read_bytes()).hexdigest()
    package=Path(stable_baselines3.__file__).parent
    for name in ('sac/sac.py','sac/policies.py','common/off_policy_algorithm.py','common/buffers.py','common/distributions.py'):
        result[f'stable_baselines3/{name}']=hashlib.sha256((package/name).read_bytes()).hexdigest()
    result['stable_baselines3_version']=stable_baselines3.__version__; result['torch_version']=torch.__version__
    if stable_baselines3.__version__!='2.9.0': raise RuntimeError('Pinned SAC version required')
    return result

Verbatim archive excerpt from locomotion_policy_learning_gate333.py (companion source E38). Context-dependent historical code, not a standalone runnable program. Comments retain their original wording; the article distinguishes implemented behavior from stale or overbroad comments.

The boundary that matters

The current state preserves failed capability gates alongside useful engineering components. It does not imply that all historical claims were revalidated. A status page can become misleading if an old headline survives after its supporting claim was corrected.

Keep building

Other posts of interest