1.7 million parameters. 311 concepts. One GPU. No tokenization.
Every major AI lab responded to the same problem the same way: make the model bigger. More parameters. More data. More compute. The assumption was simple: intelligence is what happens when you make the model big enough.
We went the other direction.
Origin is a developmental AI system trained with the Genesis framework. The current implementation, OLT-1, operates with 1.7 million parameters. That's 75 times smaller than the GPT-2 base we started with. It has 311 concepts. It runs on consumer hardware. Its training data fits on a hard drive.
And it demonstrates progressive understanding across physics, emotions, comparison, and quantity domains. Not pattern matching. Understanding, in the sense that it can answer follow-up questions it was never explicitly trained on.
Three Generations of Getting It Wrong
OLT-1 didn't spring into existence. It's the third attempt, and each failure taught us something the successes couldn't.
Generation 1 was GPT-2 with LoRA adapters. 124 million parameters, token-based. We hit 98% recall on 22 concepts and celebrated. Then we realized the model was just really good at parroting. It produced correct-looking text by statistical prediction, not reasoning over concepts. The ceiling was pattern matching.
Generation 2 applied Domain-Driven Design to the LoRA adapters, organizing them into bounded contexts: physics, social, bridge, abstraction, chain, dialogue. Each circuit had its own training data, test batteries, and health monitoring. This validated that specialized circuits could be independently trained and evolved. The underlying problem still persisted: the base model was still a token predictor.
Generation 3 is OLT-1. We abandoned tokens entirely. The encoder reads characters and produces concept activations. Reasoning operates on concepts. The decoder generates language from concept probabilities. No tokenizer, no word embeddings. Characters straight to concepts.
That's the one that worked.
What "Concept-Based" Actually Means
Most language models process text as tokens. Each token gets an embedding, the transformer processes the embeddings, and outputs more tokens. The model never explicitly represents what it's talking about. Its "knowledge" is distributed opaquely across billions of parameters.
OLT-1 works differently. A character-level CNN with multi-scale filters (looking at 3, 5, 7, and 11 character windows) maps raw text into a 311-dimensional concept vector. This makes the encoder robust to novel vocabulary, typos, and morphological variation. It doesn't need to have seen a word before to detect the concepts within it.
Reasoning happens on concepts explicitly. A thalamus router sends concept activations to one of four brain regions:
- Physical Cortex: physics, causality, comparison, quantity
- Social Cortex: emotion (amygdala), conversation
- Logic Cortex: conditionals, sequences (reserved for future stages)
- Knowledge Cortex: science, AI self-knowledge (reserved for future stages)
Each region contains specialized micro-circuits, about 50K parameters each. A TwoStageReasoner infers properties then applies rules. A ComparisonCircuit determines relationships between concept sets. A QuantityCircuit handles counting and amounts.
The decoder takes concept probabilities and generates language character by character using a GRU. The entire path: characters in, concepts detected, reasoning applied, characters out. At every step, the system's "knowledge" is locally representable, traceable, and interpretable.
Growing Up, One Stage at a Time
OLT-1 learns through developmental stages modeled on child cognition. Each stage introduces a foundation before building on it:
- Stage 1-2: Pattern detection and vocabulary. Learning to hear language and name things.
- Stage 3: Physics reasoning. Understanding why things fall, float, sink, break.
- Stage 4: Dialogue. Talking back. Holding multi-turn conversations. Saying "I don't know" when appropriate.
- Stage 5: Self-knowledge. Knowing what it is, what it can't do, and expressing uncertainty.
- Stage 8: Regional brain architecture, comparison and classification, hippocampus memory, word grounding.
- Stage 9: Quantity and counting. Pre-arithmetic numerosity.
Each stage is additive. New concepts append to the vocabulary. New circuits slot into the appropriate region. No stage requires retraining earlier ones. You don't forget how to walk when you learn to run.
The Memory System That Actually Remembers
Here's the problem with most AI models: they store knowledge in weights. Every training session overwrites previous knowledge. That's catastrophic forgetting, and it's the reason most models can't learn continuously without being retrained on everything from scratch.
OLT-1 solves this with a hippocampus: a persistent, disk-backed memory system with four banks (encoder, reasoning, decoder, evolution). Each bank has three tiers: Hot (RAM, current session), Warm (SQLite, growing, pruned), and Cold (SQLite, permanent, dream-consolidated).
Currently holding: 19,948 decoder memories, 12,122 encoder memories, 346 reasoning memories, 2,826 grounded definitions. All growing with every session. All surviving restarts.
In a controlled experiment, we tested what happens when you train sequentially without mitigation: the model forgot 94% of physics. With spaced repetition, interleaving older examples during new training, retention jumped to 70%. The hippocampus makes this automatic. Knowledge enters as memory. Important patterns consolidate into weights over time. Old knowledge persists because it's stored, not because weights magically retain it.
Adding data no longer means retraining. Drop a text file into the data directory and it enters the hippocampus immediately. Available via retrieval. No weight changes. No forgetting.
Learning Words It Was Never Trained On
When OLT-1 encounters an unknown word, it queries Simple Wikipedia, extracts the definition, detects known concepts within it, and stores the mapping. Next time that word appears, OLT-1 "knows" it.
"Volcano" maps to [rock, ground, hot, liquid]. No retraining. No forgetting. 2,826 terms grounded so far, growing automatically during teacher sessions.
This is vocabulary expansion without catastrophic forgetting. In a field where every new capability traditionally means risking the loss of old ones, that matters.
What the Numbers Look Like Right Now
OLT-1 runs 311 concepts across 11 category groupings. It passes 44-47% of a 79-test suite. The encoder's concept match rate is 93-98%.
Those aren't benchmark numbers. OLT-1 hasn't been evaluated on GLUE, SuperGLUE, or HLE. Its responses are typically under 15 words. Complex multi-clause reasoning isn't reliable yet. The concept coverage is narrow.
But at 1.7 million parameters, it runs on consumer hardware. It doesn't require thousands of GPUs to train. If the architectural principles hold at larger scales, this represents a fundamentally more sustainable path for AI development.
What's Coming Next
Stages 10-15 will add conditional reasoning, sequences, arithmetic, code concepts, science, and language quality. Each stage follows the same pattern: new concepts, new circuits in the appropriate brain region, updated teacher, evolution cycles.
The bigger question is scale. Everything we've shown works at 1.7M parameters. We need to demonstrate that the principles hold at 170M or 1.7B. That requires compute we don't currently have.
In Part 2, we'll cover the part that surprised us: how OLT-1 learned to say no without being told to, and what that means for AI safety.
Origin is developed at Fallen Angel Systems with the Genesis framework (USPTO Application #64/016,973). FAS Guardian defends production AI systems from prompt injection in under 3ms. FAS Judgement is the open-source attack console that finds the gaps.
