Changelog

6.1.0 — native Windows monitoring client

Released September 13, 2026

• Added the native WebView2 Cognia Desktop client and branded Windows icon.
• Added cognia_monitor.exe, which loads a declarative orchestration .cognia file without compiling example sources.
• Added source-free Example 22 with six heterogeneous engines, multimodal inputs, a real external output and an active demonstration LoRA overlay.
• Added engine drill-down, bounded L0/L1 internal topology, matching Cognia source display and Sensors/Memory/Learning views.
• Kept passive monitoring free of GPU downloads and bit-identical under the M-15 non-interference gate.

6.0.0 — orchestration observability and control

• Headless HTTP/SSE monitoring service and responsive orchestration console.
• Engine inspectors, causal timeline, safe tensor viewer and atomic exports.
• Controlled operations, remote security policy and offline diagnostic replay.
• Non-interference and aggregate release gate: 15 PASS, 0 FAIL, 0 BLOCKED.

5.0.0 — governed context, memory, durable runs and placement

Prepared September 12, 2026

• Added loss-aware context governance with explicit budgets and provenance.
• Added episodic/semantic/working memory and safe multi-space embedding migration.
• Added durable orchestration runs with committed journals, reconnect cursors, crash recovery and atomic compaction.
• Completed placement P-01 through P-12: .cplace, immutable plans, hardware inventory, resource estimation/calibration, fail-closed preflight, shared base weights, residency, admission control, transfer planning, snapshot binding and CLI.
• Release validation passes orchestration 13/13, placement GPU 14/14, durable 4/4, memory 3/3, transformer GPU 15/15 and DPSH GPU 38/38.
• Learned routing E-06 remains experimental. Real two-GPU peer-copy validation is not claimed on the single-GPU release host; learned memory quality remains checkpoint- and dataset-dependent.

5.0.0-alpha.1 — context governor and placement API

• Added a context governor with separate budgets, protected retention, loss-bounded explicit transforms and stored replay provenance.
• Added versioned .cplace parsing and immutable lowering bound to Cognia 4 SystemSpec graphs.
• Added Windows CPU/RAM/CUDA inventory, checked resource estimators and a no-allocation explicit OOM preflight.
• Added deterministic first-fit decreasing with pinned assignments and byte-identical results under input permutation.
• Example 20 now demonstrates build → placement → preflight → live orchestration.
• Physical device allocation, shared base-weight residency, admission control, multi-GPU transfers and placement-aware snapshots remain out of scope for this alpha candidate.

This changelog covers the public Windows x64 distributions of Cognia / Sensory. Version 1.0.0 freezes the synchronous, rate-based CUDA engine as runtime 1; later runtime generations are versioned separately.

4.0.0 — heterogeneous runtime orchestration

Prepared September 12, 2026

Added

• Added typed multi-engine system IR, capability negotiation and explicit schema adapters across synchronous, DPSH and transformer runtimes.
• Added a deterministic bounded message bus, serial logical scheduler and a logically equivalent parallel executor with explicit CUDA streams.
• Added immutable tensor ownership, copy/zero-copy transport, consistent system snapshot/restore/fork and experimental Windows shared memory.
• Added provenance, causal replay, connection ablations, matched controls and base-bound LoRA overlay lifecycle.
• Added inspect/run/replay/benchmark CLI tools, Example 20's real three-engine composition and Example 21's ablation-oriented research protocol.

Validation and compatibility

• The orchestration release gate passes 13/13 controls with no failed or blocked group; DPSH GPU and transformer GPU gates pass 38/38 and 15/15.
• Runtime 1–3 models and artifact formats remain supported. System snapshots are separate orchestration artifacts.
• CUDA IPC, cluster scheduling and automatic placement remain out of scope.
• The examples demonstrate infrastructure and methodology; they do not claim consciousness or automatically establish complementarity.

3.1.0 — CUDA transformer training and intuition

Released September 3, 2026

Added

• Added device-resident CUDA/BF16 training with persistent AdamW state.
• Added the CUDA transformer REST service, ranked byte-level BPE and a stable chat template with atomic roles and EOS.
• Added dialogue-bounded assistant-only training and degeneration-health metrics.
• Added Community Czech Intuition with a latent embedding output.
• Specified future LoRA lifecycle and ablation requirements for orchestration v4.

Compatibility

• CTM/CTS contracts remain hash-bound and version checked.
• CTT checkpoints using the old sum-gradient training semantics are rejected by the cognia-transformer-training-v2 configuration check.

3.0.0 — Transformer runtime

Released September 1, 2026

Added

• Added Cognia 3.0 transformer declarations and canonical AST-to-spec lowering.
• Added CPU forward/backward, deterministic training/resume, tokenizer, CTM/CTT/CTS artifacts, KV cache, generation and sampling.
• Added CUDA dense/tiled attention and GQA parity validation.
• Added transformer CLI, benchmark, release validator and community Czech example.

Compatibility

• Runtime 1 and 2 remain supported and their artifact formats are unchanged.
• Runtime-3 artifacts are deliberately separate and spec/tokenizer bound.

2.0.1 — DPSH application kit

Released August 30, 2026

Added

• Added a practical design kit for embodied DPSH applications and small autonomous robots.
• Added safety boundaries, staged commissioning, replay-first development, population-coded motor recommendations and a minimal project layout.
• Added a standalone technical overview of DPSH runtime and expanded the 2.0.0 release documentation with a thematic and commit-level audit.

Changed

• Generalized RoverBridge to RealtimeTransportBridge; hardware-specific channel mappings now remain outside the engine.
• Updated package and public release identity to 2.0.1.

Compatibility

• No event physics, capability contract or snapshot format changed from 2.0.0.

2.0.0 — Event-driven DPSH runtime

Released August 30, 2026

Runtime 2 is a separate event-driven execution model for reproducible dynamical experiments. Runtime 1 remains supported. This release spans 35 commits, 181 files and roughly 30,960 added lines since v1.0.0.

Runtime architecture and language

• Added IRuntime, explicit runtime selection and capability validation.
• Split the shared Cognia frontend from sync and DPSH substrate lowering.
• Added the Cognia 2.0 language surface for oscillators, phase modulation, interventions, plasticity, prediction, experiments, sweeps, multimodality and realtime actuators.
• Added a production DpshRuntime composition boundary rather than leaving the feature implementations as disconnected test components.
• Unresolved lowering targets and multiple incompatible neuron-dynamics declarations now fail loudly instead of silently changing model meaning.

Event physics and determinism

• Added integer nanosecond ModelTime, deterministic cancellable event queues and calendar storage.
• Added autonomous closed-form neurons, explicit refractory semantics, adaptation and explicit memory.
• Added stochastic firing using Ogata thinning with checked analytical hazard bounds, exact replay and deterministic controls.
• Added a sparse delayed synapse graph with stable edge identities, polarity, mutable plastic state, lazy dual CSR indexes and byte snapshots.
• Added named RandomContext streams and complete .dpsh checkpoints including pending candidates, queues and runtime-owned mechanisms.

Windows, oscillations and CUDA

• Added causal lookahead windows derived from declared minimum synaptic delay.
• Added analytical oscillators, Kuramoto coupling and phase-aware excitability, threshold, synaptic and plasticity gains.
• Added shared host/device neuron physics and deterministic numerical functions.
• Added CUDA window execution, deterministic shard layouts and resident local event queues.
• Added the CPU/CUDA parity gate: 20 models × 5 seeds, including restore and active plasticity, compare bit for bit.

Measurement and interventions

• Added spike/state recording, queue-scheduled sampling, JSONL and NumPy export.
• Added trajectory clustering, dwell times, transition matrices, surrogate controls and versioned metric export.
• Added scoped ablations, perturbations, forced spikes and thinning-candidate invalidation.
• Added matched phase scrambling, replay, reorder and delay controls with frozen or fresh randomness.
• Observer paths are guarded by I-8: attaching a recorder cannot alter the event log.

Learning and higher-level dynamics

• Added trace-based STDP, matched rate-based controls, homeostasis and separate excitatory/inhibitory rules.
• Added global and per-group learning gates, exact weight-change accounting, fast/slow consolidation and offline learning modes.
• Replaced central workspace selection with recurrent excitation and lateral inhibition; ignition and reversals are measured by an observer.
• Added distributed prediction-error channels, precision weighting, explicit or implicit predictors, surprise-modulated learning and phase preparation.
• Added a single multimodal input path and shared-manifold, consistency, continuity, completion and shared-causal-impact measurements.

Experiments and validation

• Added declarative stimuli, pre-registered experiments, snapshot-forked branches and versioned run registries.
• Added parameter sweeps across seeds, Student confidence intervals, shape classification, critical-regime candidates and resumable execution.
• Added cognia_experiment_run as the end-to-end language-to-report command.
• Added the F-21 binary validation gate; the CUDA build passes 38/38 controls.
• Reports permit inconclusive and present curves or maps rather than silently recommending an optimum.

Realtime embodiment

• Added population-coded antagonistic actuators without reintroducing argmax.
• Added the read-only motor commit boundary and invariant I-9.
• Added free and paced realtime driving with measured overruns and no hidden model-time catch-up.
• Added trace recording/replay and R0 live-versus-offline log-hash equality.
• Added a generic timestamped SPSC transport bridge; rover-specific channel mapping remains in Example 16 rather than in the engine.

Compatibility and known limitations

• Runtime 1 .bin v4 and runtime 2 .dpsh v1 are intentionally separate.
• Runtime 1 competition now lowers to inhibitory topology unless an explicit selector: argmax control is declared.
• Engine-version changes invalidate cached experimental comparisons.
• Whole-run CUDA speedup remains below the original ≥10× target; Z-9 is an open, non-blocking optimization and may not change event physics.
• The downloadable desktop package does not include a device-specific robot relay or safety controller.

1.1.0 — Deterministic snapshot and restore

Unreleased

Runtime 1 gains a complete execution snapshot, so a run can be branched from one saved state and the difference between branches attributed to an intervention.

Added

• Full runtime checkpoints in .bin v4: RNG state, adaptation, excitation, chemistry, the activation-history ring buffer, firing state, polarization and the workspace/attention state are all preserved, so save followed by load reproduces the original trajectory bit for bit.
• cognia_snapshot_test, a GPU regression that snapshots a live Mind, branches it twice, and requires both branches to reproduce the uninterrupted trajectory exactly — plus a perturbed third branch whose divergence must be reproducible.
• RandomContext, a runtime-neutral source of named random streams: a stream is addressed by purpose and entity rather than by creation order, so adding a neuron cannot shift the draws of unrelated ones. Supports exact freeze/replay (an exhausted recording is an error, never a silent fall back to fresh draws) and byte-deterministic snapshot/restore.
• Runtime 1 derives its random state from that context: init (bias, polarization directions), growth (structural growth and pruning) and spontaneous (per-neuron stochastic firing) are now separate streams, so a draw added to one can no longer shift another.
• cognia_random_test, a CUDA-free regression for stream independence, the stream handle, distribution stability across master seeds, exact replay, replay exhaustion and transactional snapshot/restore. It runs from the canonical test suite and from the front-end-only build.
• The runtime 2 event core: integer ModelTime in nanoseconds and a deterministic EventQueue ordered by (time, sequence). Because the sequence is unique, that is a strict total order, so the delivery order is fully determined regardless of insertion order or heap layout — which is what makes non-commutative event order (A then B versus B then A) reproducible. Cancellation is lazy with compaction past 50 % dead entries, model time only advances on delivery, and scheduling before the current model time is an error rather than an event delivered after ones that already happened. The queue carries a byte-deterministic snapshot so its pending events, sequence counter and model time can go into a checkpoint.
• cognia_event_queue_test, a CUDA-free regression covering every F-04 acceptance criterion: ordering in both insertion directions, exact delay through the queue, non-commutativity, causality enforcement, cancellation and compaction stability, byte snapshot round-trip and rejection of corrupt or truncated state, ungridded timestamps, and a 20k-event load test.
• The autonomous state neuron: membrane and adaptation evolve in closed form (v(t) = v(t_last)·exp(-(t-t_last)/tau)), so there is no integration step and therefore no hidden global clock. A neuron is touched only by a delivered or self-scheduled event, keeps its own refractory window and schedules its own RefractoryEnd (cancelling the previous one so the queue keeps no dead entries), and carries a byte snapshot so its state can go into a checkpoint. Absolute versus relative refractoriness is a declared model parameter: under the absolute variant a spike inside the window is a caller error rather than a silently extended window.
• Explicit memory cells now have behaviour, not just a marker: a cell flagged explicit_memory holds its membrane state instead of leaking it, while its adaptation still decays. Clearing the flag turns it back into an ordinary decaying neuron, which is what the memory-cell ablation needs to switch off.
• cognia_autonomous_neuron_test, a CUDA-free regression: no updates while model time advances for other neurons, split-invariance of the closed form, causality and refractory enforcement, self-event rescheduling, non-commutative input order inside the refractory window, exponential adaptation, the declared decay threshold, explicit-memory semantics and its ablation, and byte snapshot round-trip.

Compatibility notes

• Full runtime checkpoints now use .bin v4 (magic SENSNET2). Runtime 1 still reads v1-v3 checkpoints but warns that their restore is incomplete. Builds released before v4 reject the new magic instead of silently loading a file as v3 semantics.
• Eligibility-training traces are not part of the runtime snapshot contract; checkpoint at inference/experiment boundaries, not mid optimizer update.
• A failed save or load now reports failure instead of returning success after a partial transfer.
• Stochastic models draw a different sequence than in 1.0.0 for the same seed. Named streams changed how per-neuron and structural random state is derived, so trained weights and .bin files stay valid, but a recorded stochastic result from 1.0.0 will not reproduce run-for-run. Distributions and firing rates are unchanged.
• Stream identity is folded to 32 bits where the device generator stores its state in unsigned int, so two neurons can share a spontaneous stream by birthday collision (about 1 % of seeds at 10k neurons). Runtime 1 reports the count when it happens instead of leaving it silent.

1.0.0 — Stable synchronous runtime

Released August 20, 2026

This release freezes the existing synchronous, rate-based CUDA engine as Cognia runtime 1. Low-rank adapters remain explicitly experimental.

Added

• Added opt-in adapter low_rank blocks on Cognia connections with deterministic A/B lowering, linear bottleneck neurons, alpha/r scaling, and separate GPU accumulation/normalization from the frozen base path.
• Added isolated adapter training and cognia_train operations --train-adapter, --load-adapter, and --save-adapter.
• Added experimental .cmod v2 adapter payloads while preserving .cmod v1, plus GPU regression test 17 for learning isolation and binary round-trip.
• Added --disable-adapter, --adapter-scale, softmax adapter logits/gradients, and Example 15 measuring frozen, full and LoRA Czech domain adaptation with replay.

Documentation

• Added RFC-0004 for the experimental MVP and its remaining compatibility work.
• Defined separate base/adapter normalization, deterministic lowering, training ownership, .cmod v2 adapter metadata, compatibility rules, and conformance tests without changing .cmod v1.

Portable construct modules and community Czech MoE

Added

• Portable .cmod v1 checkpoints for a construct's internal weights and neuron biases, keyed by type and relative neuron/edge identities rather than global indices or instance paths.
• --load-construct, --save-construct, --freeze-construct, and --train-construct trainer operations with ownership-isolated updates.
• RFC-0003, a machine-readable community module manifest schema, a reference manifest, and cross-network round-trip regression coverage.
• Example 14: four reusable Czech SLM expert modules, a separate router checkpoint, staged eligibility training, per-expert replay, readout anchoring, progress/ETA reporting, and multi-metric promotion gates.

Compatibility

• The feature is opt-in. Existing .cognia, full .bin, and controller .ctrl files keep their behavior and format. .cmod v1 requires an identical construct type and stable relative declared topology; it intentionally does not carry grown/pruned edges, runtime state, or external adapter edges.

Runtime identity

• Runtime 1 checkpoints are not complete execution snapshots: RNG, adaptation, chemistry, activation history, and workspace state are not fully preserved.
• Asynchronous/Poisson focus, event controllers, declarative clamp phases, and inter-network pub/sub are parsed but not executed end to end by runtime 1.

0.4.1 — CUDA batches and mixed spatial readouts

Released August 8, 2026

Added

• --batch-size N for deferred softmax readout updates: CUDA kernels accumulate weight and bias gradients and apply their mean once per mini-batch.
• Square-map 3x3 local receptive fields and a convolution topology pattern that reuses one nine-coefficient stencil across spatial positions.
• Multiple independent classification sub-heads in one top/clamp layer, plus continuous Smooth-L1 regression and optional four-value smooth_l1_iou box loss in the same CUDA-trained readout.
• Raw continuous values arrays on REST signal outputs.
• Example 13: a two-slot Fashionpedia object detector with deterministic image augmentation, presence/category heads, xyxy boxes and evaluation tooling.
• Complete trainer CLI help and release documentation for all 0.4.x training modes, dataset formats, constraints and persistence options.

Changed

• Independent examples still run forward one at a time, but their readout gradients remain on the GPU until the batch boundary. This is distinct from --eligibility-batch, which controls inner/recurrent updates in sequence mode.
• Classification outputs no longer have to cover the complete top layer; separate contiguous output regions are normalized as separate softmax heads.
• Equal square maps use two-dimensional neighborhoods for local; unequal or non-square regions retain the one-dimensional radius-2 fallback.

Research status

Example 13 demonstrates the complete mixed readout, but its documented mean IoU is 0.1955 and localization remains the weak component. The convolution topology reuses coefficients when edges are created; runtime edges are independent, so models requiring permanent tying should keep those edges non-plastic.

0.4.0 — Continual Czech language learning

Released August 6, 2026

Added

• Normalized covariance credit, pairwise target-versus-runner-up learning, stochastic competitor exploration, temperature schedules and centered neutral memory state for eligibility-trained inner layers.
• --load, per-epoch checkpoint prefixes, --freeze-readout, eligibility batching, reverse-step controls and --eligibility-every N in cognia_train.
• GPU-native indexed one-hot sensory and target loading for sequence datasets.
• Example 11 with compact synthetic sequence-memory experiments for diagnosing spatial and temporal common-mode credit.
• Example 12 with a continually trained Czech chatbot, licensed community JSONL validation, deduplication, fixed-vocabulary syllable conversion, replay mixing, checkpoint lineage and a regression gate before model promotion.
• Persistent dialogue memory, previous-topic references, response obligations, grammar-guided decoding and lexicon-driven Czech verb valency.
• A generated 764-entry Czech lexicon with 36 verb paradigms and nominative, accusative, locative and genitive noun forms.

Changed

• Example 10 grew from a syllable-model prototype into a grammar-guided Czech dialogue planner with word-window memory and multi-turn evaluation.
• Indexed sequence training constructs one-hot vectors directly on the GPU instead of allocating and transferring dense host vectors per token.
• Language experiment scripts use the Release trainer. On the documented 4,284-token sample, Release reduced one epoch from 105.3 s to 11.0 s.
• Eligibility cadence N=4 reduced a full 175,709-target grammar epoch from 556.2 s to 285.4 s while matching or slightly improving grammar, dialogue and FineWeb cross-entropy in the controlled A/B experiment.
• The package excludes downloaded/generated datasets, community submissions, checkpoints, logs and experiment output directories. Required tiny datasets for classic demos and runnable regression tests remain explicitly installed.

Research status

The Czech chatbot is a controlled research prototype, not a general-purpose LLM. Grammar and valency improve syntactic safety but can mask insufficient semantic training. Continual learning always mixes prior replay data to reduce catastrophic forgetting, and a candidate model is not promoted unless protected grammar, dialogue-memory and FineWeb metrics pass the regression gate.

0.3.0 — Deep sequence credit

Released August 4, 2026

Added

• Opt-in three-factor eligibility traces for plastic inner and recurrent edges during sequential softmax training.
• Three-step reverse credit transport, per-edge temporal traces, sequence-boundary reset and applied-update diagnostics.
• --eligibility CLI support and the eligibility staged-plan flag.
• Streaming sequence training that retains only sequence offsets in memory and reads training rows on demand.
• Compact cognia-seq-indexed and cognia-controller-seq-indexed formats.
• Stateful sequential controller training with ownership isolation and controller checkpoints.
• Example 08: an adaptive email-spam classification baseline over safe numerical UCI Spambase data.
• Example 09: a Czech dialogue experiment with staged inner-controller training.
• Example 10: a lossless syllable-plus-character Czech language-model pipeline, FineWeb2 filtering and bounded sequence preparation.
• Tests 14 and 15 for controller sequences, ownership isolation and genuine inner-edge eligibility updates.
• Synchronized English and Czech research documentation for the spam experiment and eligibility traces.

Changed

• Sequence datasets are shuffled by sequence while token rows are streamed from disk.
• Supervised classification uses linear learning-rate decay and a dedicated weight range; the deterministic regression remains 30/30.
• Repetition detection terminates cyclic Czech dialogue generation more reliably.
• Downloaded corpora, generated input/ data, output/ artifacts and trained checkpoints are excluded from the public ZIP.

Research status

Eligibility traces establish a working delayed credit path into inner layers; the checked bootstrap changed 2,248 inner edges. This proves implementation behavior, not a general language-quality gain. A controlled readout-only versus eligibility A/B perplexity experiment remains required.

0.2.0 — Polarized neural networks

Released August 3, 2026

Added

• Polarized neural modules with a shared two-dimensional state and seeded per-neuron direction vectors.
• Autonomous polarization updates with sensitivity, update rate and momentum controls.
• Direction learning and polarization-state introspection.
• Controller output ports that actively steer the polarization vector of another module.
• Semantic validation for controller width, target compatibility, blend range and single-controller ownership.
• Polarization data in REST responses and runtime statistics.
• Visualization of the polarization direction in the plane of the affected neurons.
• Examples 05–07 covering adaptive cruise-control exploration, lead-vehicle intent retention and controller-driven polarization.
• English and Czech research notes for the polarization concept.
• A new controller-polarization smoke test.

Changed

• Extended the Cognia grammar, AST, semantic analyzer, topology builder and CUDA bridge for polarized state.
• Expanded the graph snapshot and network view with polarization metadata.
• Promoted the release from the 0.1 line to 0.2 because it introduces a new model-level state and controller capability.

Research status

Polarization is experimental. Example 06 reports a controlled improvement on an identical-input memory tail, while Example 07 demonstrates better late-horizon state retention but not higher aggregate accuracy. These results are demonstrations, not a general scientific or safety claim.

0.1.2 — Consistent classification heads

Released August 1, 2026

Added

• Example 03: a feed-forward plant-watering decision model and documented baseline experiment.
• Example 04: the corresponding supervised classification model and controlled comparison.
• Dataset generators, clients and English/Czech experiment documentation for both examples.
• Smoke test 12 for the classification-output path.

Changed

• Added a first-class classification output using pre-activation logits.
• Aligned softmax cross-entropy training and REST inference to use the same logits.
• Added classification probabilities, selected class, confidence and entropy to server output.
• Added supervised output-bias training for the classification readout.

0.1.1 — Stochastic firing and reproducible examples

Released August 1, 2026

Added

• GPU runtime support for stochastic neuron firing declared with fire when.
• Per-neuron seeded random-number-generator state.
• Firing state and firing probability in snapshots and HTTP responses.
• Optional multi-step fire counting through the stateful API.
• Example 01: one-neuron XOR experiment and its documented limitations.
• Example 02: stochastic one-neuron AND experiment with repeated sampling.

Changed

• Reset now restores stochastic generator state for reproducible trials.
• Public release resources use English as the primary language, with Czech variants carrying a -cz suffix.
• Packaging and release checks were tightened for website distribution.

0.1.0 — First public Windows release

Released July 31, 2026

Added

• First ready-to-run Windows x64 distribution.
• Full Sensory GUI application for camera, microphone and text input.
• Declarative Cognia parser, semantic analyzer, topology builder and GPU runtime bridge.
• Stateful recurrent Mind with workspace competition, attention, chemistry, delays, plasticity and bounded structural growth.
• cognia, cognia_run, cognia_train and cognia_serve command-line tools.
• Signal and vocabulary-backed text outputs.
• Stateless evaluation, stateful stepping and raw sequence feeding over HTTP.
• Supervised readout training, sequential datasets and softmax classification tooling.
• Reusable constructs, neural gate/select controllers and staged controller training.
• Canonical EBNF grammar, RFC documents, examples and graded smoke tests.
• Per-user installation and uninstallation scripts.
• PolyForm Noncommercial licensing, commercial-license terms, third-party notices and privacy information.

Compatibility notes

• A saved .bin must match the model dimensions expected by the runtime that loads it.
• Models relying on undocumented defaults or random initial behavior may change between pre-1.0 releases.
• Keep the model source, dataset, generator, seed, release version and trained binary together when reproducing an experiment.
• Use the latest release for new work; keep an older release only when reproducing its exact behavior.