An autocomplete tool gets one chance to suggest working code. A system that can test 16 candidates has more room for error. In research published in Nature on October 7, the converted models scored lower on first-attempt coding accuracy than their source models, while doing better when allowed multiple attempts.
The Allen Institute for AI has released byte-level conversions of Qwen3 8B and Llama 3 8B, extending a method previously used for its own Olmo models. Called byteification, it changes how a trained model receives and produces text without repeating its entire original training run. For developers, the immediate question is how those inherited capabilities survive the change in representation.
What the October release adds
Ai2 introduced the Bolmo family in December 2025. Its October announcement adds Bwen 8B, derived from Qwen3 8B, and Blama 8B, derived from Llama 3 8B. The institute says both come close to their source models, with Bwen outperforming Bolmo 7B across its aggregate evaluation suite. It also releases checkpoints from the first conversion stage, intended to give researchers an earlier starting point for architecture experiments. Those are the new artifacts accompanying the Nature publication.
The Bwen model card identifies its starting point as Qwen3 8B Base and labels the resulting model English. This matters when choosing a baseline: a comparison with an instruction-tuned chat model would answer a different question from a comparison with the base checkpoint that was actually converted. Ai2 lists Bwen under Apache 2.0 and describes its intended use as research and education.
The Llama-derived release has a different license. Its model card specifies the Llama 3 Community License Agreement. The paper calls it Blama, while the card's heading says Llama-B and the repository address contains Blama. Anyone evaluating these downloads should record the exact artifact address and license alongside the model name. A shared conversion method doesn't give every resulting checkpoint identical distribution terms.
Bytes enter, compressed patches do the heavy work
Most language models receive text split into pieces drawn from a fixed vocabulary. A piece might be a whole word or part of one. Ai2's original Bolmo explanation describes why that representation can make spelling and unusual strings awkward: the model works with chunks that don't expose individual characters in the same way raw text does. Moving to UTF-8 bytes changes the input units, but processing every byte through a large transformer would also increase the amount of work.
Bolmo therefore groups bytes into variable-length patches. A small local encoder builds byte representations, a boundary predictor decides where to divide them, and pooled patches pass through the inherited transformer. A local decoder then returns to byte-level output. As Ai2 describes the architecture, the expensive central model operates on the shorter patch sequence. The byte-level components handle the finer detail around it.
This division helps explain what a developer is downloading. In the Bolmo 7B model card, Ai2 describes an autoregressive model retrofitted from Olmo 3 7B. Its inference example still uses Hugging Face's familiar model and tokenizer interfaces, with custom code enabled. The unchanged interface names can hide a changed unit of work. The card explicitly says max_new_tokens specifies how many bytes to generate.
The coding result depends on how many answers you can test
The Nature paper reports higher coding pass@16 alongside lower pass@1 for the byteified models. Pass@1 measures success with one sampled answer; pass@16 measures success when a correct answer can be found among 16. The authors suggest the converted models produced more varied continuations, but caution that sampling settings or inference engines could explain the difference. They stop short of establishing an inherent diversity advantage.
For deployment, that finding suggests separate tests for autocomplete and repeated generation with automated checking. The authors' sampling caveat means matching temperature values alone cannot establish a fair comparison across architectures. Report first-attempt accuracy separately, with the number of permitted attempts and the checking procedure.
A smaller training bill still means billions of tokens
The training repository documents two stages. First, the global transformer stays frozen while new local components learn to imitate its behavior, using 9.8 billion tokens, approximately 43 billion bytes. The second stage trains the whole model for another 39.3 billion tokens, approximately 173 billion bytes. That is a substantial training workload even though the researchers describe conversion as using less than 1% of a pretraining budget.
Ai2 has made the intermediate state inspectable. The Bolmo 7B Stage 1 card says its inner model parameters remain unchanged. For someone studying conversion, this gives a useful comparison: begin with an inherited transformer whose parameters are preserved, then compare it with the fully adapted version. Researchers can examine the work of learning a byte interface separately from the later changes inside the model.
The public training-data card lists a 172.7-billion-token mixture containing web text and scientific PDFs, alongside code and mathematics. Character-understanding material accounts for 75.5 million tokens. The card says Bolmo trains for less than one epoch on this mixture, about 39.3 billion tokens. The mixture's total size and the number of tokens consumed during the second stage are different quantities; reporting the former as the conversion budget would misstate the run.
Familiar loading code needs different measurements
The Bwen inference example uses AutoModelForCausalLM and AutoTokenizer, with trust_remote_code=True, to generate from the converted Qwen checkpoint. Ai2 reports testing with Transformers 4.57.3 and Python 3.11, and requires the xLSTM package. Those version numbers and dependencies give anyone reproducing the example a specific starting configuration. The example's 256-unit generation limit is a byte limit.
A developer comparing that output with subword generation should therefore compare completed text and elapsed time, with limits that allow comparable answers. Reusing the same numerical output cap can truncate one system at a different point. This follows from the model card's byte-counting behavior. It is a practical evaluation adjustment, especially when a coding answer must fit an entire function before tests can run.
Likelihood evaluation has another complication. The repository's evaluation instructions say the probabilities for byte outputs with and without a following patch boundary must be combined. Ai2 supplies an OLMES fork that implements this handling. Anyone reproducing the benchmarks should use that documented procedure before interpreting a score difference as a model-quality difference.
Compression leaves a question for character tasks
Separate research puts the patching decision under scrutiny. In an August 31 preprint, Lukas Edman and Alexander Fraser tested hierarchical byte models against models that kept computation at the byte level. Their experiments used roughly 100-million- and 400-million-parameter models. Pure byte processing performed better on character manipulation, while hierarchical designs gained speed. These smaller, newly trained models provide architectural evidence, rather than a direct ranking of Ai2's new 8B checkpoints.
The same study found that byte-level attention mattered more to character understanding than keeping feed-forward computation at that level. For developers considering conversion, this suggests testing the exact string operations their application needs even when the model accepts bytes. Input granularity and the amount of computation devoted to each byte are separate decisions. A byte interface doesn't guarantee perfect manipulation of the text behind it.
The next useful evidence will be independent tests of Bwen and Blama on complete coding workloads, with output budgets measured consistently and first-attempt results kept separate from repeated attempts. Ai2's released intermediate checkpoint makes the conversion process easier to examine. Independent runs should show how often the extra attempts produce working code, and how much time they cost before a developer gets a usable answer.