Osakra

norn-v15

README

License: apache-2.0

Abstract

Standard large language models perform complex multi-step reasoning by autoregressively generating explicit tokens into a visible textual scratchpad (Chain-of-Thought, CoT). While effective, this discrete paradigm incurs substantial token generation latency, quadratic key-value cache growth, and is constrained by vocabulary discretization bottlenecks. In this technical report, Osakra Research shares Project Norn V15, an exploratory 4.45-Billion parameter neuro-symbolic language model engineered to test Continuous Latent Chain-of-Thought (Latent CoT) reasoning directly within hidden representation space ( $h \in R d$ ) on consumer-grade local hardware.

We make no claims of outperforming massive 70B+ scale flagship models on open-ended general intelligence. Instead, this project investigates whether introducing Dynamic Stochastic Recurrence ( $k \sim U {2, 16}$ ), quadratic Attractor Drift Regularization ( $L drift $ ), and continuous-time modulation from a Liquid Time-Constant (LTC) ODE brainstem and a Holographic Reduced Representation (HRR) associative memory engine can help a compact 4B-class model approach competitive performance on targeted structured reasoning tasks under modest local hardware constraints (< 4.5 GB active VRAM).

Across a 250-sample held-out evaluation suite (bundled directly with this release for complete reproducibility), Norn V15 achieves a Composite Evaluation Score of 71.6% (174 / 250 correct) under an Auto-Router policy, approaching or matching significantly larger models on structured arithmetic (76.0% GSM8K, $k = 2$ ), collegiate STEM (65.0% MMLU, $k = 8$ ), and algorithmic coding (72.0% CodeAlpaca, $k = 4$ ). All weights, biological projections, inference code, and the complete 250-sample test suite are released openly under the Apache-2.0 license.

1. Introduction & Research Scope

Verbalized Chain-of-Thought reasoning (Wei et al., 2022; Kojima et al., 2022) has demonstrated remarkable empirical success. However, generating visible reasoning tokens carries notable practical trade-offs:

Generation Latency: Emitting hundreds of intermediate tokens incurs sequential forward-pass latency.
KV-Cache Memory: Text scratchpads scale memory consumption quadratically with sequence length $O (T 2)$ .
Representation Bottleneck: Discretizing internal continuous states into vocabulary tokens restricts gradient-guided intermediate representations.

While prior research has explored recurrent internal deliberation (Goyal et al., 2021; Dohan et al., 2022), models often suffer from representation drift or collapse when recurrence depth exceeds a few steps. Project Norn V15 explores whether variable-depth stochastic training and attractor regularization can stabilize continuous deliberation across variable horizons ( $k \in [2, 16]$ ) on a standard consumer laptop GPU.

2. Mathematical Architecture Formulation

$h t (k) = T θ (h t (k - 1) ) + α W$

Embedding Manifold: Input tokens $x 1 : t $ are mapped to initial representations $h t (0) = E (x 1 : t ) \in$ .

3. Empirical Evaluation & Multi-Domain Benchmarks

All results were obtained on a local consumer laptop (RTX 4070 Laptop GPU, 4.45B model in 4-bit NF4, < 4.5 GB active VRAM).

Project Norn V15 Benchmark Comparisons

3.1 Comparative Scorecard Across Model Scales

Evaluated on the bundled 250-sample held-out suite (evaluation_suite_250.json).

Table with columns: Pillar / Benchmark, Domain Evaluated, Qwen3-4B-Base, Project Norn V15 (Auto-Mode), Norn V15 (Flash Step 2s), Llama-3.3 (70B), Claude 3.5 Haiku, GPT-4o mini, Frontier MoE (Projected)
Pillar / Benchmark	Domain Evaluated	Qwen3-4B-Base	Project Norn V15 (Auto-Mode)	Norn V15 (Flash Step 2s)	Llama-3.3 (70B)	Claude 3.5 Haiku	GPT-4o mini	Frontier MoE (Projected)
Pillar 1: GSM8K Math	50 Multi-Step Problems	40.0%	76.0% (38/50)	82.0% (41/50)	86.0%	75.0%	82.0%	97.5%

[!NOTE] As expected, large 70B+ frontier models retain a clear advantage on broad, unstructured general knowledge and open-domain comprehension. Norn's value is in demonstrating that a compact 4.45B model can achieve competitive structured accuracy within specific technical domains on consumer hardware.

3.2 Comparison with Leading Sub-5B Compact Baselines

Table with columns: Benchmark / Capability, Google Gemma-2 (2B-IT), Meta Llama-3.2 (3B-IT), Microsoft Phi-3.5 (3.8B-mini), Alibaba Qwen2.5 (3B-IT), Project Norn V15 (Auto-Mode)
Benchmark / Capability	Google Gemma-2 (2B-IT)	Meta Llama-3.2 (3B-IT)	Microsoft Phi-3.5 (3.8B-mini)	Alibaba Qwen2.5 (3B-IT)	Project Norn V15 (Auto-Mode)
Active Parameters	2.61B	3.21B	3.82B	3.09B	4.45B
Active VRAM Footprint	~2.5 GB	~3.0 GB	~3.8 GB	~3.0 GB

4. The Core Discovery: Latent Compute Scaling as an Orthogonal Dimension

Contemporary artificial intelligence research is witnessing a fundamental transition in scaling laws:

Pre-training Scaling ( $N, D$ ): Scaling model parameters and pre-training tokens (Kaplan et al., 2020; Hoffmann et al., 2022) yields diminishing marginal returns under severe power, data, and hardware constraints.
Test-Time Search in Token Space (OpenAI o1/o3; Snell et al., 2024): Demonstrates that allocating compute at inference time unlocks dramatic reasoning improvements. However, verbalizing reasoning into explicit textual tokens incurs severe penalties: quadratic key-value cache expansion ( $O (T 2)$ ), substantial generation latency, and the discrete vocabulary bottleneck.
The Latent Compute Frontier (Project Norn): Norn V15 demonstrates an alternative, orthogonal scaling paradigm: scaling continuous recurrence passes ( $k$ ) within internal hidden vector space ( $h \in R$ ).

Project Norn V15 Compute Scaling Curve

4.1 Empirical Evidence: Domain-Dependent Deliberation Windows and Entropy Thresholds

Across 1,000 evaluation checkpoints from $k = 0 \to 16$ , analysis of the latent scaling trajectory reveals a critical, nuanced empirical dynamic: continuous latent compute does not scale uniformly across task archetypes, but exhibits domain-dependent optimal deliberation windows governed by task entropy:

High-Entropy Exploratory Reasoning (Collegiate STEM MMLU): Scales monotonically with deeper deliberation, advancing from $26.7% \to 63.0% \to 65.0%$ at $k = 8$ (+38.3% over zero-shot base) as extended recurrence enables iterative candidate hypothesis evaluation and distractor elimination before token emission.
Closed-Form Precision (GSM8K Math): Peaks sharply at $k = 2$ (82.0% vs 40.0% base). Because deterministic arithmetic tasks possess narrow, rigid attractor basins, brief deliberation rapidly snaps representations into the correct numerical manifold; over-deliberating ( $k \geq 4$ ) induces vector diffusion and manifold drift that degrades performance (60.0% at , 52.0% at ).

Architectural Justification for the Auto-Router: Because closed-form arithmetic and rigid tool-calling decay when over-deliberated while exploratory collegiate STEM demands deep deliberation, static-depth recurrent models inevitably suffer performance decay on multi-domain evaluations (composite index steadily declines past $k = 2$ : $72.4% \to 68.0% \to 59.6% \to 54.5%$ ). Norn V15's Dynamic Deliberation Auto-Router dynamically evaluates task entropy to route queries to their domain-optimal depth, achieving a state-of-the-art 71.6% composite score without wasteful compute or representation collapse.

4.2 The Potential of Scaling to Larger Architectures

The central takeaway of Project Norn V15 is not merely the performance of this specific 4.45B model, but the scaling trajectory of continuous latent reasoning itself:

Compute-to-Accuracy Efficiency: In discrete CoT, a model must generate ~500 tokens (~500 sequential forward passes) to reason through a complex problem. In Norn V15, just 2 to 8 internal latent iterations ( $k \in [2, 8]$ ) achieve comparable or superior grounding at a fraction of the wall-clock latency and zero KV-cache overhead.
The Open Horizon (14B, 32B, 70B+): If a modest 4.45B model running entirely on a single consumer laptop (< 4.5 GB VRAM) can close the gap to significantly larger baselines through latent deliberation, what happens when Continuous Latent CoT is trained on 14B, 32B, or 70B foundation backbones?
Manifold Smoothness at Scale: Higher-dimensional models possess smoother latent representations and higher attractor capacity, suggesting that the dynamic stochastic regularization ( $L drift $ ) proven here will scale with even greater stability on massive architectures. We release this model and dataset to encourage the community to explore this scaling frontier.

5. Multi-Horizon Deliberation Sweep Reference Table

Table with columns: Pillar, Domain Evaluated, Held-Out Test Set, Flash Step (k=2), Balanced (k=4), Deep (k=8), Max (k=16), Auto-Mode
Pillar	Domain Evaluated	Held-Out Test Set	Flash Step ( $k = 2$ )	Balanced ( $k = 4$ )	Deep ( $k = 8$ )	Max ( $k = 16$ )

6. Bundled Reproducible Evaluation Suite

To facilitate independent verification, the exact 250 evaluation samples and benchmark script are included directly in this repository:

Dataset File: evaluation_suite_250.json (50 GSM8K math, 100 collegiate MMLU, 50 CodeAlpaca, 30 HRR analogies, 20 agentic sandbox tasks).
Evaluation Script: run_benchmark.py.

How to Reproduce Locally:

bash
python run_benchmark.py --suite evaluation_suite_250.json --steps auto

6.1 Data Integrity & Contamination Audit

To ensure scientific validity and verify zero test-set leakage, an automated multi-tier audit scanned all 250 evaluation samples across all 17 training corpus files (15,791 total training records) using exact substring matching, 12-gram sequence analysis, and 8-gram Jaccard similarity metrics:

Table with columns: Evaluation Pillar, Samples Audited, Active Training Set Matches, 12-Gram Leakage, Contamination Status
Evaluation Pillar	Samples Audited	Active Training Set Matches	12-Gram Leakage	Contamination Status
GSM8K Math	50	0 (0.00%)	0	100% PRISTINE (Zero Leakage)
MMLU Academic	100	1 (1.00%)*	0 (Template boilerplate only)	*99% PRISTINE (Upstream CAIS Duplicate)**
CodeAlpaca Code	50

*Note on MMLU: The single match (mmlu_31, quasar 3C9 physics problem) is due to an upstream duplicate in the official cais/mmlu dataset, occurring in both validation (#156) and test (#1440). Other detected 12-grams correspond to standard benchmark prompt templates (e.g., standard USMLE clinical framing).
**Note on CodeAlpaca: While the active training and evaluation partitions form a strictly disjoint split with zero overlap in active training, ancestral adapter checkpoints during initial pre-tuning had historical exposure to the broader open-source pool. We encourage independent evaluation on completely external benchmarks (e.g., HumanEval, EvalPlus).

7. Model Architecture & Parameter Audit

Table with columns: Component, Tensor Specification, Precision / Type, Active Parameter Count
Component	Tensor Specification	Precision / Type	Active Parameter Count
Frozen Base Backbone	`Qwen3ForCausalLM`	4-bit NF4 Quantized	4,411,424,256 (~4.411B)
Trainable LoRA Adapters	Rank 16, Alpha 32 (`q,k,v,o,gate,up,down`)	16-bit Bfloat16	33,030,144 (~33.03M)
LTC ODE Brainstem Projection	`Linear(32 -> 2560)`	16-bit Bfloat16

8. Quickstart & Usage

8.1 Installation

bash
# Clone from Hugging Face:
git clone https://huggingface.co/Osakra/norn-v15
cd norn-v15

# Or clone from GitHub:
# git clone https://github.com/Osakra-Research/Norn.git
# cd Norn

pip install -r requirements.txt

8.2 Interactive Console (Auto-Mode Default)

bash
python chat.py --steps auto

8.3 Python API Integration

python
import os
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import PeftModel
from norn_wrapper import HybridNornWrapperV4

device = "cuda" if torch.cuda.is_available() else "cpu"
target_dtype = torch.bfloat16 if device == "cuda" else torch.float32

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type="nf4"
) if device == "cuda" else None

base_model_id = "Qwen/Qwen3-4B-Base"
tokenizer = AutoTokenizer.from_pretrained(base_model_id, trust_remote_code=True)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

load_kwargs = {"device_map": "auto" if device == "cuda" else None, "trust_remote_code": True}
if bnb_config:
    load_kwargs["quantization_config"] = bnb_config
else:
    load_kwargs["torch_dtype"] = torch.float32

base_model = AutoModelForCausalLM.from_pretrained(base_model_id, **load_kwargs)
peft_model = PeftModel.from_pretrained(base_model, "./")

norn = HybridNornWrapperV4(
    peft_model=peft_model,
    embed_dim=base_model.config.hidden_size,
    ltc_dim=32,
    hrr_dim=256
)
norn.ode_proj.to(device=device, dtype=target_dtype)
norn.hrr_proj.to(device=device, dtype=target_dtype)

bio_state = torch.load("norn_biology_proj_v15.pt", weights_only=False, map_location=device)
norn.ode_proj.load_state_dict(bio_state['ode_proj'])
norn.hrr_proj.load_state_dict(bio_state['hrr_proj'])
norn.eval()

# Initialize biological context vectors (LTC ODE brainstem state & HRR associative vector)
ode_latent, hrr_vector = norn.init_bio_states(batch_size=1, device=device, dtype=target_dtype)

# Continuous Latent Deliberation via Auto-Router
prompt = "Question: Tracy used a 4-foot wire to support tomato plants. She cuts it into 6-inch pieces. How many pieces does she get?"
output_tokens = norn.generate_with_latent_cot(
    tokenizer=tokenizer,
    prompt=prompt,
    num_latent_steps="auto",
    max_new_tokens=256,
    ode_latent=ode_latent,
    hrr_vector=hrr_vector
)

print(tokenizer.decode(output_tokens[0], skip_special_tokens=True))

8.4 Running with LM Studio & Ollama (Universal Local API Adapter)

Project Norn V15 includes a dedicated local API adapter (norn_api_server.py) that implements both OpenAI and Ollama REST specifications with real-time streaming support. This allows frontends such as LM Studio, Ollama CLI, Open-WebUI, Cursor, or Continue to run Norn while preserving its full hybrid architecture (Continuous Latent CoT deliberation, LTC ODE brainstem modulation, and HRR associative memory):

1. Start the Universal Adapter Server

bash
# Serves both OpenAI (/v1/chat/completions) and Ollama (/api/chat, /api/tags) protocols
python norn_api_server.py --port 11434 --steps auto

2. Connect LM Studio

In LM Studio, go to Local Server / Developer Settings.
Set endpoint: http://localhost:11434/v1
Select model: norn-v15

3. Connect Ollama & Open-WebUI

Any client configured for Ollama can point directly to http://localhost:11434.
The model will appear as norn-v15:latest in ollama list and Open-WebUI model dropdowns.

4. Direct Ollama Modelfile Registration (Optional)

bash
ollama create norn -f ./Modelfile
ollama run norn

5. Merging LoRA Weights for Standalone GGUF Export

bash
python merge_lora.py --output_dir ./norn_v15_merged
# Convert to GGUF using llama.cpp:
# python llama.cpp/convert_hf_to_gguf.py ./norn_v15_merged --outfile norn-v15-q4_k_m.gguf

9. References

Vaswani, A., et al. (2017). Attention is all you need. NeurIPS.
Wei, J., et al. (2022). Chain-of-thought prompting elicits reasoning in large language models. NeurIPS.
Hasani, R., et al. (2021). Liquid time-constant networks. AAAI.
Plate, T. A. (2003). Holographic Reduced Representations. CSLI Publications.
Hu, E. J., et al. (2021). LoRA: Low-rank adaptation of large language models. ICLR.
Dettmers, T., et al. (2023). QLoRA: Efficient finetuning of quantized LLMs. NeurIPS.
Cobbe, K., et al. (2021). Training verifiers to solve math word problems. arXiv:2110.14168.
Hendrycks, D., et al. (2020). Measuring massive multitask language understanding. ICLR.
Goyal, A., et al. (2021). Recurrent independent mechanisms. ICLR.
Dohan, D., et al. (2022). Language model cascades. arXiv:2207.10342.
Kojima, T., et al. (2022). Large language models are zero-shot reasoners. .

10. Citation

bibtex
@misc{osakra_norn_v15_2026,
  title={Project Norn V15: Continuous Latent Chain-of-Thought Reasoning via Dynamic Stochastic Recurrence},
  author={{Osakra Research}},
  year={2026},
  howpublished={\url{https://huggingface.co/Osakra/norn-v15}},
  note={Hugging Face Technical Report and Model Release}
}

Osakra Research

Available on FriendliAI

Dedicated Endpoints

Run this model inference on single tenant GPU with unmatched speed and reliability at scale.

Learn more

Container

Run this model inference with full control and performance in your environment.