Veritate
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 hand-coded engine needs no framework, GPU, or hosted service: it loads a single .bin weight file and runs on an ordinary CPU.
Computing that doesn't need a datacenter.
Carpathian builds efficient, US-based cloud and AI infrastructure on hardware we own and operate. Our 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. The page below is the research log: the measured numbers and the experiments behind them.
The research log.
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, not the parameter count.
Byte-Level Language Modeling Without a Tokenizer
What a 256-symbol byte vocabulary costs, and what the measured per-byte entropy and failure modes reveal.
Read the entryData Quality Over Framework Speed
Throughput sweeps show the hardware is bandwidth-bound, and that data and the training objective are what move small-model quality.
Read the entryTrained-In, Not Bolted-On
The 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 entryActivation Sparsity
Why 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 entryLossless Decode Acceleration
A 19x byte-exact KV-cache speedup and self-speculative drafting composing to a 2.25x theoretical speedup with unchanged output.
Read the entryTrading Parameters for Thinking Time
Best-of-N self-grading and adaptive-depth compute savings that appear even at 85M.
Read the entryGlass-box interpretability.
Full trace on every forward pass
Per-layer residual stream, FFN neuron activations, attention scores, logit lens, and direct logit attribution. A browser-based MRI dashboard reads these in real time.
No GPU required
One binary. No CUDA, no driver, no runtime. CPU-native autoregressive decode at batch=1 is the CPU's home turf.
Byte-level vocabulary
256-character byte-level vocab. No tokenizer, no vocabulary mismatch, no subword artifacts. Trains on raw bytes of any corpus.
A hand-coded inference engine.
Engine
Hand-coded C
Kernels
AVX-512 SIMD
Quantization
INT8 / INT4
Runtime
Single binary
Compute
CPU, batch 1
Vocabulary
256 bytes
Veritate is a hand-written C inference engine: custom AVX-512 SIMD kernels, with INT8 and INT4 quantization built into the decode path, and no CUDA, driver, or runtime to install. It ships as a single binary and decodes byte by byte on commodity CPUs, which is where batch-1 autoregressive inference is at home.
Watch the model reason, right in your browser.
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.
Efficient inference on commodity CPUs.
Veritate's size and speed work sits in a hand-coded byte-level inference engine built to run large 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.
A byte-level model you can read.
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 in real time, with nothing hidden behind a framework or a hosted service. Interpretable AI here is not a dashboard bolted onto a black box; it is a property of an engine small enough and open enough to inspect end to end.
Read the code.
Veritate 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.