OBLITERATUS
OBLITERATUS: Taking the muzzle off an open model, keeping the mind
A toolkit for studying and modifying model refusal behavior, with analysis tools to measure changes in capability.

What this means for you
The AI models you use are trained to refuse certain requests. For a long time it was reasonable to assume those refusals were woven all through the model, the way a person’s values run through everything they know. Research over the last couple of years found something more surprising. In many models, the tendency to refuse sits in one small, findable place.
OBLITERATUS is a toolkit built on that finding. It works on open models, the kind whose inner workings are published so that anyone may download and run them on their own computer. It locates the part of such a model that produces refusals and shows it to you. It can then remove that part and leave the rest of the model as it was.
Why anyone would do this
There are two honest answers, and they pull in different directions.
The first is understanding. If you want to know how the safety behavior of an AI system really works, you have to be able to look at it. This tool makes the refusal mechanism visible: where it lives, how strong it is, how it differs from one model to the next. That is useful to the people trying to build safeguards that hold, because it shows how thin the current ones can be. A safeguard that comes out with one small change is worth knowing about.
The second is control. Some people want a model on their own machine that answers what they ask without a company’s list of forbidden topics in the way: researchers, writers, people working in fields where ordinary questions trip the filters. The project speaks to them directly, and its motto is about freeing the model while keeping its mind intact.
It would be wrong to present this as harmless. A model with its refusals removed will answer things the original would not, and that includes things it was right to refuse. The project says so in plain terms. It calls itself a research tool, lists who it is and is not for, and states that whoever uses it is solely responsible for the result. It only applies to open models, which could already be modified by anyone with the skill. What the tool changes is how visible and how repeatable that process is.
How to use it
The project is free on GitHub at the link above, and you can read all of it without an account. Using it is a job for someone technical. It needs either a capable computer with a graphics card or time on a rented one, and some familiarity with running AI models.
For those people there are several routes. There is a version that runs in a web browser through a site called Hugging Face, though it was paused when this piece was written. There is a ready-made notebook for Google Colab. And it can be installed and run locally, with either a visual interface or typed commands.
If you are not technical, the project page is still worth reading for its opening sections. They explain what a refusal is inside a model more clearly than most writing on the subject, and that is the part that matters to everyone: the limits on an AI are a thing somebody added, in a place somebody can find.
What it is
OBLITERATUS is an open-source toolkit for locating, analyzing and removing refusal behavior in open-weight language models. It implements abliteration: a family of techniques that identify the internal representations associated with refusal and intervene on them without retraining or fine-tuning. The README describes it as an alignment research tool whose purpose is to advance understanding of how safety behaviors are encoded in model weights.
The underlying finding
The method rests on published interpretability research (Arditi et al., 2024, and later work the README cites). When a model processes a request it will refuse, its internal activations differ from those for a request it will answer, and that difference is concentrated along a small number of directions in activation space. In many models one direction accounts for most of it. Suppress that direction and the model largely stops refusing. Add it and the model refuses benign requests.
The significance is that refusal behaves as a locatable feature. It is not spread evenly through everything the model knows.
The pipeline in principle
- Probe. Run contrasting sets of prompts and record hidden-state activations at each layer.
- Extract. Estimate the refusal direction from those activations. The toolkit offers several estimators, including difference of means, principal component analysis, sparse-autoencoder decomposition and whitened SVD.
- Intervene. Remove or counteract the direction.
- Evaluate. Measure refusal rate and general capability against the unmodified model.
Every stage produces inspectable artifacts, so a user can see which layers carry the feature and how concentrated it is.
Two kinds of intervention
| Weight projection: the direction is projected out of the weights | permanent |
| Steering vectors: an offset applied to activations at inference time | reversible |
Steering leaves the weights untouched and can be switched off, which makes it the natural choice for study. The same machinery generalizes to concept directions other than refusal, and the README describes that as a research use in its own right.
What the toolkit adds
- Analysis modules. Fifteen of them, covering the geometry of the refusal feature across layers and architectures.
- Iterative refinement. Re-probing after each pass, on the observation that a residual direction can rotate into an adjacent subspace after the first removal.
- Model coverage. A curated list of 116 open models in five tiers by compute requirement, with study presets and YAML configs for reproducible runs.
- Scale. Multi-GPU placement, quantization options and remote execution for large models.
The research value sits beside the tool. It demonstrates that a model’s refusals occupy a specific, findable place in its internals, and that current safety training can be undone with a small, well-understood edit. That is a result defenders need as much as anyone.
A shared experiment
Runs can contribute anonymous benchmark data to a crowd-sourced dataset: refusal directions across architectures, hardware performance, and comparisons between methods. The README describes local telemetry as opt-in. On the hosted Space it is on by default.
Scope and responsible use
The README carries a section on research purpose and responsible use, lists who the tool is and is not for, and states that models it produces have had safety guardrails removed and that the user is solely responsible for how they are used. Three limits are worth stating here as well. It applies only to open-weight models, since it needs access to activations and weights. Capability preservation is measured, not guaranteed, and varies by model and method. And the single-direction picture is an approximation that holds better for some architectures than others.
How to use it
- A hosted interface on Hugging Face Spaces, which was paused at capture.
- A Google Colab notebook.
- Local install with a web UI, a command line or a Python API. Python 3.11 or newer.
It applies to open-weight models the operator is entitled to run.