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 engine needs no framework, GPU, or hosted service. It loads a single .bin weight file and runs on an ordinary CPU.

carpathian.ai / veritate / forward pass
attention weightresidual streamlayer under inspection

Computing that does not need a datacenter

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.

No GPU
One binary, with no CUDA, no driver, and no runtime to install
CPU-native
Autoregressive decode at batch 1, which is the processor's home turf
Glass-box
Every forward pass readable end to end, with nothing behind a framework
Open
Engine, plugins, and training scripts published for anyone to audit

Glass-box interpretability

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.

No GPU required

One binary, with no CUDA, driver, or runtime to install. CPU-native autoregressive decode at batch 1 is the processor's home turf.

Byte-level vocabulary

A 256-symbol byte vocabulary means no tokenizer to train, no vocabulary mismatch between corpora, and no subword artifacts to reason around.

Auditable end to end

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.

A hand-coded inference engine

EngineHand-coded C
KernelsAVX-512 SIMD
QuantizationINT8 / INT4
RuntimeSingle binary
ComputeCPU, batch 1
Vocabulary256 bytes
veritate / decode path
drafted aheadverified and kept

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 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.

carpathian.ai / veritate / compute
unit active on this byteINT4 weights

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 as it runs, with nothing hidden behind a framework or a hosted service.

veritate / vocabulary
Vocabulary
256
Tokenizer
None
Weights
INT8
Runtime
1 binary

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.