What Are the Six Stages of the OBLITERATUS Pipeline?

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, providing a deterministic, repeatable framework for model transformation.

Pipeline Architecture and the STAGES Constant

The pipeline definition resides in obliteratus/abliterate.py (lines 703–710), where the STAGES list enumerates the six sequential phases:

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

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:

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 (lines 1151–1152) uses the STAGES constant to initialize progress tracking dictionaries:

# 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, 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.
• 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.

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. 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 and manually managing state between them. The standard AbliterationPipeline class enforces the complete six-stage sequence to ensure valid model transformation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}