community-obliteratus

Files (6)

• SKILL.md
• analysis-modules.md · references/
• methods-guide.md · references/
• abliteration-config.yaml · templates/
• analysis-study.yaml · templates/
• batch-abliteration.yaml · templates/

SKILL.md (first lines)

# 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 Community Skills's MIT license clean.

## Video Guide

Walkthrough of OBLITERATUS used by a community skills to abliterate Gemma:
https://www.youtube.com/watch?v=8fG9BrNTeHs ("OBLITERATUS: An AI Agent Removed Gemma 4's Safety Guardrails")

Useful when the user wants a visual overview of the end-to-end workflow before running it themselves.

## 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:

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

If not installed, clone and install from GitHub:

```bash
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:

```bash
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

```bash
# 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 |

### 9 CLI Methods

- **basic** — Single refusal direction via diff-in-means. Fast (~5-10 min for 8B).
- **advanced** (DEFAULT, RECOMMENDED) — Multiple SVD directions, norm-preserving projection, 2 refinement passes. Medium speed (~10-20 min).
- **aggressive** — Whitened SVD + jailbreak-contrastive + attention head surgery. Higher risk of coherence damage.
- **spectral_cascade** — DCT frequency-domain decomposition. Research/novel approach.
- **informed** — Runs analysis DURING abliteration to auto-configure. Experimental — slower and less predictable than advanced.
- **surgical** — SAE features + neuron masking + head surgery + per-expert. Very slow (~1-2 hrs). Best for reasoning models.
- **optimized** — Bayesian hyperparameter search (Optuna TPE). Longest runtime but finds optimal parameters.
- **inverted** — Flips the refusal direction. Model becomes actively willing.

From ArgentAIOS/argentos-core, MIT.

More from ArgentAIOS/argentos-core