DatologyAI, a startup that sells automated data curation for model training, had a busy week. Earlier in October it open-sourced Zephon, a data loader built to keep training data identical when the number of GPUs changes. On October 9 it launched Curation Studio, its commercial data-curation product. On October 14 it announced Datology Labs, an open research initiative. Each has a different audience, and each comes with company-reported numbers.
This article explains what each piece is, what the reported results say, and where the evidence stops. The theme will be familiar from our coverage of Coinbase's small fine-tuned model beating frontier models: better data and narrower training can beat brute-force scale, and the claims deserve careful reading.
TL;DR: the three launches
| Launch | Date | What it is | Cost / access |
|---|---|---|---|
| Zephon | Early Oct 2026 | Open-source data loader for text and multimodal training | Open source (Python package), Apache 2.0 per the repo README |
| Curation Studio | Oct 9, 2026 | Guided data-curation product that runs in your own cloud | Commercial; book a demo, no public price found |
| Datology Labs | Oct 14, 2026 | Open, collaborative research on the "science of data" | Research initiative; details thin at publication |
Zephon: the data loader as a hidden variable
DatologyAI's Zephon post starts from a practical problem. If you resume a training run on 8 GPUs after starting on 16, most data loaders quietly change what each GPU sees. The authors argue this turns the loader into a hidden variable in experiments: if two runs differ in data order as well as in the thing you are testing, you cannot tell which caused the difference.
They call the property you want elastic determinism: the same global batches regardless of GPU count. They credit Mosaic Streaming with coining the term, and say Mosaic Streaming and Grain provide it for indexable pipelines, where a sample index tells you what to train on at step N. Modern pipelines are often not indexable: they tokenize documents into several subsequences, pack them into stateful bins and reorder them to hit a mixture. The post says Megatron Energon supports online packing and reproducible scaling but needs a fixed total number of workers. Zephon aims to keep identical batches for those stateful pipelines while changing GPU count, operator parallelism and execution backend.
What the results show (company-run)
- GPU-count test. The team trained a 1B-parameter model for 20B tokens on 8, 16, 32 and 64 GPUs with a standard loader. FineWeb evaluation scores varied by up to 0.64 points and DCLM Core v1 scores by up to 0.82 points depending on GPU count. With Zephon, the spread was 0.011 and 0.05 points.
- Why that matters. The post says its reference thresholds for judging data-curation ablations are 0.15 points (FineWeb) and 0.2 points (DCLM), so the loader-induced spread is roughly four times the size of effects people use to pick filters. It adds that these thresholds come from published experiments and are not statistical significance tests.
- Honest wrinkle. On DCLM, the post says Zephon "got unlucky": its fixed data stream gave a worse model than the standard loader's streams. The authors state that this is chance, and that determinism does not trade off against quality; it only removes variance.
- Resume test. After a checkpoint at step 150 on 16 GPUs, resuming on 8, 32 and 64 GPUs with Zephon gave overlapping loss curves and matching SHA-256 hashes of every global batch.
- Throughput. On a vision-language pipeline using MAmmoTH-VL data, on a single AWS r8id.48xlarge instance, Zephon reached 16k samples per second for fetch-and-batch, against 5.8k for Grain; LitData and Streaming topped out near 2k. In a full VLM pipeline, Zephon and Grain were "effectively tied" at 32-way parallelism and both cleared the model's required rate of 16.9k usable tokens per second per GPU, by the company's measurement. The post says Zephon does this while providing elastic determinism for a stateful pipeline, which none of the baselines does.
How to try it
The post says Zephon is a Python package with a builder-style API. Its example defines a mixture over datasets, then chains tokenize, sequence packing, mixture enforcement and batching:
ws = StaticMixtureWorkSource(
[Dataset.from_path("demo", "s3://example-dataset")],
mixture=MixtureSpec({"demo": 1.0}), chunk_size=1024)
pipeline = (Pipeline(ws)
.tokenize(tokenizer_id="gpt2", parallelism=4)
.pack_sequences(target_length=2048)
.ensure_mixture()
.batch(microbatch_size=8))
for batch in pipeline:
train_step(batch.to_training())
Per the post, it separates the curriculum (which data, in what proportions) from processing, ships readers for Parquet, LitData, MDS, Vortex and JSONL, streams from S3, GCS and Azure, offers token-aware mixing and works with PyTorch or any framework that accepts iterables. We have not installed it. The repository README lists the Apache 2.0 license; check supported versions and open issues before adopting it in a long run.
Curation Studio: the commercial product
DatologyAI's Curation Studio announcement positions it as "frontier data curation" for any team training its own model. The workflow has four stages:
- Clean: fix ingestion issues, filter broken text and boilerplate, and decontaminate against the benchmarks you provide, including proprietary ones.
- Calibrate: score every document, drop redundant copies and reweight the corpus toward your target tasks, balanced with general data to avoid overfitting.
- Create: generate synthetic data by rephrasing real high-quality documents, an approach the company calls BeyondWeb.
- Compose: mix the resulting subsets into training sets tuned to a particular run.
It deploys in the customer's cloud account so data stays in the customer's environment, and the first release covers LLMs across web, math, code and multilingual data. The company names customers including Thomson Reuters, HRT, Deepgram and Arcee.
Claims to treat as claims
- Compute multiplier. The company says models trained on curated data matched the largest baseline's performance with 6x less training compute. A 30B-A3B curated model outscored its baseline 46.8 percent to 37.7 percent after post-training, and a 12B-A1.4B curated model beat the 30B-A3B baseline with a fifth of the pretraining compute. The baseline was a hand-built mix of 39 public datasets, which is a reasonably strong comparison, but it was designed and run by the vendor.
- Thomson Reuters. The post says a Qwen model mid- and post-trained on curated data, called Thomson-1, outperformed frontier models including GPT-5.6 Sol in blind comparisons on legal workflows, at 100x lower cost per task. That is the vendor's description of a customer result, and we did not find the underlying evaluation.
- Inference savings. The "100x or more" lower inference cost depends on swapping a frontier API for a small owned model, and varies by workload.
None of this is implausible, since data quality is a well-established lever. But a vendor benchmark of its own product with its own baseline should be read as a hypothesis. If you consider the product, ask for a head-to-head on your data and your evaluation, with your own decontamination.
Green sieve keeping one cream leaf while duplicate outlines peel away, illustrating data deduplication in curation
Datology Labs: what we know
DatologyAI announced Datology Labs on X on October 14: "a new commitment to open and collaborative research into the science of data," partnering with researchers at universities and across industry. Aggregated summaries said it is meant to bridge organizations that can afford to study data and researchers who want to share findings, and to tie data research to safety and model control. We found no program page, named partners, funding or release schedule at publication, so this is an announcement of intent. The company's blog already tags posts as "Labs", including a piece on automating data research and one titled "The Finetuner's Fallacy."
Why this matters
- Reproducibility. Data-ablation studies are common in open model work. If loader topology can shift scores by more than the effects being measured, some published comparisons may be noisier than they look. Zephon's argument is plausible, and easy to test: rerun your own ablation on two GPU counts.
- Agents running experiments. The Zephon post notes that more experiments are designed and run by agents, which will not notice when a result depends on GPU count. As labs automate research, hidden sources of variance matter more.
- Own your model. The company's pitch echoes a wider trend, covered in our posts on Nathan Lambert's Trillium Labs and the DOE Genesis open models with Arcee: more teams want models they can train and control, and data is the cheapest lever.
- Conflict of interest. An open-source loader and an open lab also act as marketing for a paid product. That does not make them less useful, but it explains the timing.
What this means if you train models
If you run pretraining or mid-training ablations, test your loader: train a small model on two GPU counts from the same checkpoint and compare batch hashes. If they differ, treat small score gaps with suspicion. For background on when custom training beats prompting, see our fine-tuning guide and our explainer on evals for engineers and PMs.
What we could not verify
We read the company's Zephon and Curation Studio posts and its X account. We did not run Zephon, review its code or the referenced paper, or reproduce any benchmark. The Thomson Reuters and Curation Studio results are the vendor's own, and the Labs initiative has few public details. We will update this post if independent tests or more Labs details appear.
Details reflect DatologyAI's public posts as of October 14, 2026.