What it is
Hyperion is something I built: a small, fast, transparent system that learns the rules of a language or puzzle from a small handful of examples, then applies those rules to brand-new cases it has never seen before.
Think of it like watching someone solve three crossword puzzles, then being able to solve every crossword of that type forever after, without practicing thousands more, without a giant brain, and without forgetting.
It does this on four standardized academic benchmarks researchers use to measure whether an AI system can generalize compositionally, meaning it applies learned rules to new combinations instead of just memorizing patterns.
The results
Here are the actual numbers. They come from running code in the open-source repo against the official public datasets, and they're gated by automated tests. Clone the repo, run the tests, and if they pass on your machine, the numbers are real.
| Benchmark | What it measures | Hyperion | For comparison |
|---|---|---|---|
| SCAN | Novel combinations of simple commands | 100.00% | Transformer baselines: 1-50% depending on split |
| PCFG | Nested string-edit operations | 99.98% | Baselines: 50-80% |
| COGS | English-like sentences never seen before | 99.75% | Transformer baseline (Kim & Linzen 2020): ~35%. Best published neuro-symbolic methods: 60-80%. |
| 1D-ARC | Abstract grid puzzles | 100.00% | Joffe & Eliasmith (2025) with hand-crafted VSA: 83% |
The whole codebase is roughly 1,000 lines of Python. It runs on a laptop, trains in about 10 seconds, and needs no GPU, no gradient descent, no neural networks at all. Repo's here: github.com/NORTHTEKDevs/hyperion.
Why this might matter
I hold two framings on this at once.
The conservative read: Hyperion is a strong empirical baseline on four well-known compositional-generalization benchmarks. It beats published methods on at least one of them (1D-ARC, where the prior best was 83%) and is competitive with or above the best published methods on the others. It runs in seconds, and the code is auditable. On its own, that's a research-grade result.
The more ambitious read: it's evidence for a hypothesis I've been chasing, that the kind of reasoning large language models famously struggle with might not need giant neural networks at all. It might just need the problem represented the right structured way, plus systematic search over candidate rules. If that hypothesis holds up on harder problems (still an open question), it points toward a different kind of AI: small, transparent, energy-efficient, and provably correct on the cases it handles.
My honest read sits between those two. I have a real, reproducible result on a narrow set of problems, and a direction I think is worth pushing further.
What it isn't
I'd rather you trust this than be impressed by it, so here's what Hyperion cannot do:
- It's not a ChatGPT replacement. You can't have a conversation with it, and it can't summarize a PDF or write you a poem.
- It only works in domains with a learnable rule structure. Formal languages, structured puzzles, simplified grammars. Not real internet text, not arbitrary natural language.
- The COGS parser knows the schema of COGS. It hand-codes knowledge of determiners, prepositions, role labels. What it learns from data is the lexicon and the parameter values. So this isn't pure "discover the language from scratch." It's data-driven parameter induction over a structured hypothesis space.
- 1D-ARC is much easier than 2D-ARC. The full ARC-AGI benchmark is two-dimensional and dramatically harder. Extending this approach to 2D is open research, not a done deal.
- It won't scale to general natural language. The mechanism depends on surface regularity in the inputs, and real internet text isn't regular like that.
How it works (in plain English)
For each benchmark, Hyperion pulls the underlying rule out of a small set of training examples, then applies that rule to test inputs it's never seen. The mechanisms differ across benchmarks, but they all share the same pattern underneath: a structured hypothesis space, systematic search, and parameter induction from training data.
SCAN: Vector Symbolic Architecture
This one's built on bipolar 8,192-dimensional vectors that you can bind (multiply), bundle (sum), and permute (shift). Those operations let you store and retrieve role-filler pairs algebraically, with no learning required. The grammar's compositional structure gets encoded directly, and everything else falls out of the algebra.
COGS: Template induction plus a recursive-structure parser
This is a two-part system. First, a template induction algorithm scans the training pairs, identifies the input "shape" (positions of proper nouns, determiners, function words), and learns what each output position should be. Second, a recursive-structure fallback parser handles the cases the template learner can't: prepositional phrase recursion, clausal complements, control verbs, ditransitive constructions, passive voice variants. It learns its parameters, things like past-tense to infinitive mappings, intransitive subject roles, ditransitive verb sets, entirely from training data.
1D-ARC: Program synthesis
This one's a program-synthesis engine working over a library of generic grid transformations: shift, mirror, fill, recolor, scale, copy-pattern, and so on. For each task's three to five training examples, it enumerates programs and picks the first one that matches all of them exactly. Three parameter-induction modules (length to color, longest-run to color, parity to color) learn their parameters from training. Programs are ordered general-before-specific, so ties go to the simpler, more general program, an Occam's razor kind of preference.
Verified by adversarial audit
Before I published any of this, I audited the numbers end-to-end in attack mode: five distinct phases, each one trying to falsify the results. All five passed.
The single most important test: I shuffled the COGS ground-truth labels randomly, then re-evaluated. If the system were peeking at the labels somehow, accuracy would stay at 99%. It dropped to 0.005%, pure random chance. That's the cleanest signal I have that the system isn't cheating.
Full audit report and reproducible scripts are in the repo: AUDIT_REPORT.md, audit_independent.py, audit_perturb.py.
How to verify the numbers yourself
Don't take any AI claim on faith, mine included. Here's how to check it yourself.
1. Run the tests.
git clone https://github.com/NORTHTEKDevs/hyperion
cd hyperion
pip install -e .
python data/scan/download_and_prep.py
python data/cogs/download_and_prep.py
python data/pcfg/download_and_prep.py
python data/arc1d/download_and_prep.py
python -m pytest tests/ -vThe tests assert specific accuracy thresholds. If they pass on your machine, the numbers are real.
2. Print the raw numbers. A one-liner in the README runs all four evaluations end to end and prints the per-benchmark percentages. The evaluation functions are deterministic, so same data means same output, every time.
3. Audit the code. The whole research codebase is about 1,000 lines of Python, so you can just read it. There's no per-test hardcoding. The fit functions take training pairs only, and the evaluation functions compare predictions to ground truth. Grep the code yourself if you don't believe me.
What this is part of
Hyperion is the research arm of Northtek, my broader work on alternative AI architectures. The production stack that pays the bills, websites, automations, the realtor CRM, the agent runtime, uses standard tools where standard tools are the right answer. The research is where I get to ask: is there a smaller, more transparent way to do what large language models do, in the cases where their downsides actually matter?
Right now, for these four benchmarks, the answer is yes. Whether it generalizes to harder problems is an open question, and the obvious next step is the full ARC-AGI benchmark, the 2D version of 1D-ARC. That's the direction I'm headed.
The code is MIT-licensed. Fork it, use it, build on it, cite it. Issues and pull requests welcome.
See the code
The full repo is on GitHub. Clone it, run the tests, audit the work.
github.com/NORTHTEKDevs/hyperion →
Built by Kristian Baer / Northtek. Research code, MIT license. Citation in CITATION.cff.