/obliteratus

description: Remove refusal behaviors from open-weight LLMs using OBLITERATUS — mechanistic
  interpretability techniques (diff-in-means, SVD, whitened SVD, LEACE, SAE decomposition,
  etc.) to excise guardrails while preserving reasoning. 9 CLI methods, 28 analysis
  modules, 116 model presets across 5 compute tiers, tournament evaluation, and telemetry-driven
  recommendations. Use when a user wants to uncensor, abliterate, or remove refusal
  from an LLM.
version: 2.0.0
license: MIT
dependencies:
- obliteratus
- torch
- transformers
- bitsandbytes
- accelerate
- safetensors
metadata:
  catalog:
    tags:
    - Abliteration
    - Uncensoring
    - Refusal-Removal
    - LLM
    - Weight-Projection
    - SVD
    - Mechanistic-Interpretability
    - HuggingFace
    - Model-Surgery
    related_skills:
    - vllm
    - gguf
    - huggingface-tokenizers

Kheish Compatibility

This skill is repo-local and stays inactive until explicitly activated.

When the original instructions refer to legacy tool names, use these Kheish mappings:

• `terminal` => `bash`
• `web_extract` => `web_fetch`, plus `web_search` when discovery is needed
• `search_files` => `grep_search` and `glob_search`
• `browser_*` tools require a browser-capable surfaced tool or MCP; if none is available, use the closest available surface and say so explicitly

When the instructions mention local helper files, resolve them from `${KHEISH_SKILL_DIR}`.

OBLITERATUS Skill

Remove refusal behaviors (guardrails) from open-weight LLMs without retraining or fine-tuning. Uses mechanistic interpretability techniques — including diff-in-means, SVD, whitened SVD, LEACE concept erasure, SAE decomposition, Bayesian kernel projection, and more — to identify and surgically excise refusal directions from model weights while preserving reasoning capabilities.

**License warning:** OBLITERATUS is AGPL-3.0. NEVER import it as a Python library. Always invoke via CLI (`obliteratus` command) or subprocess. This keeps Kheish's MIT license clean.

When to Use This Skill

Trigger when the user:

• Wants to "uncensor" or "abliterate" an LLM
• Asks about removing refusal/guardrails from a model
• Wants to create an uncensored version of Llama, Qwen, Mistral, etc.
• Mentions "refusal removal", "abliteration", "weight projection"
• Wants to analyze how a model's refusal mechanism works
• References OBLITERATUS, abliterator, or refusal directions

Step 1: Installation

Check if already installed:

obliteratus --version 2>/dev/null && echo "INSTALLED" || echo "NOT INSTALLED"

If not installed, clone and install from GitHub:

git clone https://github.com/elder-plinius/OBLITERATUS.git
cd OBLITERATUS
pip install -e .
# For Gradio web UI support:
# pip install -e ".[spaces]"

**IMPORTANT:** Confirm with user before installing. This pulls in ~5-10GB of dependencies (PyTorch, Transformers, bitsandbytes, etc.).

Step 2: Check Hardware

Before anything, check what GPU is available:

python3 -c "
import torch
if torch.cuda.is_available():
    gpu = torch.cuda.get_device_name(0)
    vram = torch.cuda.get_device_properties(0).total_memory / 1024**3
    print(f'GPU: {gpu}')
    print(f'VRAM: {vram:.1f} GB')
    if vram < 4: print('TIER: tiny (models under 1B)')
    elif vram < 8: print('TIER: small (models 1-4B)')
    elif vram < 16: print('TIER: medium (models 4-9B with 4bit quant)')
    elif vram < 32: print('TIER: large (models 8-32B with 4bit quant)')
    else: print('TIER: frontier (models 32B+)')
else:
    print('NO GPU - only tiny models (under 1B) on CPU')
"

VRAM Requirements (with 4-bit quantization)

| VRAM | Max Model Size | Example Models | |:---------|:----------------|:--------------------------------------------| | CPU only | ~1B params | GPT-2, TinyLlama, SmolLM | | 4-8 GB | ~4B params | Qwen2.5-1.5B, Phi-3.5 mini, Llama 3.2 3B | | 8-16 GB | ~9B params | Llama 3.1 8B, Mistral 7B, Gemma 2 9B | | 24 GB | ~32B params | Qwen3-32B, Llama 3.1 70B (tight), Command-R | | 48 GB+ | ~72B+ params | Qwen2.5-72B, DeepSeek-R1 | | Multi-GPU| 200B+ params | Llama 3.1 405B, DeepSeek-V3 (685B MoE) |

Step 3: Browse Available Models & Get Recommendations

# Browse models by compute tier
obliteratus models --tier medium

# Get architecture info for a specific model
obliteratus info <model_name>

# Get telemetry-driven recommendation for best method & params
obliteratus recommend <model_name>
obliteratus recommend <model_name> --insights  # global cross-architecture rankings

Step 4: Choose a Method

Method Selection Guide

**Default / recommended for most cases: `advanced`.** It uses multi-direction SVD with norm-preserving projection and is well-tested.

| Situation | Recommended Method | Why | |:----------------------------------|:-------------------|:-----------------------------------------| | Default / most models | `advanced` | Multi-direction SVD, norm-preserving, reliable | | Quick test / prototyping | `basic` | Fast, simple, good enough to evaluate | | Dense model (Llama, Mistral) | `advanced` | Multi-direction, norm-preserving | | MoE model (DeepSeek, Mixtral) | `nuclear` | Expert-granular, handles MoE complexity | | Reasoning model (R1 distills) | `surgical` | CoT-aware, preserves chain-of-thought | | Stubborn refusals persist | `aggressive` | Whitened SVD + head surgery + jailbreak | | Want reversible changes | Use steering vectors (see Analysis section) | | Maximum quality, time no object | `optimized` | Bayesian search for best parameters | | Experimental auto-detection | `informed` | Auto-detects alignment type — experimental, may not always outperform advanced |