Full trace on every forward pass
Per-layer residual stream, feed-forward neuron activations, attention scores, logit lens, and direct logit attribution. A browser-based MRI dashboard reads these live.
Carpathian's open research program for capable, inspectable AI that runs without a datacenter or a GPU floor. Veritate is the full pipeline: a quantization-aware training stack and a hand-coded INT8 byte-level inference engine, glass-box interpretable and published for anyone to read.
The engine needs no framework, GPU, or hosted service. It loads a single .bin weight file and runs on an ordinary CPU.
Carpathian builds efficient, US-based cloud and AI infrastructure on hardware we own and operate, and the research pushes toward lower-power infrastructure and inference that does more with less.
Veritate is our open research program. It shows that capable, inspectable AI does not need a datacenter or a GPU floor. Every model is glass-box interpretable, so you can read exactly what it does and audit how it reaches an answer.
What follows is the research log: the measured numbers and the experiments behind them, including the ones that did not work.
Per-layer residual stream, feed-forward neuron activations, attention scores, logit lens, and direct logit attribution. A browser-based MRI dashboard reads these live.
One binary, with no CUDA, driver, or runtime to install. CPU-native autoregressive decode at batch 1 is the processor's home turf.
A 256-symbol byte vocabulary means no tokenizer to train, no vocabulary mismatch between corpora, and no subword artifacts to reason around.
The engine is small enough to read in full, so interpretability is a property of the system rather than a dashboard bolted onto a black box.
Prompt a running Veritate box and read the residual stream, attention scores, and logit lens update on every byte. No sign-up, no GPU, nothing to install.
Veritate's size and speed work sits in a hand-coded byte-level inference engine built to run language models on commodity CPUs, with no GPU, no CUDA, and no external runtime. Quantization-aware training folds INT8 arithmetic into the model rather than bolting it on afterward, so the low-precision engine keeps nearly all of the full-precision model's quality. Sub-four-bit INT4 weight compression shrinks the memory footprint further, and ternary weight representation is an active research direction toward multiply-free decoding.
Efficiency compounds across the stack. Activation sparsity, trained into the network rather than pruned after the fact, lets the engine skip most of the feed-forward compute on every token. Speculative decoding drafts several bytes ahead and verifies them in a single pass, cutting decode latency without changing a single output byte. Together they make capable modeling practical on hardware people already own, which is the premise Veritate exists to prove.
Veritate is a tokenizer-free language model. Its 256-symbol byte vocabulary is the raw alphabet of every file, so there is no tokenizer to train, no vocabulary mismatch between corpora, and no subword artifacts to reason around. A byte-level model reads any language, any codebase, and any binary format as the same stream of bytes, which keeps the architecture simple and the behavior straightforward to audit.
Because the engine is hand-coded and small enough to read end to end, every forward pass is a glass-box. The residual stream, feed-forward neuron activations, attention scores, logit lens, and direct logit attribution are all readable as it runs, with nothing hidden behind a framework or a hosted service.
Each entry records what we measured, what it cost, and where it broke. Together they trace the path from a tokenizer-free byte model to compute that scales with the question rather than the parameter count.
What a 256-symbol byte vocabulary costs, and what the measured per-byte entropy and failure modes reveal.
Read the entryThroughput sweeps show the hardware is bandwidth-bound, and that data and the training objective are what move small-model quality.
Read the entryThe measured cliff below four bits per weight, and how quantization-aware training recovers nearly all quality at an effective 1.98 bits per weight.
Read the entryWhy it must be trained in, reaching about 88 percent zeros, composing with pruning to cut feed-forward compute to roughly 6 percent of dense.
Read the entryA 19x byte-exact KV-cache speedup and self-speculative drafting composing to a 2.25x theoretical speedup with unchanged output.
Read the entryBest-of-N self-grading and adaptive-depth compute savings that appear even at 85M.
Read the entryVeritate is developed by Carpathian and published on GitHub. The engine, plugins, and training scripts are all there, alongside the research log above. Read it, audit it, and see exactly how it works.