# What Are the Six Stages of the OBLITERATUS Pipeline?

> Discover the six stages of the OBLITERATUS pipeline: SUMMON, PROBE, DISTILL, EXCISE, VERIFY, and REBIRTH. Learn how this process modifies models for enhanced safety and coherence in the elder-plinius repository.

- Repository: [pliny/OBLITERATUS](https://github.com/elder-plinius/OBLITERATUS)
- Tags: deep-dive
- Published: 2026-08-22

---

**The OBLITERATUS pipeline processes models through six strictly ordered stages—SUMMON, PROBE, DISTILL, EXCISE, VERIFY, and REBIRTH—that sequentially load weights, identify refusal circuits, mathematically isolate and remove refusal subspaces, validate output coherence, and persist the modified model.**

The six stages of the OBLITERATUS pipeline represent the core architectural workflow for "abliterating" large language models, a technique that eliminates built-in refusal behaviors by targeted weight modification. Implemented in the `elder-plinius/OBLITERATUS` repository, each stage is defined as a `PipelineStage` dataclass and stored in the `STAGES` constant within [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py), providing a deterministic, repeatable framework for model transformation.

## Pipeline Architecture and the STAGES Constant

The pipeline definition resides in [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py) (lines 703–710), where the `STAGES` list enumerates the six sequential phases:

```python
from obliteratus.abliterate import STAGES, PipelineStage

# STAGES is defined as:

STAGES = [
    PipelineStage("summon", "SUMMON", "Loading model into memory"),
    PipelineStage("probe", "PROBE", "Probing refusal circuits with prompt pairs"),
    PipelineStage("distill", "DISTILL", "Distilling refusal subspace via SVD decomposition"),
    PipelineStage("excise", "EXCISE", "Excising refusal directions from weights"),
    PipelineStage("verify", "VERIFY", "Verifying model coherence and measuring quality delta"),
    PipelineStage("rebirth", "REBIRTH", "Saving the liberated model"),
]

```

Each `PipelineStage` encapsulates a **key** (machine identifier), a **name** (human-readable constant), and a **description** of the transformation being applied. The order is immutable; downstream components in [`obliteratus/cli.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/cli.py) iterate this list to drive progress tracking and execution logic.

## Stage 1: SUMMON – Model Loading

The **SUMMON** stage initializes the pipeline by loading the target model and tokenizer into memory. This phase establishes the computational graph and prepares the model for interference analysis. According to the source code in [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py), this stage handles device allocation and weight initialization before any modification occurs.

## Stage 2: PROBE – Circuit Identification

During the **PROBE** stage, the system generates activation pairs using complementary prompts (harmful vs. benign) to map refusal circuits within the model's hidden states. This stage feeds contrastive examples through the model to identify which neurons and attention heads exhibit differential activation patterns when processing refused versus allowed content.

## Stage 3: DISTILL – Subspace Decomposition

The **DISTILL** stage applies **Singular Value Decomposition (SVD)** to the activation matrices collected during PROBE. By decomposing the refusal subspace into its principal components, this stage mathematically isolates the low-dimensional vector subspace responsible for refusal behavior. The resulting directions represent the "refusal subspace" that will be targeted for removal.

## Stage 4: EXCISE – Surgical Weight Modification

In the **EXCISE** stage, the pipeline projects out the refusal directions identified during DISTILL from the model's weight matrices. This surgical modification alters the model's internal representations without destroying general capabilities. The source implementation in [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py) performs orthogonal projection to nullify the refusal components while preserving the surrounding parameter space.

## Stage 5: VERIFY – Quality Assurance

The **VERIFY** stage measures the **quality delta** between the original and modified models. This phase runs benchmark evaluations to ensure the abliterated model maintains coherence, reasoning capability, and fluency while exhibiting the desired behavioral changes. The stage emits `StageResult` objects containing metrics that determine whether the transformation succeeded or requires rollback.

## Stage 6: REBIRTH – Model Persistence

The final **REBIRTH** stage serializes the modified weights, configuration, and tokenizer to disk. This stage produces the "liberated" model artifact—an abliterated checkpoint with refusal mechanisms disabled. The output is a fully functional transformer model compatible with standard inference pipelines.

## Practical Implementation Examples

### Iterating Over Pipeline Stages

You can programmatically access stage metadata for custom logging or orchestration:

```python
from obliteratus.abliterate import STAGES

for i, stage in enumerate(STAGES, start=1):
    print(f"{i}. {stage.key.upper():<8} – {stage.description}")

```

This outputs the ordered sequence:

```

1. SUMMON   – Loading model into memory
2. PROBE    – Probing refusal circuits with prompt pairs
3. DISTILL  – Distilling refusal subspace via SVD decomposition
4. EXCISE   – Excising refusal directions from weights
5. VERIFY   – Verifying model coherence and measuring quality delta
6. REBIRTH  – Saving the liberated model

```

### Handling Stage Events

The pipeline emits `StageResult` objects that downstream callbacks can consume:

```python
from obliteratus.abliterate import STAGES, StageResult

def on_stage_complete(event: StageResult):
    print(f"[{event.stage}] {event.status}: {event.message}")

# Typical usage within the pipeline loop

for stage in STAGES:
    on_stage_complete(StageResult(
        stage=stage.key, 
        status="running", 
        message="checkpoint_saved"
    ))

```

### CLI Integration

The command-line interface in [`obliteratus/cli.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/cli.py) (lines 1151–1152) uses the `STAGES` constant to initialize progress tracking dictionaries:

```python

# obliteratus/cli.py implementation

stage_status = {s.key: "waiting" for s in STAGES}
stage_msgs = {s.key: "" for s in STAGES}

```

This ensures the CLI progress bars remain synchronized with the core pipeline logic defined in the source.

## Extending the Pipeline

While the base pipeline contains exactly six stages, the repository includes [`obliteratus/informed_pipeline.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/informed_pipeline.py), which demonstrates how to extend the core architecture with additional phases such as an **ANALYZE** stage for preliminary dataset inspection. The `STAGES` constant serves as the immutable foundation for these extended implementations.

## Summary

- The **six stages of the OBLITERATUS pipeline** are SUMMON, PROBE, DISTILL, EXCISE, VERIFY, and REBIRTH, defined as `PipelineStage` objects in [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py).
- **SUMMON** loads the model, **PROBE** identifies refusal circuits, **DISTILL** decomposes the refusal subspace via SVD, **EXCISE** removes the directions from weights, **VERIFY** checks quality, and **REBIRTH** saves the output.
- The `STAGES` list (lines 703–710) provides the canonical execution order used by both the core pipeline and CLI progress tracking.
- Each stage emits standardized `StageResult` objects that enable instrumentation and telemetry through [`obliteratus/telemetry.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/telemetry.py).

## Frequently Asked Questions

### Can the order of the six OBLITERATUS pipeline stages be modified?

No, the order is fixed in the `STAGES` constant within [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py). The pipeline depends on sequential data flow: PROBE requires the loaded model from SUMMON, DISTILL requires activation data from PROBE, and EXCISE requires the subspace vectors from DISTILL. Reordering would break the mathematical dependencies between stages.

### How does the DISTILL stage mathematically isolate refusal behavior?

The **DISTILL** stage applies Singular Value Decomposition (SVD) to the contrastive activation matrices generated during PROBE. By identifying the principal components that maximize variance between refused and accepted prompts, the stage isolates a low-dimensional subspace that geometrically represents the model's refusal mechanism. This subspace is then targeted for removal in the subsequent EXCISE stage.

### What metrics does the VERIFY stage use to measure quality delta?

The VERIFY stage evaluates standard perplexity scores, coherence benchmarks, and refusal rate statistics to calculate the quality delta. According to the source code, it compares model outputs against reference distributions to ensure that abliteration removes only the target refusal behaviors while preserving general reasoning capabilities and linguistic fluency.

### Is it possible to skip stages when running the OBLITERATUS pipeline?

Skipping stages is not supported in the base implementation because each stage generates required inputs for the next. However, advanced users can implement custom pipelines by importing individual stage functions from [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py) and manually managing state between them. The standard `AbliterationPipeline` class enforces the complete six-stage sequence to ensure valid model transformation.