README.md

---
license: mit
language: en
tags:
- fractus
- hypervectors
- training-free
- knowledge-ingestion
- moe
- continuous-thought
- vector-symbolic-architectures
---

# Fractus-Vorax

**The Fractus that never trains again. It eats.**

**Fractus-Vorax is NOT a fine-tune. NOT a RAG wrapper. NOT an API mashup.** It is a knowledge-ingestion organism grafted onto a born-once CTE brain: the weights of the underlying 1B model are **sealed in read-only memory** — the training loop is dead, permanently — and every byte of new knowledge arrives by **writing**, never by gradient. It remembers forever, generalizes by analogy, spawns a new expert per dataset, and speaks through mechanical decoding dynamics. Zero GPU. Zero LLM externals. Zero retraining, ever.

> Le manifeste complet (français) : [`README.fr.md`](README.fr.md) — the founding takeover document.

---

## The Pact

The birth brain (`FRACTUS_1B_PHASE2_FROZEN_MERGED.pt` — the final checkpoint of the 8× RTX 5090 run, pushed 2026-08-18 04:20) is loaded via `mmap` **read-only**: no code path can write a weight. The pact is not a convention, it is physical. Sha256, verification transcript and the full act are in [`docs/NAISSANCE.md`](docs/NAISSANCE.md).

```
This brain will NEVER be retrained.
No gradient will ever touch its weights.
All new knowledge arrives by ingestion.
Training stops here.
```

## Quick Start

```bash
git clone https://huggingface.co/thefinalboss/fractus-vorax  # or local copy
cd fractus-vorax

# Substrate venv (numpy-only, CPU, no torch needed for the organs):
#   any Python ≥3.10 with numpy + pytest — the full substrate suite runs.

# Full-stack venv (adds the native CTE/Fractal kernels — torch CPU):
py -3.11 -m venv .venv-torch
.venv-torch/Scripts/python.exe -m pip install torch --index-url https://download.pytorch.org/whl/cpu
.venv-torch/Scripts/python.exe -m pip install tokenizers numpy pytest

# Fetch the sealed birth brain (4.66 GB — lives on the fractus-cte repo):
.venv-torch/Scripts/python.exe -c "from huggingface_hub import hf_hub_download; hf_hub_download('thefinalboss/fractus-cte', 'checkpoints/FRACTUS_1B_PHASE2_FROZEN_MERGED.pt', local_dir='checkpoints')"
mv checkpoints/checkpoints/FRACTUS_1B_PHASE2_FROZEN_MERGED.pt brain/FRACTUS_BIRTH.pt  # (mkdir brain first)

# Tests (both environments, honestly counted):
.venv-torch/Scripts/python.exe -m pytest -q          # 199 passed (full stack)

# Feed it something, then talk to it:
.venv-torch/Scripts/python.exe -m fractus_vorax.agent.repl --brain ./brain
fractus_vorax> :ingest my_data.csv
fractus_vorax> :core brain/FRACTUS_BIRTH.pt
fractus_vorax> :say what is the capital of japan     # the 1B answers, out of its own mouth
```

## What is Fractus-Vorax?

The Fractus lineage made a bet: a model can be a **dynamical system** (continuous thought, Kuramoto-routed experts, persistent carrier states) rather than a frozen function. Fractus-cte proved the training side. Fractus-Vorax takes the other side of the relay:

- **Fractus-cte** trains the brain (8 GPUs, mean-merged hourly, sealed at the end).
- **Fractus-Vorax** refuses to ever train it again — and makes it *know things anyway*.

### What makes it different from GPT/RAG?

| | GPT-style | Fractus-Vorax |
|---|---|---|
| New knowledge | retrain / fine-tune / context window | **compiled to `.kn` and written** into organs, O(1) per atom, permanent |
| Forgetting | catastrophic | append-only memory: it cannot forget |
| Unseen data | hallucinates confidently | **answers 0.00 on facts it never ate** (measured floor) |
| Generalization | emergent from gradients | analogy (3CosAdd/3CosMul over char-ngram slots) — morphological, measured |
| Growth | bigger training run | each dataset **spawns a routed expert** — physical growth, no joint training |
| Speaking | the model speaks | **mechanics speak**: anti-attractor decoding + organ steering on a sealed brain |
| Hardware | datacenter | laptop CPU (kernels optional, torch CPU) |

## Architecture

```
DATA (csv/json/jsonl/txt/md/anything)
   │  one pass, closed forms (hash, counting, SVD) — compilation, not optimization
   ▼
┌──────────────────────────────────────────────────────────────┐
│ KNOWLEDGE COMPILER (.kn) — deterministic, bit-identical      │
└──────────────┬───────────────┬───────────────┬───────────────┘
               ▼               ▼               ▼
   ORGAN 1 · TRACES    ORGAN 2 · HEBBIAN   ORGAN 3 · SPAWN
   hippocampus:        cortex: closed-     growth: one expert
   append-only HV      form outer-product  per dataset, routed
   memory + LSH-style  writes, ΔE gate     by HV signature
   retrieval           refuses degradation (physical MoE growth)
               │               │               │
               ▼               ▼               ▼
        CARDS (FACT / HEBBIAN / ANALOGY / GAP) — the organ output
               │
               ▼
   SEALED CTE BRAIN (1.165B params, 440/440 strict, read-only mmap)
   + SPEAK: z-norm anti-attractor decoding, repetition penalty,
     answer-lock steering (the organs articulate THROUGH the core)
               │
               ▼
   The conversation itself is written back O(1) — it learns as you talk.
```

**Parameter accounting:** the brain is the 1.165B CTE (d=1280, 16 blocks, 128 batched experts top-2, carrier states `thought_state`/`attn_S`/`attn_z`, tied observe/output head, confidence & salience heads). The organs are **parameter-free** (hypervector memory: capacity scales with dimension, not weights). Strict-load verified key-for-key (440/440) and **bit-identical** against the reference engine on identical weights.

## The Mechanics of Speech (honest)

The sealed brain was trained on ~124.5M tokens (8-GPU merged). Greedy decoding collapses into repetition attractors (` the the the…`, `**`×8) — logits span ±265, self-reinforcing loops. **This is not mutism; it is a decoding dynamics problem.** Fractus-Vorax treats it as mechanics:

1. **Z-normalization of logits** — crushes the attractor's runaway scale (measured std ~26 calm, hundreds in-loop).
2. **Repetition penalty** — breaks self-reinforcement; vocabulary is liberated (`philosophy`, `manufactures`, `archaeological`, `UNCLASSIFIED`… verbatim in the README.fr / reports).
3. **Answer-lock steering** — when the organs know the answer, its BPE tokens are biased step-by-step through the core's own distribution: the words come out of the 1B's mouth, the knowledge comes from the organs.

**Measured (real 1B, verbatim, paired seeds):**
- Locked answers: **4/4 capitals** appear in the generation (` paris`, ` tokyo` clean; `madrid`/`rome` arrive fragment-glued — the lock covers the answer's BPE fragments, the free continuation doesn't know the word ended; reported as-is, 9/9 locked tokens emitted at their step).
- First-token steering (soft bias, no lock): 2/4 vs 0/4 unsteered.
- Free speech: real English vocabulary, **syntax absent** at this training depth. That gap belongs to the brain's nascence, not to the mechanics.
- Open-skies reading: expert gates sit at a near-tie 0.50/0.50 per layer (κ_eff = 1.6, adjacent Farey phases) — that is the measured routing of this checkpoint, not a reader artifact.

## Benchmarks (honest floors included)

| Measure | Result |
|---|---|
| Held-out paraphrases (never-seen queries of eaten facts) | **1.00** |
| Held-out typos (morphologically novel slots) | **0.98** |
| Control: facts never ingested | **0.00** — it does not guess |
| Floor: cards disabled | **0.00** — the organs are the entire effect |
| Ingestion | one pass, ~1.1k atoms/s compile, CPU |
| Query latency | ~7 ms (organs), CPU |
| Gradients used, total, since birth | **0** |

A single accuracy number cannot represent both retrieval and generalization. The paraphrase score measures order-invariant encoding; the typo score measures char-ngram analogy transfer; the 0.00 controls are the honesty floors — any run that inflates the headline while moving the unseen-facts control off 0.00 is reporting hallucination, not knowledge. Full harness: `bench/killer_bench.py`; core-speech harness: `bench/core_speak.py --mode {greedy,mechanic,steered}`.

## Research Results (Honest)

**Validated:**
- Training-free expertise: ingest → 0.99 held-out accuracy, zero gradient (killer bench, floors included).
- Morphological generalization: typo→answer via 3CosMul over char-ngram slots (ANALOGY cards, sim 1.00 on real typos).
- Hebbian closed-form writes with a ΔE gate: degrading writes refused and rolled back (measured), corroboration cards at sim 1.00.
- Physical growth: per-dataset expert spawn + signature routing, no joint training.
- Strict checkpoint fidelity: 440/440 keys, **bit-identical** outputs vs the reference CTE engine on identical weights (max diff 0.0 across prompt chunk, carry chunk, full greedy trajectory).
- Mechanical speech unlock: anti-attractor decoding liberates the sealed brain's vocabulary; answer-lock yields 4/4 articulated answers.
- Determinism as an invariant: same source → bit-identical `.kn`; same seeds → same words.

**Honest limits:**
- Syntax is absent at 124.5M training tokens. Low teacher-forced loss never meant free-run speech (the exposure-bias gap Fractus-cte documents); the mechanics liberate the lexicon, not grammar.
- Chinchilla does not apply here (sparse structured MoE, 1B capacity / ~119M active) — the brain's own scaling law governs; we report tokens processed, not "under/over-trained" folklore.
- Answer-lock articulates what the organs know; it is displayed as a mechanism (`[ORGANES]` line before every `[PAROLE]` line), never hidden in the output.
- Steering boosts shift distributions; they do not guarantee the draw (2/4 vs 0/4 first-token, measured with paired seeds).

## Lineage

`palimpseste` (hypervector cortex, learning-by-writing) → `ensemble` ("training is dead", portable `.exp` experts) → `fractus` / `fractus-cte` (the CTE brain, continuous thought, 8-GPU living training) → **`fractus-vorax`** (the takeover: sealed brain + ingestion organs + mechanical speech). Full attributions: [`ATTRIBUTIONS.md`](ATTRIBUTIONS.md). Research archive and full plan/spec history: [`docs/heritage/`](docs/heritage/) and the `vorax` repository (v1.2).

**No corporation can control it.** CPU-first, no external LLM, no API, weights read-only, knowledge portable as `.kn` files.

---

*Fractus was born once. Fractus-Vorax never lets it train again — it only eats.*