Open Model & Research
A small open model that rewrites AI-styled text into more natural human prose, built from public-domain books and published with everything needed to study or reproduce it: dataset, code, evaluation and a step-by-step write-up.
The GoHumanize Open Humanizer is a public research and educational model created to demonstrate the general approach used to develop AI text humanization systems. It is separate from the production models used by GoHumanize.ai, but it reflects many of the same high-level principles we follow when developing our technology, including careful dataset preparation, transformation of source text into training pairs, model fine-tuning, evaluation, and iterative improvement.
By publishing the model, dataset, code, methodology, and development process, we aim to provide developers and researchers with a practical example of how a humanization model can be built and studied. The open model is not intended to reproduce the exact architecture, datasets, training configuration, or performance of GoHumanize.ai's production systems.
The Open Humanizer makes no claim about passing AI detectors. Its purpose is to show how such a tool is developed so that others can learn from and build on the work.
Qwen3-4B fine-tune on Hugging Face (Apache-2.0), with the LoRA adapter and a GGUF build for Ollama and LM Studio.
2,000 training and 200 test pairs of AI-styled text and its human original, from 47 public-domain books (CC-BY 4.0).
The complete pipeline on GitHub: sourcing, cleaning, AI-fication, training, evaluation and serving.
A paper-style explanation of every step, every service used and why, with results and limitations.
pip install gohumanize-open-humanizer: a small client and command-line tool.
A permanent, citable snapshot of the code, paper and dataset on Zenodo: doi.org/10.5281/zenodo.22843083.
Paste AI-styled English text (up to 400 words) and see the open model's rewrite. The endpoint sleeps when idle, so the first request can take two to three minutes.
50 / 400 words
Passages of 80 to 300 words from 47 English-language books on Project Gutenberg, all published before 1929. Translations were excluded so no newer copyright is involved. Boilerplate and typographic artefacts were stripped.
Each human passage was rewritten in the register typical of large language models (formal, smooth, hedged, connective phrases) by three different generators and four rotating style prompts. The human original stays the target.
Qwen3-4B was trained with QLoRA (a 4-bit base model and a small rank-16 adapter) on the 2,000 pairs, with the loss applied only to the human target. Training took about 22 minutes on a single rented GPU and cost about one dollar. A full fine-tune of all four billion weights, run for comparison, gave the same quality.
The fine-tuned model is compared with the untouched base model on 200 held-out pairs: how much meaning survives (BERTScore, ROUGE-L, name recall) and how the style moves towards the human target (contractions, transition words, stock phrases, sentence length).
Weights, dataset and demo on Hugging Face, code on GitHub, an archived copy with a DOI on Zenodo, an MCP server on npm and a client on PyPI, so every piece can be reused independently.
The choices a developer new to fine-tuning will ask about, in short. The write-up explains each one in detail, with the numbers.
OpenAI's fine-tuning keeps the trained model on OpenAI's servers: it could not be published, downloaded, inspected or run locally, and every use would be billed per token. An open release needs open weights, so we fine-tuned an open model. OpenAI's models were still used to produce training data.
A humanizer needs fluent English and a sense of style, not world knowledge: everything it needs is in the input text. A 4B model trains in about 22 minutes for about a dollar on one 24 GB GPU, and its 2.5 GB build runs on a laptop. A 32B model would need an 80 GB GPU, hours per attempt and far more to serve.
Among open models of this size it combines a plain Apache-2.0 licence (so the fine-tune can be Apache-2.0 too), strong quality for its size, first-class support in Unsloth, vLLM and llama.cpp, and a "thinking" mode that can be switched off for fast rewrites.
Each human passage was sent to a language model with the instruction to rewrite it like typical LLM output while keeping every fact, name and the order of ideas, in one of four styles (formal, explanatory, hedged, corporate). Rewrites that changed the length too much or came back as lists were rejected and redone. Three generators from three labs were mixed so the model learns LLM style in general, not one model's habits.
Training loss and held-out loss (3.17 before training, 1.39 after, flat through the second epoch, so no overfitting), the size of each update, the learning-rate schedule, and GPU use (93% busy, 8.6 GB of 24 GB). Every run is public, so each number can be checked.
We trained both. Updating all four billion weights on an 80 GB GPU gave the same scores as the small QLoRA adapter on a 24 GB GPU, so the published model uses QLoRA: same quality, a fraction of the hardware.
Each step relies on an off-the-shelf service. The write-up explains each in more depth; in short:
Free public-domain books; the only source of human text in the dataset.
Three different language models produce the AI-styled side of each pair, so the model does not learn the quirks of one provider.
On-demand GPUs for training and for serving the demo endpoint; it scales to zero when idle.
Records every training run (loss curves, settings) so results are traceable.
Hosts the model weights, the dataset and the browser demo.
Archives a release snapshot with a permanent DOI for citation.
If you use the model or the dataset, please cite:
GoHumanize team (2026). GoHumanize Open Humanizer: an open text-humanization model, dataset and pipeline built from public-domain data. Version 0.1.0. Zenodo. https://doi.org/10.5281/zenodo.22843083
Model and code: Apache-2.0. Dataset: CC-BY 4.0.