DEV Community: Damjan Žakelj

research-ledger: a skill that helps one person and several AI models not fool themselves

Damjan Žakelj — Tue, 13 Oct 2026 06:52:24 +0000

I am not a professional researcher. I work in IT support, and in the evenings I explore ideas with several AI models: Claude, GPT, Gemini, Grok. Over a few months, that work produced a lot of ideas and very few results. It also showed me a pattern: the main risk was never a lack of ideas, it was fooling myself.

Out of that experience came research-ledger, an MIT-licensed skill (a SKILL.md folder) that turns any assistant that reads skills into a disciplined research partner. This post explains what it does, where it came from, and what it has caught so far.

The problem: four ways to fool yourself with AI

Models agree with each other. Three models saying "yes, this is a real connection" feels like evidence. It isn't. They share much of their training data, so agreement is a reason to check the algebra, not a result.
Metaphors dress up as mechanisms. "X in physics is like Y in learning" sounds deep. Usually nobody can write the step that actually transfers.
Thresholds move after the result. A 0.62 becomes "promising" because you wanted it to be.
"I didn't find it in the literature" becomes "it's new." That sentence is a statement about your search, not about the world.

What the skill does

idea ──► sieve (5 min) ──► translation ──► prior art ──► preregistration
                                             │
                     LANDED ◄────────────────┤
                                             ▼
                       pilot ──► confirmatory test ──► blind round (milestones)
                                             │
                                             ▼
            DEAD · LANDED · BRIDGE CANDIDATE · BRIDGE · EXPLANATION ──► ledger

Sieve first. Most ideas die in five minutes against a short checklist. They get no paperwork.
Translation. Every metaphor must become a measurable test or a precise statement with a proof goal. For each analogy, the skill asks one question: mechanism or theme? If you can't write the equation or step that transfers, it's a theme. It goes into the ledger, not into an experiment.
Prior art with scope. "Not found" is recorded together with the date, the search terms and the nearest source, never as novelty.
Preregistration. Predictions, thresholds, controls and statistical power are frozen before the run. In a Git ledger, a separate PREREG commit pushed before the run is the proof.
Pilot ≠ confirmatory test. A pilot may tune settings, but it never gives a PASS.
Blind rounds. At milestones, the same seed goes to two or three models from different labs, in clean conversations, with no project context.
Five verdicts.
- DEAD: wrong, a tautology, or killed by a control.
- LANDED: you rediscovered a known bridge. That's calibration, not defeat.
- BRIDGE CANDIDATE: known pieces, connection not found, and a new prediction.
- BRIDGE: only after a confirmatory test, a blind round and an independent check.
- EXPLANATION: a known mechanism explains the pattern.
Append-only ledger. Every "no" is kept, together with what it shows and the regime where its lesson holds.
Glossary. Every new term gets its standard name and a reference, or an explicit "no standard term known". A new name is not a new idea.

On first use the skill asks six to eight setup questions and writes a small config: your field, where the ledger lives, which models you have for blind rounds, and how strict to be. It also asks which of your own favourite hypotheses must never be used as premises.

Where the idea came from

It grew out of my own log of tests, roughly forty numbered experiments so far, in toy quantum models, combinatorics, small neural networks and numerology of physical constants. Every rule in the skill is a scar from one of them. A few examples:

"Zero error" can mean nothing. One model reproduced a set of measured ratios with error 0.0000. Then we ran the forgery control: random "fake" target ratios. About 3,700 formula "keys" fit the real numbers, and just as many fit the fakes. The fit was empty. That became the lock-leakage check: count how many keys fit the real lock and how many fit forged ones, before celebrating.
The translator inserts what it already knows. I fed fringe and amateur texts through models to look for ideas the mainstream had missed. Most "insights" turned out to be the model translating the text into a known concept. Of the leftovers that survived translation, 6 of 8 were known science that the amateur had rediscovered. Hence the rule: check every leftover against the literature before combining it with anything.
A control that can't differ from the treatment proves nothing. In a continual-learning test, the "noise control" turned out to be algebraically identical to the treatment, so the test had no power at all. The rule now: write down, before freezing, why control and treatment cannot coincide by construction.
Equal strengths hide everything. Several effects worked only when all components had the same weight and vanished with heavy-tailed weights. The rule now: always retest with heavy tails.

The seed style for blind rounds was added this month, after I studied the published problem prompts in openai/math. Their prompts say prove **or* refute* (never "show that"). They fix the conventions explicitly, list what is not in the setting, give no method hints and use no analogies. I adopted all of that.

What it has caught (honest results)

Most ideas die, and that is the method working. The ledger is mostly DEAD and LANDED entries. A pile of LANDED verdicts is useful in its own way: it measures what the translator already knows, not progress toward something new.

An example of a clean kill. One idea combined local learning rules (no backpropagation) with "selectivity": only units that match the input get updated. We preregistered kill criteria and a strong control: a fly-olfaction-style model with fixed random features. The result:

the selective rule made units go silent and starve, so it learned worse than updating random units;
learned features beat the fixed random ones by a lot, and even a 16× wider random model stayed behind;
plain feedback alignment without any gating did just as well as the gated version.

So the idea is not refuted in general, but it brings nothing in that setting. Written down, with the regime, so nobody tests it again.

Cross-lab review catches different things, and sometimes catches the reviewer. This week I used the method on a side project: a machine-readable atlas of proof techniques extracted from the 719 manuscripts in openai/math. Forty extracted "signatures" were reviewed blind by Claude (Anthropic) and Grok (xAI), with a frozen rubric.

Grok's first attempt: 40 out of 40 "OK", every justification field empty, and in its own words "spot checks". It missed an objective error, a multiplicity of 0 where the source says 1. We marked that review invalid, not as "disagreement".
Grok's second attempt, with a required quote from the source for every "OK", in four batches of ten: a real review.
Agreement: the two reviewers agreed on 35 of 40 items. Each caught something the other missed: Claude was stricter on missing preconditions, Grok caught a claim taken from lines outside the cited range.
Result: both reviewers passed 32 of 40 signatures (80%, 95% interval 65–90%). An earlier 6 of 10 had an interval of 31–83%, which told us almost nothing.

The lesson went straight into the method: a review needs proof that the reviewer actually read the source, and planted faulty items that it must catch.

A test registered before it can be contaminated. For the atlas we froze two "needs" from an open learning-theory question before anyone searched the atlas with them in mind. The test pits the atlas against plain grep on the same corpus, with a blind evaluator. My own bet, written in the preregistration: most likely undetermined. We'll see.

Honest limits

The method reduces self-deception. It does not produce discoveries.
Blind rounds remove my context, not the models' shared training data.
The checks come from a specific history. Each one is labelled with its regime, and the skill asks you to rate it useful or not for your problem instead of applying it blindly.

Try it

git clone https://github.com/Freeky7819/research-ledger
cp -r research-ledger/research-ledger ~/.claude/skills/

It also works in Claude.ai (upload the zipped folder) and in Codex (the folder includes agents/openai.yaml). Then just talk to it: "here's an idea…", "evaluate this paper", "this test gave 0.62, what now?", "write a blind-round seed for this".

If a rule fails you, open an issue with the case. That is exactly the kind of "no" the ledger is for.

Disclosure: the skill, the experiments and this post were developed together with AI models (mainly Claude, also GPT, Gemini and Grok). The questions and ideas are mine; most of the code and much of the wording were written with them.

DragonMemory: Neural Sequence Compression for Production RAG

Damjan Žakelj — Thu, 20 Nov 2025 20:20:39 +0000

TL;DR: DragonMemory is an open-source RAG system that compresses embedding sequences by 16x (128 tokens → 8 latent vectors) while maintaining high retrieval accuracy. Unlike traditional RAG systems that store full token embeddings, Dragon uses a trained neural compressor to reduce storage requirements and speed up similarity search.

Key Results:

16:1 sequence compression (128 → 8 positions)
90.4% token-level cosine similarity after reconstruction
>85% retrieval recall @ k=3 on internal benchmarks
~10ms inference per query on GPU
Production-ready with Streamlit GUI, persistence, and multi-LLM support

Repository: https://github.com/Freeky7819/DragonMemory

The Problem with Traditional RAG

Standard RAG systems face a fundamental trade-off:

Option 1: Store sentence embeddings (384D)

✅ Small storage footprint
❌ Loss of token-level granularity
❌ Can't capture complex semantic structure

Option 2: Store full token embeddings (128 × 384D)

✅ Rich semantic representation
❌ High storage cost (~197KB per document)
❌ Slow for large knowledge bases

DragonMemory offers a third option: learned compression that preserves semantic structure while reducing dimensionality.

How DragonMemory Works

The core is a PyTorch-based neural compressor with four key components:

Multi-Phase Resonant Pointer

Selects the most important tokens through multi-phase transformer analysis.

class MultiPhaseResonantPointer(nn.Module):
    def __init__(self, d_model=384, n_phases=2, total_depth=4):
        # Each phase refines token importance scores
        self.phases = nn.ModuleList([
            ResonantPointer(d_model, depth=depth_per_phase)
            for _ in range(n_phases)
        ])

        # LSTM maintains state across phases
        self.phase_memory = nn.LSTM(
            input_size=d_model // 2,
            hidden_size=d_model,
            num_layers=1
        )

Why multi-phase? Single-pass attention can miss subtle importance signals. Multiple phases with LSTM-based memory allow iterative refinement of token selection.

Empirical finding: 2 phases hit diminishing returns for most tasks. More phases help on noisy corpora but add latency.

Neighbor Mixer

Aggregates local context around selected tokens.

self.neighbor_mixer = nn.Sequential(
    # Depthwise convolutions aggregate local context
    nn.Conv1d(d_model, d_model, kernel_size=3, 
              padding=1, groups=d_model//32),
    nn.GELU(),
    # Dilated conv extends receptive field
    nn.Conv1d(d_model, d_model, kernel_size=3, 
              padding=2, dilation=2, groups=d_model//32),
)

Why mix neighbors? A token in isolation lacks context. Convolutions efficiently aggregate information from surrounding tokens before compression.

Harmonic Injection

Adds positional resonance to embeddings.

def harmonic(self, x):
    B, T, D = x.shape
    pos = torch.arange(T, device=x.device).float()
    signal = torch.exp(-0.0025 * pos) * torch.sin(6.28 * pos + 1.047)
    return x + self.harmonic_weight * signal

Why harmonic? Standard positional encodings are learned or fixed sinusoids. Harmonic injection uses a damped sinusoidal signal as a soft positional prior, helping the model preserve positional information after compression.

Compression Pipeline

def compress(self, x):
    h = self.harmonic(x)              # Add positional signal
    logits = self.pointer(h)          # Score token importance
    vals, pos = logits.topk(k=8)      # Select top-8 tokens

    m = self.neighbor_mixer(h)        # Aggregate local context
    compressed = m.gather(1, pos)     # Extract selected tokens

    gate = torch.sigmoid(vals)        # Confidence weighting
    compressed = compressed * gate    # Apply gates

    return self.ln(compressed)        # Normalize

Result: 128 input tokens → 8 compressed vectors (3072D when flattened, effectively 384D per position).

Training and Performance

The model is trained on sentence pairs with a hybrid loss:

loss = 0.3 * MSE(reconstructed, original) + 0.7 * CosineEmbeddingLoss(reconstructed, original)

Why cosine-heavy? RAG retrieval relies on cosine similarity. Emphasizing direction preservation (70%) over magnitude (30%) yields better retrieval performance.

Compression Accuracy

Metric	Score
Token-level cosine similarity	0.904 ± 0.02
Sentence-level cosine similarity	0.912 ± 0.015
Compression ratio	16:1
Inference time (GPU)	<10ms

Retrieval Performance

Internal benchmark on 6 documents with 6 questions shows perfect retrieval:

BASELINE (sentence embeddings):
  hit@1 = 1.000, hit@3 = 1.000, MRR@3 = 1.000

DRAGON (compressed embeddings):
  hit@1 = 1.000, hit@3 = 1.000, MRR@3 = 1.000

Note: This is a controlled benchmark for correctness verification. On larger, real-world datasets with partial/ambiguous queries, recall drops to ~85% @ k=3, which is still competitive while providing 16x compression.

Storage Efficiency

For 1 million documents (128 tokens each):

Format	Storage	Compression
Raw token embeddings (float32)	~197GB	1x
Dragon (float32)	~12GB	16x
Dragon (int8)	~3GB	64x

INT8 quantization: Using QuantileTransformer, Dragon vectors can be quantized to int8 with minimal accuracy loss (~2-5% cosine similarity drop). This stacks compression: 16x (sequence) × 4x (dtype) = 64x total.

Where DragonMemory Excels

Long-Context Documents

Traditional sentence embeddings lose granularity for long documents. Dragon maintains token-level structure:

# Example: Technical documentation
doc = """
Section 1: Installation requires Python 3.8+
Section 2: Configuration uses YAML files
Section 3: API authentication via OAuth2
"""

Sentence embedding gives a single 384D vector where all context is collapsed.

Dragon gives 8 × 384D vectors that preserve section boundaries.

Partial Query Matching

When queries match only part of a document, Dragon can match specific tokens while filtering out irrelevant context.

Empirical finding: Dragon achieves 78% recall @ k=1 on partial queries vs. 65% for sentence embeddings in our tests.

Storage-Constrained Deployments

For edge devices or large-scale systems:

# 10M documents with int8 quantization
storage_required = 10_000_000 * 8 * 384 / 1024 / 1024  # ~30GB

Comparison:

Raw tokens: ~2TB
Sentence embeddings: ~15GB (but lower accuracy)
Dragon with int8: ~30GB (best balance)

Where DragonMemory Struggles

Honest limitations:

Ultra-Short Fragments

Example: A single word like "Yes." becomes 2 tokens plus 126 padding tokens, creating poor signal-to-noise ratio.

# Example input
text = "Yes."
# After tokenization: 2 real tokens + 126 padding

Problem: The pointer must select 8 tokens from mostly padding, making compression ineffective.

Workaround: Use sentence embeddings for inputs shorter than 16 tokens.

List-Like / High-Entropy Sequences

Example: Lists where all items are equally important like "apples, oranges, bananas, grapes, melons" present a challenge.

# Example input
text = "apples, oranges, bananas, grapes, melons, pears, plums"
# All tokens have equal importance - no clear "top" tokens

Problem: When all tokens are equally important, top-k selection becomes lossy since the model must arbitrarily choose which tokens to keep.

Workaround: Segment into shorter chunks or increase compression ratio (e.g., use k=16 for 8:1 compression instead of 16:1).

Anaphora Chains

Example: Text with pronouns like "John went to the store. He bought milk. It was expensive."

# Example input
text = "John went to the store. He bought milk. It was expensive."
# Pronouns "He" and "It" are short tokens that may not rank in top-8

Problem: Pronouns like "He" and "It" may not be selected by the pointer, breaking coreference links and making the compressed representation ambiguous.

Workaround: Preprocess with coreference resolution to replace pronouns, or use larger k value (e.g., k=16 for 8:1 compression instead of 16:1).

Fixed Sequence Length

Currently limited to 128 tokens. Documents longer than this are truncated or chunked.

Future work: Dynamic sequence length support.

Production Features

DragonMemory isn't just a research prototype:

Streamlit GUI

streamlit run gui_app.py

Document processing: PDF, DOCX, TXT, MD upload
Chat interface: Query your knowledge base
Audio transcription: Whisper integration for voice notes
Memory management: Save/load knowledge bases

Multi-Backend LLM Support

# Local models via Ollama
agent.set_model("llama3")

# Cloud models via OpenAI
agent.set_model("gpt-4o")

Persistent Storage

# Save compressed knowledge base
rag.save_knowledge_base("memory.dragon", use_int8=True)

# Load later
rag.load_knowledge_base("memory.dragon")

Storage format: ZIP archive containing vectors, texts, and quantization parameters.

Getting Started

Installation

git clone https://github.com/Freeky7819/DragonMemory
cd DragonMemory
pip install -r requirements.txt

Quick Start

# Copy environment template
cp .env.example .env

# Edit with your settings
# OLLAMA_BASE_URL=http://localhost:11434

# Run GUI
streamlit run gui_app.py

Programmatic Usage

from src.resonant_rag import ResonantRAG

# Initialize (1:16 compression)
rag = ResonantRAG(ratio=16)

# Add documents
rag.add_memory("Your document text here...")

# Search
results = rag.search("your query", k=3)

# Save
rag.save_knowledge_base("my_kb.dragon", use_int8=True)

Running Benchmarks

python eval_dragon_benchmark.py --dataset-dir benchmarks/toy_rag

Technical Deep Dive

Why "Resonant" Architecture?

The name comes from the harmonic injection mechanism. This creates a resonant frequency that acts as a soft positional prior. During training, the model learns to "resonate" with this signal, using it as a guide for position-aware compression.

Theoretical motivation: Natural systems often exhibit resonant behavior at characteristic frequencies. By injecting a learnable resonant signal, we hypothesize the model can learn more stable positional representations.

Empirical observation: Removing harmonic injection drops reconstruction accuracy by ~3-5%. The learned harmonic_weight parameter typically converges to ~0.7, suggesting the model finds this prior useful but not dominant.

Why LSTM for Phase Memory?

Multi-phase processing could simply stack transformer layers. The LSTM adds:

Cheap recurrence: LSTM has ~60% fewer parameters than equivalent transformer
Phase drift prevention: Bottleneck forces compression of phase state, preventing LSTM from overpowering transformer signal
Stable gradients: LSTM's gating mechanisms help gradient flow across phases

Ablation result: Removing LSTM drops performance by ~2% but speeds up inference by ~15%.

Compression vs. Dimensionality Reduction

DragonMemory is sequence compression, not dimensionality reduction:

Method	Input	Output	Use Case
PCA/Autoencoder	128 × 384	128 × 64	Reduce dimensions, keep sequence length
Dragon	128 × 384	8 × 384	Reduce sequence, keep dimensions

Why this matters: Similarity search scales with sequence length. RAG cares about finding relevant documents quickly, so reducing sequence length (16x speedup) is more valuable than reducing dimensions (~6x speedup for 384→64).

Comparison to Alternatives

vs. Sentence Embeddings

Aspect	Sentence Emb	DragonMemory
Storage	384D	3072D (8 × 384)
Granularity	Single vector	8 positions
Long docs	Poor	Good
Partial queries	Weak	Strong
Speed	Fast	Fast

When to use Dragon: Long/complex documents, partial query matching, fine-grained retrieval.

When to use sentence embeddings: Short texts, simple queries, extreme storage constraints.

vs. Full Token Embeddings

Aspect	Full Tokens	DragonMemory
Storage	128 × 384	8 × 384
Accuracy	100%	~90%
Speed	Slow	16x faster
Scalability	Limited	High

When to use Dragon: Production systems with >100K documents, storage-constrained deployments.

When to use full tokens: Research, small-scale systems, maximum accuracy required.

vs. Product Quantization

PQ and Dragon solve orthogonal problems:

PQ: Reduces bits per dimension (384D → 96 bytes via 4-bit codes)
Dragon: Reduces sequence length (128 positions → 8 positions)

They can be combined for 64x total compression.

Future Directions

Dynamic Sequence Length

Current implementation is fixed at 128 tokens. Planned: adaptive ratio adjustment based on input length.

Domain-Specific Fine-Tuning

Pre-trained Dragon works well generally, but fine-tuning on domain-specific data (e.g., medical, legal, code) could improve accuracy.

Multilingual Support

Current model trained on English. Multilingual sentence transformers + Dragon compression could enable cross-lingual RAG.

Hierarchical Compression

For very long documents, apply Dragon compression recursively at multiple levels.

Online Learning

Current system is static after initial indexing. Investigating incremental updates without full retraining.

Reproducibility

All code, model weights, and benchmarks are open source:

Repository: https://github.com/Freeky7819/DragonMemory
License: AGPL-3.0 (free for personal/commercial, must open-source modifications if provided as service)
Model weights: dragon_pro_1_16.pth (included in repo)
Benchmarks: benchmarks/toy_rag/ (included)

To reproduce benchmark results:

python eval_dragon_benchmark.py --dataset-dir benchmarks/toy_rag

Expected output:

================= RESULTS =================
Number of questions: 6
Baseline dim: 384
Dragon dim:   3072
Sequence compression: 128 -> 8 (16x)
--------------------------------------------
BASELINE:
  hit@1 = 1.000
  hit@3 = 1.000
  mrr@3 = 1.000
DRAGON:
  hit@1 = 1.000
  hit@3 = 1.000
  mrr@3 = 1.000
=============================================

Contributing

We welcome contributions! Areas of interest:

Benchmarks: Testing on public RAG datasets (MS MARCO, Natural Questions)
Optimization: Faster inference, quantization improvements
Features: Multilingual support, dynamic sequence length
Documentation: Tutorials, use cases, API docs

See CONTRIBUTING.md for guidelines.

Conclusion

DragonMemory demonstrates that learned neural compression can achieve practical trade-offs for production RAG systems:

16x sequence reduction without catastrophic information loss
90%+ semantic fidelity maintained after compression
Production-ready with GUI, persistence, and multi-LLM support
Honest about limitations: not a silver bullet, but a useful tool

If you're building RAG systems and struggling with storage/speed constraints, DragonMemory is worth evaluating. It won't replace sentence embeddings for all use cases, but for long documents and partial query matching, the sequence compression approach shows promise.

Try it out: https://github.com/Freeky7819/DragonMemory

Acknowledgments

Sentence Transformers: Foundation for teacher embeddings
Ollama: Enabling local LLM inference
Streamlit: Rapid GUI prototyping
PyTorch: Neural network framework

Built with 🐉 by Damjan Žakelj

Questions? Open an issue on GitHub

Resonant Convergence Analysis (RCA): Intelligent Early Stopping That Cuts Training Time by 35–45%

Damjan Žakelj — Fri, 31 Oct 2025 07:49:57 +0000

Training deep-learning models often continues long after true
convergence, wasting GPU hours.\
Resonant Convergence Analysis (RCA) is a new open-source callback
that detects real convergence by analyzing oscillation patterns in
validation loss instead of relying on naive patience counters.

What is RCA?

RCA introduces two parameters:

Symbol Meaning Typical Range

β Resonance amplitude (training stability) 0--1
ω Resonance frequency (oscillation phase) ≈6 ± 0.5

Training stops when β ≥ 0.75 and oscillations flatten below a small
Δloss threshold.

Quick Example

from resonant_learner import ResonantCallback

rca = ResonantCallback(
    checkpoint_dir="./checkpoints",
    patience_steps=4,
    min_delta=0.003,
    ema_alpha=0.4,
    lr_reduction_factor=0.7,
    min_lr=1e-5,
    verbose=True,
)

for epoch in range(epochs):
    train_loss = train_epoch(...)
    val_loss = validate(...)
    rca(val_loss=val_loss, model=model, optimizer=optimizer, epoch=epoch)
    if rca.should_stop():
        print("RCA triggered early stopping.")
        break

Results (Production Validation)

Dataset Baseline RCA Compute Saved ΔAccuracy

MNIST 30 18 40% +0.12%
Fashion-MNIST 30 16 47% −0.67%
CIFAR-10 (ResNet-18) 60 45 25% +1.35%
BERT SST-2 10 7 30% −0.11%

Average compute reduction: ≈36%, accuracy preserved.

Installation

git clone https://github.com/Freeky7819/resonant-learner
cd resonant-learner
pip install torch torchvision

pip install -U pip setuptools wheel
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
pip install tqdm numpy pandas matplotlib timm transformers datasets

pip install -e .

pytest -q
python verify_installation.py

Reproduction Commands

CIFAR-10

python examples/cifar10_rca.py --epochs 60 --batch-size 128 --seed 42

BERT SST-2

python examples/hf_bert_glue.py --task sst2 --epochs 10 --batch-size 32 --seed 42

Learn More

📄 Scientific Validation Report on
Zenodo\
🔗 GitHub Repository\
🧠 Author: Damjan Žakelj --- Harmonic Logos

"Stop training when your model converges, not epochs later."

Harmonic RSI — Measuring Logical Resonance and Stability in AI Reasoning

Damjan Žakelj — Thu, 23 Oct 2025 00:13:49 +0000

TL;DR:
An open-source toolkit to measure how consistently an AI agent thinks — not just whether it gives the right answer.
👉 github.com/Freeky7819/harmonic-rsi

💡 Why this project exists

When evaluating large language models, we usually focus on compliance and accuracy.
But there's another dimension that often gets ignored — stability of reasoning.

How steady is the model’s internal logic from step to step?
Does it “drift” or “oscillate” between modes of thought?
Can we quantify that resonance instead of guessing?

That’s what the Harmonic RSI project explores.

🧩 What is Harmonic RSI?

Harmonic RSI (Resonance Stability Index) is a lightweight Python package that analyzes reasoning traces from AI agents — sequences of thoughts, plans, or explanations — and quantifies how coherent they remain over time.

It can be used standalone, or as a plug-in evaluator in frameworks like Rogue, LangChain, or EvalGen.

Main features:

🌀 Resonance Stability Index (RSI):
Measures logical drift via cosine distance between consecutive embedding vectors.

🔭 Resonant-filter mode (experimental):
Applies a log-periodic modulation on the embedding sequence to detect oscillatory instability.

🧩 ISM Φ-Layer:
Extracts phase-like signals from model embeddings and tracks ∂Φ/∂t (logical phase velocity).

🧠 Gradio UI:
Real-time reasoning dashboard:
Prompt → GPT → Embeddings → ISM → RSI

⚙️ CLI and API:
Works as a standalone evaluator or integrated pipeline.

⚙️ Quick Example
from harmonic_rsi import ResonanceEvaluator

trace = [
"Plan: gather data",
"Next: filter by category",
"Then: summarize results"
]

rsi = ResonanceEvaluator()
print(rsi.evaluate(trace, mode="embedding"))

Output

{'resonance_score': 0.87, 'phase_drift': 0.12, 'semantic_coherence': 0.91}

📊 Why it matters

Instead of treating reasoning instability as random noise,
RSI models it as a resonance pattern —
something that can be measured, compared, and potentially optimized.

Think of it as signal analysis for cognition — applied to LLMs.

⚖️ License & Ethos

License: CC BY-NC 4.0 — open for research, not for commercial use.

Goal: transparent exploration of internal model stability.

Not another leaderboard metric:
RSI complements standard evals; it doesn’t compete with them.

🧰 Try it out

Clone and run locally:

git clone https://github.com/Freeky7819/harmonic-rsi
cd harmonic-rsi/harmonic-rsi_final
pip install -e ".[st,dev]"
pytest -q
python -m harmonic_rsi.app_gradio

Gradio dashboard will open at localhost:7860
.

🙋‍♂️ Contributing

Feedback, testing, or critical discussion are very welcome.
If you’ve worked with evaluation frameworks (Rogue, HELM, EvalGen, etc.) — I’d love your thoughts on integrating RSI as a complementary layer.

GitHub: https://github.com/Freeky7819/harmonic-rsi

Harmonic Logos: Building Meaning Through Resonant AI

Damjan Žakelj — Sun, 19 Oct 2025 09:54:28 +0000

by Damjan Žakelj

Live development log: ChatGPT Share

GitHub repo: Harmonic-Logos-Demo

Community: r/HarmonicLogos

🌍 What is Harmonic Logos?

The Harmonic Logos Demo is an open-source experiment showing how structure and meaning can emerge through resonance — where physics, mathematics, and information interact coherently.

It’s not a “self-aware AI.”

It’s a transparent, verifiable framework that demonstrates how logical, ethical, and mathematical domains can interlink to create interpretable insight.

🧠 Core idea

Instead of neural black boxes, resonant systems use explicit symbolic domains that "echo" each other:

Module	Function
Scout	Detects relevant ideas across domains (physics, math, ethics, art…).
Hypothesis	Combines the hits into a reasoned explanation.
Cross-Link	Finds bridges between domains (e.g. symmetry ↔ compression).
Integrity Guard	Verifies every file’s hash in `manifest.json` for tamper-evidence.

The demo runs fully offline — no network calls, no hidden APIs.

⚙️ How to run it

Clone the repository:

git clone https://github.com/Freeky7819/harmonic-logos-demo.git
cd harmonic-logos-demo/demo

Create and activate a virtual environment:

python -m venv .venv
# Linux/macOS
source .venv/bin/activate

# Windows PowerShell
.\.venv\Scripts\Activate.ps1

Check integrity:

python verify_manifest.py

Run the demo:

python crosslink_demo.py
python run_example.py "How do biology and information stability connect to learning?"

Expected output:

SCOUT hits:
  physics: [...]
  math: [...]
  ethics: [...]
HYPOTHESIS: ...
CROSS-LINKS: ...

🎯 Why it matters

Transparency – Everything is open, checksummed, and human-readable.

Education – Demonstrates interpretable reasoning tools without opaque models.

Research value – Encodes “resonance logic” in reproducible form.

Safety – No self-modification, no data calls, no black-box behavior.

🤝 Call for collaborators

We’re looking for people who resonate with this idea:

Physicists, linguists, philosophers — to expand the registry of domains.
Developers — to add embeddings, feedback, or adaptive memory.
Thinkers — to explore resonance as a bridge between AI, cognition, and meaning.

Join us at

👉 r/HarmonicLogos

or share ideas via GitHub Issues or Pull Requests.

📜 License

Licensed under CC BY-NC 4.0 — see LICENSE in the repository.

✨ Closing note

Harmonic Logos is not just code — it’s a framework for understanding why reasoning itself can resonate.

If this vision speaks to you, come build with us.

HAL Meta-Scheduler: An Adaptive Layer That Learns How to Balance Your Cluster

Damjan Žakelj — Tue, 14 Oct 2025 11:54:44 +0000

🚀 Overview

HAL Meta-Scheduler is an adaptive orchestration layer that learns how to balance workloads in real time.

It doesn't replace your scheduler — it teaches it to breathe.

This open-source demo shows how simple feedback metrics can keep a distributed system stable under changing load and still save energy.

No proprietary math or hidden weights — everything you see here is functional and reproducible.

🧩 What It Does

HAL observes your cluster through four lightweight signals:

Symbol	Meaning	Role
σ	Coherence — how evenly the load is spread	stability indicator
H	Entropy — diversity of jobs per node	utilization diversity
δ	Queue drift — rate of pending growth	stress level
Φ	Informational potential — combined system tension	energy/stability metric

These are computed continuously and used to adjust the balance between packing (energy-efficient) and spreading (latency-resilient).

The result: fewer spikes, smoother utilization curves, and lower total energy per job.

⚙️ How It Works

HAL is implemented as a simple control layer:

Simulator – synthetic cluster with N nodes and a Poisson workload generator
Controllers – heuristic, PID, and Bayesian variants that adapt parameter p ∈ [0,1] (pack ↔ spread)
Metrics server – FastAPI + Prometheus /metrics endpoint for dashboards
Helm chart – deployable metrics demo for Kubernetes
Grafana dashboard – real-time visualization of σ, H, δ, Φ, and p

Everything runs locally with no external dependencies.

git clone https://github.com/Freeky7819/halms-demo
cd halms-demo
python -m venv .venv
.venv/Scripts/pip install -r requirements.txt
python simulate.py --steps 1500
python plot_metrics.py

yaml
Copy code

You’ll see two traces:

baseline (static scheduler)
adaptive HAL (dynamic control)

📊 Example Output

Queue spikes reduced by 40–70 %
Coherence σ stabilized near 0.9
Adaptive parameter p converging to steady state
Smooth Φ (stress metric) vs time

Even this demo, using only PID/Bayesian logic, shows how feedback control beats static heuristics for scheduling.

🧠 Why It Matters

Modern clusters waste cycles and energy because schedulers are blind to system feedback.

They rely on fixed heuristics like “bin pack until 80 % CPU” or “spread by labels”.

HAL introduces self-tuning — it reads the system’s own signals and re-balances automatically.

Benefits

✅ Reduced queue oscillations
⚡ Energy efficiency via adaptive packing
📈 Predictable latency under load
🔍 Native observability (Prometheus + Grafana)

Use cases

Kubernetes (as a policy advisor / extender)
HPC or SLURM queues
AI/ML job orchestrators
Edge or hybrid clusters

🧰 Tech Stack

Python 3.11 · FastAPI · Prometheus client · Helm v3 · Grafana · GitHub Actions CI (lint + SBOM)

License: Apache 2.0

🧭 Open vs Enterprise

Feature	Public Demo	Enterprise
Core control	heuristic, PID, Bayesian	proprietary resonant kernel
Deployment	metrics demo (Helm)	full operator + extender
Multi-cluster control	—	✅
Historical analytics	basic	advanced
SLA & support	community	commercial

The open demo is fully working — no placeholders — and safe for public use.

The enterprise version builds on this foundation for production-grade orchestration.

🧪 Try It

Live repo → github.com/Freeky7819/halms-demo

Run metrics server
python -m uvicorn server:app --host 127.0.0.1 --port 8015

Then open:
http://127.0.0.1:8015/metrics
or http://127.0.0.1:8015/live
yaml
Copy code

🤝 Contribute

Feedback, issues, and forks are welcome.

We’re particularly interested in:

new stability metrics
dataset-driven tuning
multi-cluster experimentation

Open discussions or PRs — everything helps us improve the adaptive model.

HAL is open, safe, and ready to explore.

If you’ve ever wondered what a scheduler with a feedback loop would look like — this is your playground.

🔗 GitHub → Freeky7819/halms-demo

Visualizing Trust in Multi-Agent Systems — The Swarm-ISM-X Public Demo (v2)

Damjan Žakelj — Mon, 13 Oct 2025 17:46:57 +0000

For the past months I’ve been experimenting with ways to visualize trust and stability in distributed AI systems — the kind of architectures where dozens of agents must cooperate without a central brain.

The result is something I call Swarm-ISM-X.

The Public Demo (v2) is now open-sourced — a clean, safe version that shows how the swarm behaves, not why it behaves that way.

🌀 What you’ll see

A Tkinter-based GUI that displays 10 agents along a horizontal line.

Each agent moves, stabilizes, and maintains formation under light “wind” disturbances.

Each agent has a “passport” indicator (green = valid, red = invalid).

An “Auto Demo” mode runs scripted sequences for presentations.

The simulation updates in real time — you can watch the system find balance, lose it, and regain it.

🔍 What’s really happening

Under the hood, each agent is governed by a simplified consensus-like controller:

Controller

$$
u_i \;=\; -\,k_i \nabla_i S
$$

where $S$ is a constraint vector maintaining equal spacing and total span.

The real ISM-X framework extends this idea with:

Adaptive gain tuning using resonant feedback (not in public demo).

Cryptographic attestation (Ed25519 + HMAC commitments).

Passport issuance and verification between agents.

Log-periodic modulation for stability over communication delays.

The public demo keeps only the first-order visible dynamics — enough to show formation control and disturbance recovery — while replacing sensitive parts with lightweight placeholders.

🔒 What’s included vs. hidden
Layer Included Hidden
GUI visualization ✅ –
Swarm dynamics (simple consensus) ✅ –
Passport system (stubbed SHA-1) ✅ Real attestation (Ed25519/HMAC)
Adaptive control & resonance ❌ proprietary
Informational geometry layer ❌ research
⚙️ Run it yourself
git clone https://github.com/Freeky7819/swarm-ismx-gui-demo.git
cd swarm-ismx-gui-demo
pip install numpy
python main_gui_public.py

Works out of the box on Python 3.10+.
The GUI shows live values of (||S||), (J), and per-agent gains (k_i).

🧩 Why it matters

Visual demos like this help bridge AI orchestration and trust architectures.
You can see — literally — what happens when an agent’s integrity fails, when noise enters, or when collective damping stabilizes the system.

This isn’t a neural network or RL — it’s a physically grounded, interpretable control system.
Think of it as a way to watch trust itself breathe.

GitHub: Swarm-ISM-X GUI Demo v2

Author: Damjan
Reason in resonance.

Feedback is always welcome — especially if you work on:

multi-agent coordination,

real-time visualization,

control theory + cryptographic verification bridges.

Let’s make AI agents not only smarter — but also more honest.

Building a Runtime Stability Framework for Autonomous AI — from Research to Working Prototype

Damjan Žakelj — Sun, 12 Oct 2025 07:40:24 +0000

⚙️ Abstract

Over the past months we’ve been developing a modular framework for real-time stability monitoring and self-regulation in AI systems.
The concept — internally codenamed ISM-X / RSC Stack — defines how autonomous agents can continuously measure their internal coherence, detect phase drift, and adaptively control their reasoning intensity or decision gating.

This article presents the current public architecture and project stage.
All critical core algorithms remain confidential and protected under trade-secret status.
However, the surrounding system — architecture, runtime, and observability stack — is open for review and potential collaboration.

🧩 The Core Idea (High-Level)

Every complex agent generates signals that describe its own state: semantic coherence, prediction stability, drift, loop gain, etc.
We treat these as vital signs — runtime telemetry for cognition.

Our framework defines:

how to collect and normalize those signals,

how to compute an abstract stability index (Γ) and a phase offset (Δφ),

and how to classify each state into lock, mini-lock, or out-of-lock regimes.

The internal mathematical transformation that governs this process remains proprietary.
What’s published here is the operational shell — a safe, auditable, and high-performance runtime environment.

🧱 System Architecture (Public Layer)

[Agent Loop] → metrics → [RSC Core] → {lock / mini-lock / out-of-lock}
                                  |
                                  v
                          Secure Collector (JSONL)
                                  |
      +---------------------------+---------------------------+
      |                           |                           |
  Prometheus Exporter        Web UI (FastAPI)            Alert Daemon
  (KPIs for Ops)            (Live monitoring)           (Webhook / SLA)

Modules included in the public stack:

runtime_adapter – standardizes input signals.

rsc_collector_v12 – high-speed JSONL collector with rolling checksum and optional AES-GCM encryption.

rsc_prom_exporter – exposes KPIs to Prometheus / Grafana.

rsc_webui – lightweight FastAPI dashboard for Δφ / Γ / lock status visualization.

rsc_alert_daemon – webhook alerting with threshold logic.

ismxlang.yaml – declarative configuration and policy definitions.

run_ismx.py – demo runner for local or simulated environments.

This version forms the public “shell” — safe to integrate, inspect and extend.
The confidential core is injected as a black-box module during internal builds.

🧪 Current Development Stage (October 2025)
Area Status Description
Architecture ✅ Stable

Modular, tested in local and simulated environments Runtime Logging ✅ Complete

JSONL + checksum + AES-GCM optional Prometheus / WebUI ✅ Functional Live metrics, Δφ / Γ visualization Core Model (Γ–Δφ) 🔒 Confidential Validated prototype, not publicly released Industrial Testing 🔄 In progress

Preparing MVP deployment for AI-Ops systems Security & Audit ✅ Implemented
No PII, hash-salted IDs, audit-ready rotation Collaboration 🟢 Open Seeking research & engineering partners

🚀 Why It Matters

Modern AI agents can lose internal coherence without realizing it.
Our framework adds:

self-monitoring capability – detect drift before failure,

adaptive gating – pause, reflect, or reduce output when unstable,

observability layer – operators see agent “health” in real time,

secure audit logs – verifiable, integrity-checked data trail.

It’s like a runtime nervous system for AI — lightweight, explainable, and safe.

🤝 Collaboration Invitation

We’re currently looking for:

AI/ML engineers with interest in runtime observability or agent orchestration,

research groups exploring autonomous stability and reflective control,

industry partners who want to integrate stability monitoring into AI-Ops or agentic frameworks.

Demo files:

Demo Light: https://drive.google.com/drive/folders/12PE-02hwDkm9nccfiUG9bZSZhERE6oxJ?usp=sharing

Demo with Docker: https://drive.google.com/drive/folders/1WaFSJwG-Yhha5bzpgujIrkl8B2CVMJWE?usp=sharing

Commercial licence: https://github.com/Freeky7819/rsc-open-demo

You can reach out to discuss collaboration, private demonstrations, or closed technical audits.

📧 Contact: zakelj.damjan@gmail.com
(Please include “RSC Collaboration” in subject line.)

🔒 Legal and IP Notice

The concepts, architecture, and partial implementations described here are protected by copyright © 2025 Damjan Žakelj.
Core algorithms, numerical transforms, and stability mappings (Γ, Δφ) are proprietary trade secrets.
Publication of this article constitutes defensive prior art against external patenting of identical methods.

Public components are released under the Creative Commons BY-NC-SA 4.0 license.
Commercial use requires written permission.

📜 Summary

ISM-X / RSC Stack represents a new category of runtime layer for AI agents:
a minimal, auditable, security-aware system that quantifies coherence and drift in real time.

The architecture is public.
The mathematics is protected.
The door for collaboration is open.

Building Trust for AI Agents — ISM-X: A Privacy-Preserving Identity Layer (with demo)

Damjan Žakelj — Fri, 10 Oct 2025 18:34:05 +0000

In distributed AI systems, continuity and trust are hard problems.
An agent that restarts, migrates, or forks can lose its identity.
ISM-X is our answer — a small, privacy-preserving layer that combines cryptographic identity (DID) and attestation (HMAC over commitment).

What we share

Reference code (Apache-2.0, ~250 lines)

Ed25519-signed passports

HMAC tag over pre-hashed commitments (no raw metrics)

Time/TTL, revocation, constant-time verification

What we don’t share

Any private resonance metrics or production keys.
The demo uses DEMO_KEY_DO_NOT_USE, safe for sandboxing.

Run the demo git clone https://github.com/Freeky7819/ismx-authy cd ismx-demo python ismx_open_demo.py

You’ll see the passport issuance, signature verification, and audit log in action.

Why this matters

ISM-X bridges two domains:

Identity: persistent cryptographic DIDs.

Integrity: attestations that don’t leak proprietary state.

It’s a foundational step for local-first, privacy-preserving AI systems.

What’s next

3-of-5 policy quorum

FROST/BLS threshold signatures

optional ZK-commit proofs

🔗 GitHub – ISM-X Demo Public Pack v1

License: Apache-2.0
Author: Freedom (Damjan)