DEV Community: Okerew

Patch 1 and 2 for larkos

Okerew — Mon, 08 Jun 2026 05:09:14 +0000

Patch 1 for larkos 0.1 - Major improvements in testing, fixed bugs added a feature to combine test checkpoints
Patch 2 for larkos 0.1 - bug fixes, addes start_training_from
https://github.com/Okerew/larkos_0.1

Also bug fixes for https://github.com/Okerew/larkos

mCemm a GEMM (General Matrix Multiply) kernel generato

Okerew — Fri, 05 Jun 2026 15:36:03 +0000

Released mCemm a GEMM (General Matrix Multiply) kernel generator for Apple Metal which generates optimized Metal shaders with configurable tile sizes, warp sizes, data types (f16/f32), transpose modes (NN/NT/TN/TT), activations (ReLU/GELU/SiLU), bias and more - https://github.com/MetalLikeCuda/mCemm

Fixed installation in https://github.com/Okerew/osxiec and https://github.com/MetalLikeCuda/gpumkat

Released https://github.com/MetalLikeCuda/awesome-mlc a list of community maintained metal tools, frameworks, libraries and resources.

Introducing Cognitive Fusion in Larkos: A Unified Architecture for LLM, Neuron, Memory, and Module Integration

Okerew — Tue, 02 Jun 2026 14:28:29 +0000

Introducing Cognitive Fusion in Larkos: A Unified Architecture for LLM, Neuron, Memory, and Module Integration

Author: Witold Warchoł

Date: 2.06.2026

See this paper for a more comprehensive version of this post.

Abstract

The Cognitive Fusion Mechanism (CFM) in Larkos integrates LLM embeddings, neuron states, and episodic memory into a shared 64-dimensional space. It ensures information preservation, stream balance, and deterministic reproducibility, enabling dynamic, context-aware reasoning. Empirical results demonstrate strong performance in learning efficiency, domain transfer, continual learning, and meta-learning, while maintaining stability and affective coherence.

Introduction

Current AI systems struggle with catastrophic forgetting, poor generalization, and inefficient adaptation. CFM addresses these by unifying heterogeneous information streams into a cohesive cognitive architecture, validated through a 9-test framework.

Core Architecture: Cognitive Fusion Mechanism (CFM)

Input Streams

LLM Query Stream: Dense embedding vector (q_raw ∈ ℝ^d_llm) from the LLM, blended with text input embeddings at 50% strength.
Neuron Stream: Flattened vector (n_flat ∈ ℝ^16N) for up to 8 active neurons, capturing state, output, connections, and topology.
Memory Stream: Up to 300 episodic entries, each with:
- A 22D vector (prior neuron states + external features).
- Importance weight (α_i).
- Timestamp (τ_i).

Projection Mechanism

Deterministic Random Projections: Maps arbitrary-dimensional inputs to 64D using a splitmix64-style hash, ensuring:
- Dense mixing (all input dimensions influence output).
- No information loss (no blocking/striding).
- Reproducibility (fixed seeds across runs).
Full Projection: Scales input by 1/√n (Johnson-Lindenstrauss lemma).
Banded Projection: Projects into disjoint bands of the 64D output (seeds: 1009, 2003, 3001).

Processing Pipeline

LLM Query Processing: Project + layer-normalize; blend with text input.
Neuron Feature Extraction: Project + normalize flattened neuron vector.
Top-K Memory Attention: Select top 8 memory entries via dot-product similarity; softmax-normalize scores.
Banded Assembly: Re-project each stream into disjoint 64D bands:
- LLM: [0:22]
- Neurons: [22:43]
- Memory: [43:64]
Cross-Band Mixing: Introduce interactions between bands via sigmoid-modulated mixing.
Output Normalization: Layer-normalize the final vector.

Design Rationale

Deterministic Projection: C-side fusion is a feature extractor (not a learner); gradients are killed at the C boundary.
Banded Architecture: Prevents stream dominance (e.g., neurons/memory burying LLM queries).
Top-K Memory Attention: Ensures peaked, informative attention (avoids uniform noise averaging).
Orthogonal Subspaces: Separate seeds for each band guarantee stream independence.

Key Results

Test	Status	Key Metric
Learning Efficiency	PASS	Total Improvement: +0.4770
Domain Transfer	PASS	Transfer Efficiency: +0.6388
Continual Learning	PASS	Forgetting Index: +0.2477
Discovery	FAIL	Variance Ratio: +0.1634
Model Stability	PASS	Loss Late Std: +0.0194
Internal World Model	PASS	Fused Dimensionality: 1.0
Adaptation Speed	PASS	Recovery Epochs: 5
Meta-Learning	PASS	Slope Trend: +0.0045
Affective Representations	PASS	Affective Complexity: +1.1916

Analysis Highlights

Rapid Convergence: 77% loss reduction in early epochs (Test 1).
Robust Transfer: 63.88% efficiency in domain adaptation (Test 2).
Continual Learning: Low forgetting index (0.2477) and fast recovery (Test 3).
Stability: Low loss variance (0.0194) and full dimensionality (Test 5).
Meta-Learning: Improving slope trend (+0.0045) shows "learning to learn" (Test 8).
Affective Coherence: High arousal correlates with high loss (Test 9).

Conclusion

CFM enables robust, interpretable, and adaptive cognitive modeling by unifying LLM embeddings, neuron states, and memory. It addresses catastrophic forgetting, poor generalization, and inefficient adaptation, paving the way for human-like AI systems. Future work will focus on scaling and refining exploration-exploitation balance.

Released reminders-sync, bug fixes for neural web

Okerew — Thu, 28 May 2026 08:17:25 +0000

Released a simple neovim plugin which allows pulling reminders to a certain directory, and editing them, while automatically pushing to macOS Reminders app.
https://github.com/Okerew/reminders-sync

Made simd work better, made it actually usefull, added loadNetworkStates, fixed bugs in https://github.com/Okerew/larkos

My Experience in Experimental AI(Larkos)

Okerew — Sun, 24 May 2026 20:21:31 +0000

Introduction:

One thing I’ve learned from building an experimental AI architecture is that ideas are cheap, but reality is expensive.

I learned this really good with larkos. At first, I was full of ideas and ambition. I wanted to shove in every possible feature as fast as humanly possible.

Instead of some clean “victory” I had in my head, I ended up buried in fixing interactions, broken assumptions, gradient issues, and a hell lot of systems fighting each other in ways I didn’t even predict.

What looked clean on paper turned into debugging layers of interactions between modules, losses, C code, and training dynamics.

The deeper I went, the more obvious it became: it’s never just about adding things. It’s about whether they survive contact with everything else already there.

We can pick what we try to build, but we don’t get to negotiate with reality. The rules don’t bend. Systems behave the way they behave, not the way we want them to behave.

To elaborate more on the long and the short of it

At the beginning, everything seems obvious. You sketch modules, memory systems, cognitive layers, fusion mechanisms, metacognition, imagination systems, and dozens of other ideas. On paper they all make sense.

Then you start training.

Suddenly the challenge is no longer architecture. The challenge becomes understanding what your system is actually doing.

I discovered that most of my time wasn’t spent inventing new mechanisms. It was spent debugging:

Gradient paths silently breaking
Loss functions fighting the architecture
C and Python integrations behaving unexpectedly
Data pipelines
Docker and CUDA issues
Tensor mismatches
Hidden assumptions

One lesson that surprised me was how often a training problem turned out not to be an architecture problem at all. Sometimes a single incorrect gradient path or a poorly chosen loss function had a larger effect than weeks of architectural planning.

Another lesson was that scaling is not a binary question. A system doesn’t either “scale” or “not scale.” It can survive larger datasets, preserve interesting behaviors, and still be far from where you want it to be.

The most valuable thing I gained wasn’t proof that my architecture is correct. It was evidence that some ideas are worth investigating further and others need to be rethought.

Perhaps the biggest realization is that building AI is less about adding complexity and more about removing unknowns. Every bug fixed, every assumption tested, and every failed experiment narrows the search space.

The architecture I started with is not the architecture I have today. And the architecture I have today is probably not the one I’ll have in a year.

Reality has a way of aggressively filtering ideas.

That’s frustrating sometimes.

It’s also how progress happens.

You can choose the game you play.

But you don’t get to change the rules.

Larkos changes and bug fixes

Okerew — Sat, 09 May 2026 13:14:09 +0000

Code and file restructure to make writing easier and to reduce file sizes while removing redundant code while also fixed a lot of bugs, rewrite of major portions of the README in https://github.com/Okerew/larkos

Improved testing logic in od.nvim, added a serializers module to ocote

Okerew — Sun, 03 May 2026 08:19:27 +0000

Improved testing logic to make it easier and better to use, fixed bugs in https://github.com/Okerew/od.nvim

Added a serializers module, with various serializers for ctypes and numpy to https://github.com/Okerew/ocote

Ocote

Okerew — Sun, 19 Apr 2026 18:37:55 +0000

Made ocote which is a library built on flask allowing for a socket like connection with encryption to a flask sever. https://github.com/Okerew/ocote

v1.21 update for gpumkat

Okerew — Fri, 10 Apr 2026 18:12:29 +0000

Removed rendering pipeline feature completely replaced with image data copying to a compute buffer, fixed low end gpu simulation logging not working or really not being there, fixed profiler logging, along with fixing other minor bugs and other minor features. I also made the thermal statistics actually come from something instead of the previous approximative calculations, removed energy statistics they were pointless either way.

https://github.com/MetalLikeCuda/gpumkat

Improved the social and emotional system - larkos(neural web)

Okerew — Mon, 06 Apr 2026 11:53:56 +0000

Improved the social and emotional system, along with making the moral comapss work better, added comments for readability and fixed bugs in larkos(neural web) https://github.com/Okerew/larkos

Also I forgot how the moral compass worked so added some comments there and improved it a bit so yeah.

Bug fixes for larkos optimizations for other of my software

Okerew — Sat, 28 Mar 2026 15:12:20 +0000

Bug fixes for knowledge system, indetity system, some smalller parts to larkos https://github.com/Okerew/larkos

Optimizations on compile for:
https://github.com/Okerew/osxiec
https://github.com/MetalLikeCuda/gpumkat

Neural Web renamed to Larkos, fixes and improvements

Okerew — Sun, 15 Feb 2026 17:32:30 +0000

Improved neural kernels, code changes, simplified some functions, fixed bugs, removed pybinding version (still kept cuda pybinding version though) replaced it with C version ment to be used with ctypes, renamed project to larkos in https://github.com/Okerew/larkos