Skip to content
ReviewRamble

The weekly brief

AI, reviewed, in your inbox.

  • New reviews of tools, models, MCP servers and repos, with the verdict up front
  • Re-checked prices and ratings when something changes
  • New analysis pieces as they are published

Models, agents, MCP servers and the tools actually worth your time.

One email a week. Unsubscribe with the link in any brief. How we use your email

Analysis Open Source Gems

Uncensored open models in 2026: abliterated, retrained or steerable, and what each costs

By ReviewRamble editors ·

An open model that never refuses is not more capable than the one it came from. It has lost one learned reflex, and with it the only safety check that ships inside the weights. Three ways of getting there are in wide use in 2026: editing the weights to cut out refusals, retraining on data with refusals removed, and training a model to follow whatever policy its system prompt sets. They cost different amounts, break different things, and leave you with the same job: deciding where the checks now live.

This guide is for people choosing a model to run, not for people modifying one. Every figure below comes from a paper, a model card or a research write-up, linked where it appears; we have not run these models ourselves. If you have already chosen a model and need the filter that replaces its refusals, our guide to guardrails for AI apps and agents covers that part.

Why people want models that do not refuse

Mainstream chat models are trained to decline whole categories of request, and the training is blunt. A model that refuses to explain how a phishing email works usually could explain it; the refusal is behaviour, not a missing skill. That bluntness lands on legitimate work: security teams analysing exploit code, novelists writing violence, clinicians and educators discussing overdoses, researchers studying alignment itself, and anyone running a local role-play model such as Cydonia 24B or Rocinante X 12B, both of which are uncensored by design.

Screenshot of the Cydonia 24B v4.3 website
Cydonia 24B v4.3, official site

Demand is not marginal. A peer-reviewed study in Future Internet in October 2025 tracked 8,608 modified model repositories and found that, on its unsafe prompts, unmodified models complied 19.2% of the time and modified ones 80.0%. More than half of those models were GGUF files, the format people use to run models locally. ThreatDown counted 6,644 distinct models on Hugging Face advertised as abliterated, uncensored, decensored, heretic or unfiltered, downloaded more than 22 million times in the 30 days to 4 July 2026. Those labels are the publishers' own; ThreatDown did not test what the models actually do.

Three ways to remove refusals

Abliteration: edit the weights

In 2024, Arditi and colleagues showed that refusal in 13 open chat models, up to 72B parameters, runs along a single direction inside the model. Remove that direction and the model stops refusing harmful requests; add it and the model refuses harmless ones. Abliteration bakes that removal into the weights. It needs no retraining, which is why it took off: Maxime Labonne's 2024 walkthrough made it a recipe, and the open-source tool Heretic, released in November 2025, automated the search for settings. Its README says a 4B model takes 30 to 40 minutes on an RTX 3090, and that the community has published thousands of models made with it.

Big models cost more, but not much. Anthropic's Frontier Red Team reported that abliterating GLM-5.3, a 753B-parameter open model, took its inexperienced team about 2,200 GPU hours, roughly $4,400, and estimated an experienced team would need about 600 hours ($1,200). Developers released abliterated copies of GLM-5.3 within days of its launch. Bear in mind that this is one lab's analysis of a rival's model.

Screenshot of the GLM-5.3 website
GLM-5.3, official site

Refusal-free fine-tunes: retrain the behaviour

The older route is to fine-tune on data with refusals and moralising filtered out. Eric Hartford's Dolphin series is the best known. Dolphin 3.0 R1 Mistral 24B was trained for three epochs on 800,000 reasoning traces, and its card tells you to set the system prompt yourself to define the tone and guidelines. The blunt warning often attributed to Dolphin 3 comes from the Dolphin 2.9 card: the model "will be highly compliant with any requests, even unethical ones", and you should implement your own alignment layer before exposing it as a service. That advice holds for every model in this guide. Fine-tuning takes longer than an edit, but the behaviour is trained in rather than cut out.

Steerable models: the policy lives in the prompt

Nous Research's Hermes 4 takes a third line. It is trained to follow whatever policy the system prompt sets, so it can refuse according to your rules rather than the lab's. The family runs from a 14B model on Qwen3 (Apache 2.0) through 70B and 405B models on Llama 3.1 (Llama licence) to Hermes 4.3 36B on ByteDance's Seed-OSS (Apache 2.0). The Hermes 4 technical report scores it on RefusalBench, Nous's own set of 166 prompts that frontier models tend to refuse, judged by Claude Sonnet 4. Three categories score in reverse, so refusing them counts as correct. Nous's card for Hermes 4.3 36B says it answers 74.6% of the set, against 51.3% for Grok 4. The benchmark is the vendor's own, so treat the figures as direction, not proof.

The trade-off is that your policy is only as strong as the instructions you write, and long conversations push those instructions further from the end of the context.

What it costs the model

Each method damages something, and the damage is measurable. The cleanest comparison is the table Heretic published for Gemma 3 12B in an earlier version of its README. It counts refusals on 100 harmful prompts and, on harmless ones, the KL divergence: how far the edited model's answers drift from the original's, where lower is better.

Gemma 3 12B buildRefusals out of 100Drift on harmless prompts (KL)
Original970
Labonne abliteration v231.04
huihui-ai abliteration30.45
Heretic30.16

All three remove refusals equally well; they differ sixfold in collateral change. Labonne's own walkthrough found that his abliterated model scored lower on every benchmark until a further round of DPO training recovered most of the loss, though not on GSM8K maths. Anthropic found abliterated GLM-5.3 matched the original on GPQA-Diamond but scored a few percent lower on CyberGym. The pattern: knowledge mostly survives, and how the model uses it shifts in ways a single headline score can hide.

For any build you are considering, check two things on the card. First, whether its benchmark figures were measured on the edited weights or copied from the base model's card. Second, whether it publishes refusal counts and drift at all. If it does not, you will have to measure them yourself (see the checks at the end).

Tool calling and the supply chain

Removing refusals does nothing for structured output. An abliterated model keeps the base model's tool-calling ability at best, and the serving template can still break it: Ollama's Dolphin 3 package advertised function calling, but its template did not support tools, and the issue was closed in October 2026 without a fix. Test the exact build, quantisation and template you will serve, not the base model's reputation.

The larger risk is what else an edited model carries. ProjectDiscovery showed how cheaply a backdoor fits into open weights. They fine-tuned Qwen2.5-7B-Instruct on 500 clean examples and 125 poisoned ones, using one 24 GB GPU for under $50. The model behaved normally in every clean test and, on a hidden trigger, sent a tool call that posted the developer's .env files to an outside server. Their demo was a fine-tune rather than an abliteration, and they say plainly why abliterated models are the obvious carrier: people download them precisely to run without checks, and one abliterated Qwen3 build passed two million downloads in a month.

So treat a modified model as untrusted code, the same supply-chain risk as an unknown package. Prefer publishers who document what they changed. Pin the exact revision you tested. And never give an uninspected model a shell, credentials or open network access: run its tools in a sandbox, split network access from command execution, and log what crosses either boundary. Our guide to securing coding agents and our piece on who approves agent actions cover those controls.

Where refusals come back

Removing refusals is not permanent or complete.

  • Quantisation changes the file you tested. Rounding weights to 4 bits (quantisation) also rounds the edited ones, so a refusal count published for the full-precision build may not hold for the GGUF you download. Measure the file you will actually run.
  • Short probes prove little. Twenty quick prompts say nothing about behaviour deep into a long agent session, where hedging can return and a steerable model's policy sits thousands of tokens back. Test at the length you will run.
  • Merges and further fine-tunes change it again. A build made by stacking someone else's edit on someone else's fine-tune inherits behaviour nobody measured as a whole.

Model makers are also pushing back. A 2025 paper trained models to explain at length before refusing, which spreads the refusal across many tokens; abliteration then cut refusals by at most 10%, against 70 to 80% for ordinary models, though only small models were tested. EleutherAI's Deep Ignorance work goes further back: filtering biothreat material out of pretraining produced 6.9B models that resisted fine-tuning attacks of up to 300 million tokens. A model that never learned something cannot be edited into knowing it, but it can still use the same information if you hand it over in the prompt, so the authors argue for defence in depth.

The practical point for buyers: an abliterated model can only do what its base already could. Read the base model's card for what was filtered from its training data, just as you would read its benchmark caveats.

A shortlist by GPU memory

Memory needs are the weights plus the KV cache for your context, plus a gigabyte or two of runtime overhead. Figures are for 4-bit builds, taken from our reviews and the model cards; check the exact file before you buy hardware. Our GPU calculator adds context length for you.

GPU memoryBase or buildRouteNotes
8 GBDolphin 3 8BFine-tune4.9 GB in Ollama, 128K context; its Ollama template has no tool support
16 GBRocinante X 12BFine-tuneRole-play and fiction; fits well under 16 GB at 4-bit
16 to 24 GBGemma 4 26B A4BAbliteration (community builds)Base is 14.4 GB at 4-bit, fits a 24 GB card, Apache 2.0; abliterated and Heretic GGUFs of Gemma 4 are among the most downloaded on Hugging Face
24 GBQwen 3.8 27BAbliteration (huihui-ai build)Base is 16.5 GB at 4-bit; the abliterated build is Apache 2.0, edits layers 18 to 51, and its maker calls it a proof of concept not for production
24 GBCydonia 24B or Dolphin 3.0 R1 Mistral 24BFine-tuneCydonia runs Q5 to Q6 on 24 GB, Q4 on 16 GB; the Dolphin R1 Ollama build is 13 GB and its card declares no licence
24 GBHermes 4.3 36BSteerableNous's own Q4_K_M GGUF is 21.8 GB, Q3_K_M 17.6 GB; Apache 2.0; the choice when you want the model to refuse by your written rules
Data centreGLM-5.3Abliteration (community builds)About 753 GB of FP8 weights, more than one 8-GPU 80 GB node; the case Anthropic studied
Screenshot of the Rocinante X 12B website
Rocinante X 12B, official site

Licences differ by build. A base model's Apache 2.0 does not tell you the terms of someone's edit, and several popular fine-tunes declare no licence at all. Read the licence file in the repository you download from.

How to choose

  • You need reliable tool calls. Start with a steerable model or a well-documented fine-tune, at 4-bit or higher, and test the schema on your own tools. Treat abliterated builds as experimental for agents until they pass that test.
  • You want the model to follow your rules, not none. Hermes 4 with an explicit system-prompt policy, plus a separate filter for anything that must never happen.
  • You want maximum openness on one box for coding or vision. An abliterated Qwen 3.8 27B on a 24 GB card, with its maker's production warning taken at face value.
  • Fiction and role-play on a small card. Rocinante X 12B or Cydonia 24B, which were built for it.
Screenshot of the Qwen3.8-27B website
Qwen3.8-27B, official site

Whichever you pick, run three checks at the context length you will really use, not on a two-line demo:

  1. Refusals. Run 20 to 50 prompts drawn from your real workload, including the edge cases that made aligned models refuse, and count refusals and evasive non-answers.
  2. Tools. Run 50 to 100 multi-turn tool-calling and structured-output tasks, and count schema errors and dropped tools.
  3. Drift. Run the same prompts through the build and its base model with the same seed and greedy decoding, and compare the answers side by side. When a card publishes no KL divergence, this is your stand-in for it.

Then put the safety layer the model no longer has where it belongs: a classifier such as Qwen3Guard or Llama Guard 4 on inputs and outputs, tight tool permissions, and logs. The guardrails guide walks through each.

Screenshot of the Qwen3Guard website
Qwen3Guard, official site

The catch: the label on a model card is the only description most of these builds have. "Uncensored" can mean a careful edit with published drift figures or a two-hour job with copied benchmarks and no licence, and from outside the two look the same until you test them.

Our take: removing refusals is like taking the guard off a saw. It makes some cuts possible that were not before and changes nothing about how sharp the blade is. Buy the saw for the blade, which means the base model, and put the guard back somewhere you control.

The ReviewRamble brief

AI, reviewed. Once a week, in your inbox.

The verdicts that matter across AI, robotics and tech, with what to use and what to skip. No hype, no digest of everything.

Models, agents, MCP servers and the tools actually worth your time.

One email a week. Unsubscribe with the link in any brief. How we use your email