Cartesia H-Net: Byte-Level Model Matches SmolLM3-3B With 10x Less Compute and Data, Claimed

Cartesia, best known for its voice models, has published a research series arguing that language models should learn from raw bytes instead of tokens. Two posts dated October 28, 2026, From Tokens to Bytes I and II, describe a newer generation of hierarchical networks, or H-Nets, that the company says "matches an open-source 3B Transformer with 10x less compute and data."

This post separates the 10x figure from the more modest numbers in the controlled experiments. Short version: the idea is credible and the authors are candid about limits, but the 10x comes from one internal model against one baseline, and the careful ladder shows gains of about 1.3x to 2x on text.

TL;DR: claim versus measurement

What is an H-Net, and why replace the tokenizer?

Language models do not read text directly. A tokenizer, usually Byte Pair Encoding, first merges frequent byte pairs into a fixed vocabulary (128k entries for Llama-3). On Cartesia's data mix each BPE token covers about 4.57 bytes. That step is hand-built and frozen before training, which Cartesia calls one of the last unlearned parts of the pipeline.

An H-Net moves that step inside the model. Per the post, five modules do the work: an encoder reads bytes, a learned chunking step compresses them, a main network works on the coarse chunks like tokens, the output is expanded back to byte resolution, and a decoder finishes. The main network can itself be an H-Net, so chunking nests: bytes into words, words into phrases. The original idea came from the July 2025 paper by Sukjun Hwang, Brandon Wang and Albert Gu, with code on GitHub under an MIT license.

Why does this matter to practitioners? Tokenizers cause real costs: non-English text needs more tokens, as we covered in the tokenizer tax analysis, and per-token prices hide those differences, as in why price per token misleads. A model that chunks adaptively could narrow those gaps.

The controlled result: 1-stage H-Net versus a BPE ladder

Cartesia built a scaling ladder of BPE Transformers (from 221M to 2.62B total parameters in the examples shown) trained on a mix of 70% English, 20% code, 5% math and 5% multilingual text, measured in bytes. It then converted each rung into a 1-stage byte-level H-Net, keeping the Transformer backbone and hyperparameters the same and matching the outer networks' parameters and FLOPs to the tokenization layers. A strong auxiliary loss held the compression at the BPE rate of 4.57 bytes.

Results, from fitted compute-optimal scaling laws:

• Validation bits-per-byte: 1.28x compute efficiency, meaning about 22% less compute for the same loss.
• Downstream suites: about 1.83x on Paloma and 2.06x on OLMES.
• Code: a median of 2.04x across 15 in-mix languages, rising to a median of 3.10x on ten languages outside the mix, including OCaml, Prolog, Lean and Fortran.

Cartesia also trained its own BPE tokenizer on the corpus for a fair baseline, which it says is worth about 1.1x over an off-the-shelf tokenizer. So against a standard tokenizer the H-Net advantage would be somewhat larger.

The 10x result: 2-stage H-Net versus SmolLM3-3B

The headline experiment pits a larger 2-stage H-Net against SmolLM3-3B, Hugging Face's 3B model with a documented recipe covering 11.1T training tokens. The H-Net has 3.67B parameters versus 3.08B, and FLOPs per byte are 4.44G versus 4.36G. Its main network sees about one position per 8 bytes, roughly 40% fewer than SmolLM3 on the same text, with byte-level stages built from Mamba-2 layers and sliding-window attention.

Per the post, the H-Net reaches SmolLM3's final average benchmark score, measured on six tasks from SmolLM3's published suites, after about 1T tokens versus about 11T. That is roughly 11x on data, and compute scales with it because the models are matched per byte.

Read this carefully:

• It is a single comparison against one baseline.
• The model is internal; Cartesia says it plans to release newer architectures "over time."
• Exact scores appear only in a figure, not in text.
• The authors describe their ladder matching to BPE as restrictive and favorable to the baseline, and say fair matching of data and compute is unresolved, since H-Nets compress code more and so spend less compute on it.

For perspective on similar claims, see our checks of Microsoft's MAI-Base-2 efficiency claim and Q Labs' 4000x claim: headline multipliers usually depend on a specific baseline and metric.

Part II: why bytes may "understand" data better

The second post asks why H-Nets help. It compares five setups: a byte Transformer, BPE without pretokenization, BPE with pretokenization, an H-Net and a BLT-like model, using two kinds of scaling law: compute-to-loss and loss-to-loss, which measures how pretraining loss transfers to downstream tasks.

Findings reported by Cartesia:

1. Compression buys efficiency. BPE without pretokenization is nearly 5x more compute-efficient than a byte model at reaching the same validation loss (about 6.03x compression), and BPE with pretokenization reaches about 7.2x.
2. Compression costs transfer. At equal validation loss, the byte model does better downstream. BPE with pretokenization lags the byte model by about 1.5x in compute terms on loss-to-loss, and BPE without pretokenization by over 1.9x.
3. H-Nets get both. They match the byte model's loss-to-loss transfer while keeping compression gains; versus BPE the loss-to-loss gap is 1.61x.
4. A hidden prior. Pretokenization regexes (GPT-2, cl100k, o200k, DeepSeek-V3) are hand-engineered, which cuts against the "bitter lesson" philosophy the authors invoke.
5. A known flaw. BPE without pretokenization suffers from the prompt boundary problem, where a prompt ends mid-token; the evaluation needed a correction to be sensible.

The authors argue that tokenization is about finding semantics, not only compression: BPE without pretokenization compresses about 32% more than BPE with it yet performs worse.

What H-Nets learn: in-context tokenization

The posts show behaviors absent from tokenized models. New words are first split into several chunks and then grouped into fewer as they repeat; repeated formats form very large chunks; and recurring motifs and digit blocks are picked out as units.

Beyond text: DNA and images

Cartesia previews two other domains. On prokaryote genomes (about 274B nucleotides) nucleotide-level H-Nets with 6x target compression show compute gains of 5.95x on validation and up to 7.06x on a test set, with chunks that align to codons. For vision, a 2D H-Net replaces the backbone of a pixel-space flow-matching baseline and learns chunks without supervision, but no numbers are given. Treat both as early signals. Our post on a pixel-space image model with no VAE shows the same appetite for dropping hand-built encoders.

What this means for builders

• Nothing to deploy yet. No new checkpoint is announced; the existing public code and checkpoints are from the 2025 version.
• Watch code and low-resource languages. Those are where the reported gains are largest, and where tokenizers hurt most.
• Expect inference trade-offs. Byte-level models process longer sequences; the design relies on compressing inside the model, and Cartesia reports the outer stages take about 43% of H-Net FLOPs versus 8% for embedding and head in the baseline.
• Compare with other byte-model work. See our fact check of byte-model distillation and Hugging Face Tokenizers v1 for the token-based status quo.

Cartesia's day job is voice: its Sonic-3.6 text-to-speech results are a separate line of work, and these posts come from its research team.

Open questions

• Will Cartesia release the newer 2-stage model or weights, and under what license?
• Do the gains hold at 30B+ parameters and with reinforcement learning post-training?
• How does serving cost compare once longer byte sequences and the outer-network FLOPs are counted?
• Can independent groups reproduce the 11T-to-1T result?

How to read a claim like this

Efficiency multipliers in pretraining research are only as good as the baseline and the metric behind them. Here, three choices shape the result: which tokenizer the baseline uses, whether compute is counted per byte or per token, and which benchmarks are averaged. A reader who wants to judge the 10x figure should check each of those three, then compare it with the smaller, better-controlled 1.28x and roughly 2x numbers from the scaling ladder. The gap between the headline and the ladder is not a contradiction, because the two experiments answer different questions, but only the ladder isolates the effect of learned chunking on its own.

We will add an update when code or weights appear.

Related reading

• The tokenizer tax: non-English languages pay more tokens
• Price per token is misleading
• Byte-model distillation fact check
• Hugging Face Tokenizers v1 release candidate
• Microsoft MAI-Base-2 efficiency claim
• NVIDIA ReplaySSM: caching SSM inputs
• Sources: Cartesia, From Tokens to Bytes I, II, H-Net paper

Accurate as of October 28, 2026, based on Cartesia's posts. Figures are the authors' own and unreplicated.