RCK: An AI That Isn't a Language Model, and Shows Its Work

What I actually built

RCK stands for Resonant Cognitive Kernel. I built it specifically to not be a language model. A large language model is one enormous neural network trained on a huge pile of text and then run as a black box, you feed it a prompt and hope. RCK does something different. It stores what it knows as individual facts, a subject, a relation, and an object, things like (dog, isa, mammal), and it reasons over those facts through a process you can actually watch happen from the outside.

That has real, practical consequences. Ask it something and it can show you exactly why it believes the answer, a trail of provenance back to the facts it was told. If it doesn't know, it says so instead of guessing. And if a fact turns out to be wrong, I can edit or delete it directly, no retraining required. Teaching it something new costs the same no matter how much it already knows: fact number 100,001 is exactly as cheap to add as fact number two.

It runs on hardware anyone already has. No GPU, no training run, just Python and numpy on a single CPU thread. That combination, reasoning you can inspect plus operating cost that's basically nothing, is the whole idea: an AI that shows its work and is cheap to keep running.

I designed and built RCK working closely with Anthropic's Claude. The architecture decisions are mine; a lot of the implementation and drafting was AI assisted, and I say that plainly because I think it should be said plainly. Every empirical claim in the project's paper is reproducible straight from the repo, each number traces back to a script and a JSON output sitting right there in the code, and I mean it when I say the work welcomes scrutiny and correction.

The results

These numbers come from the project's own benchmark scripts and its 757-test suite, gated by CI on every commit, not from anything I wrote for a pitch. The repo ships the exact scripts that produced them, so if you don't take my word for it, clone it and run the same tests yourself.

Query time doesn't grow with how much RCK knows, because retrieval stays local to a shard: 100,000 facts answer just as fast as 700 do. That 100,000-fact run is the largest configuration I've publicly benchmarked. Scaling into the millions should follow the same shard math, but I haven't verified it, so I won't claim it.

On the smaller demo knowledge base that ships with the repo, 716 facts, chain discovery across the fact graph takes about 21 milliseconds, and multi-hop reasoning holds up at real depth. The strict best-answer walk stays correct past 50 hops, and a newer, more conservative scoring rule (v15.2) reports calibrated probabilities that decay honestly the longer a chain gets, instead of staying falsely confident the whole way: a clean 50-hop chain scores about 0.98. A per-shard index that tracks live relations cuts 31 to 66 percent of query work, a 1.4 to 2.8x speedup.

RCK can also turn a confident reasoning chain into a brand new permanent fact, something I call fact induction, gated behind a six-step filter so it doesn't run wild. In a 400-probe validation study, 31 out of 31 manually checked inductions came back correct. Here's something I want to flag myself rather than let you find it: an earlier version of this project claimed roughly 87 percent induction precision, and I've since retracted that number in the paper. It turned out that figure measured whether the underlying vector math round-tripped cleanly, not whether the induced facts were actually true. Those are two different things, and conflating them was a mistake on my part. I'd rather document the correction in the open than quietly drop the old number and hope nobody noticed.

Elsewhere in the test suite: analogical reasoning (A is to B as C is to what) hits 93.9 percent accuracy on a commonsense benchmark, and the score calibration work turns raw similarity scores into honest probabilities, taking a held-out Brier score from 0.568 uncalibrated down to 0.0038 calibrated. The whole system is about 18,800 lines of plain Python across 126 modules, and all of it is covered by 757 passing tests that gate every change I make.

Why this might actually matter

There are two ways to read this project, and I hold both at once.

The modest read: RCK is a well tested, well documented knowledge reasoning engine. It has a real test suite, honestly calibrated confidence scores, and a track record of correcting its own earlier claims in public instead of letting them stand uncorrected. If you need to know why a system produced an answer, or you need to fix a wrong fact without retraining an entire model, that alone is useful, and it's not nothing.

The bigger read: I think RCK is a real alternative to language models for work that needs explicit, auditable reasoning instead of fluent text. The README puts the operating cost gap versus LLMs at four to five orders of magnitude in RCK's favor, because there's no training run and no GPU inference bill to pay. Whether that tradeoff, less fluent language in exchange for reasoning you can fully inspect, is worth it for your use case is an open question. I'm not going to pretend I can resolve that for you here.

The honest version sits between the two: a real, reproducible, narrow-domain reasoning engine today, and a genuine argument for why explicit reasoning over a black box is worth pushing further.

What it isn't

Trust matters more to me than hype, so here's what I'll tell you straight, and it's the same thing the project's own documentation says RCK cannot do:

• It is not a chatbot. The optional surface-form polisher is a small transformer trained on a synthetic paraphrase corpus. RCK answers in grammatical but slightly stilted sentences, not natural conversation.
• It doesn't ingest the open internet out of the box. The bundled fact extractor is rule based Open IE. If you want to feed it something like Wikipedia, you need to plug in a stronger extractor first. RCK only knows what it's told.
• It has a capacity cliff. Each shard holds roughly 80 facts before quality starts to degrade, at the default 4096-dimensional vector size. Auto-shard sizing manages this, but it needs the expected fact count up front, or a diagnostic check afterward.
• It is not for narrative or creative writing. In the project's own words: stories are hard. RCK is built for structured knowledge, not prose, and I'm not pretending otherwise.
• The operating cost advantage is not the same as knowing more. That four to five order of magnitude cost gap versus LLMs applies to a system starting from zero facts that has to be taught everything. It's not a claim that RCK already knows what a large language model knows.

How it works, in plain English

Every concept and every relationship gets a large numeric fingerprint, what's called a high dimensional vector, 4096 numbers by default, each one either +1 or -1. A fact like (dog, isa, mammal) gets stored by combining those fingerprints with a specific kind of multiplication that binds the role to the value, then adding the result into a shared memory tensor along with every other fact. I call that step bundling.

To answer a question, RCK runs that whole process backward. It multiplies the memory by the parts of the fact it already knows, then looks up the closest match in a codebook of known fingerprints, a method I call bind-then-cleanup. Facts get spread across many shards, chosen by hashing the subject and relation together, so no single shard gets overloaded as the knowledge base grows.

On top of that math sit the higher-level pieces I described above: a chain walker for multi-hop reasoning, a rule store, a provenance graph, a query memory, all wired together by one agent object that a program actually calls.

Where to go deeper

If you'd rather check this yourself than take my word for it, here's where to look:

• The repo itself: github.com/NORTHTEKDevs/rck. Apache-2.0, clone it, read the code, run the tests.
• The CI history: every commit's test run, so you can watch the 757 tests actually pass over time instead of trusting me on it.
• The architecture paper lives in the repo's papers/rck-architecture/ folder, with every number in it traceable to a script and a JSON output, including the retracted induction-precision figure I mentioned above.
• The scale benchmarks run on ConceptNet, a well known commonsense knowledge graph; the script that produced those numbers is in the repo's scripts/ folder.
• If you want the math background, this builds on decades of prior work: hyperdimensional computing (Pentti Kanerva), holographic reduced representations (Tony Plate), and non-axiomatic reasoning systems (Pei Wang). Symbolic AI research that kept going after language models ate the field's attention.

See the code

The repository is public and Apache-2.0 licensed. Clone it, read it, run the test suite yourself:

git clone https://github.com/NORTHTEKDevs/rck
cd rck
pip install -e ".[dev]"
pytest -q

The base install skips the optional MCP server and PyTorch polisher tests cleanly. Install .[dev,mcp,polisher] if you want the full 757-test suite. One heads up: the package isn't on PyPI under the name rck yet, that name belongs to an unrelated bioinformatics project, so for now you install straight from GitHub.

Current release is v15.3.1. I consider this active research with a stable API, and pull requests are welcome, see the repo's CONTRIBUTING.md.

I'm Kristian Baer, building as Northtek. Research code, Apache-2.0 licensed. Citation details are in CITATION.cff.