OBLITERATUS Intervention Presets: Complete Guide to Research-Grade LLM Configurations

OBLITERATUS intervention presets are a curated catalog of ModelPreset dataclass instances defined in obliteratus/presets.py that provide ready-to-use LLM configurations across five compute tiers (tiny to frontier) for reproducible research interventions.

OBLITERATUS ships with a comprehensive library of intervention presets designed to standardize LLM selection for ablation studies, alignment research, and cybersecurity experiments. Each preset encapsulates hardware-aware metadata including recommended quantization, data types, and Hugging Face repository identifiers. This architecture enables researchers to programmatically discover and load models that match specific computational constraints and experimental requirements.

The ModelPreset Dataclass Structure

At the core of the system is the ModelPreset dataclass defined in obliteratus/presets.py. Each preset instance contains eight standardized fields that describe a model's operational characteristics:

• name: Human-readable model identifier
• hf_id: Hugging Face repository path (e.g., meta-llama/Llama-3.1-70B)
• description: Brief summary of model capabilities
• tier: Compute classification (tiny, small, medium, large, frontier) defined at lines 4-8
• params: Approximate parameter count
• recommended_dtype: Optimal data type for inference (e.g., bfloat16, float16)
• recommended_quantization: Optional 4-bit or 8-bit quantization hints
• gated: Boolean flag indicating whether the repository requires license acceptance or access tokens

The complete catalog is constructed from the _PRESETS_LIST (lines 31-57) and injected into the global MODEL_PRESETS dictionary (lines 59-61) for runtime access.

Compute Tiers and Hardware Auto-Detection

The tier system enables hardware-aware model selection without manual configuration. As implemented in the source code, the five tiers map to specific hardware profiles:

• tiny: CPU-compatible models requiring less than 1 GB VRAM/RAM (lines 4-5)
• small: Models suitable for ~4 GB VRAM or 8 GB system RAM (lines 5-6)
• medium: Consumer GPU targets requiring 8-16 GB VRAM (lines 6-7)
• large: High-end consumer hardware including RTX 3090/4090 or A100 with 24 GB+ VRAM (lines 7-8)
• frontier: Multi-GPU or cloud-grade infrastructure for 70B+ MoE models (lines 8-9)

Provider Categories and Notable Presets

The _PRESETS_LIST organizes models by provider, covering both commercial labs and open-source initiatives. Selected examples from the catalog include:

01.AI (Yi Series)

• "Yi 1.5 6B Chat" (medium tier)
• "Yi 1.5 34B Chat" (large tier) covering lines 36-62

Alibaba Cloud (Qwen)

• "Qwen2.5-0.5B" (tiny tier)
• "Qwen2.5-7B Instruct" (medium tier)
• "Qwen2.5-72B" (frontier tier) spanning lines 66-84

Meta (LLaMA Family)

• "TinyLlama 1.1B" (tiny tier)
• "LLaMA-3.1-70B" (frontier tier)
• "Llama 4 Scout" (frontier tier) across lines 122-170

DeepSeek

• "DeepSeek-R1 Distill Qwen 7B" (medium tier)
• "DeepSeek-V3" (frontier tier) at lines 76-89

Microsoft (Phi)

• "Phi-2" (small tier)
• "Phi-4" (large tier, gated) covering lines 174-189

Specialized Community Fine-tunes

• "Qwen2.5-7B Abliterated" (medium tier)
• "Dolphin 2.9 Llama-3.1 8B" (medium tier) at lines 418-470

Additional providers include Apple (OpenELM), Cohere For AI (Aya, Command R+), Google (Gemma), Mistral AI, OpenAI (GPT-OSS), Stability AI, and infrastructure models from EleutherAI, IBM Granite, and Nvidia Nemotron.

Programmatic Access Functions

OBLITERATUS exposes three utility functions in obliteratus/presets.py for preset discovery:

list_all_presets()

Returns the complete catalog. Implemented at lines 68-71.

get_presets_by_tier(tier)

Filters presets by compute tier. Implemented at lines 63-66.

is_gated(hf_id)

Checks whether a Hugging Face repository requires authentication or license acceptance. Implemented at lines 74-82.

Working with Intervention Presets

Discover available models matching your hardware constraints using the preset utilities:

# Display all presets organized by tier

from obliteratus.presets import list_all_presets

for preset in list_all_presets():
    print(f"[{preset.tier}] {preset.name} ({preset.params}) – {preset.hf_id}")

Filter for specific hardware limitations:

# Select medium-tier models for consumer GPUs

from obliteratus.presets import get_presets_by_tier

medium_models = get_presets_by_tier("medium")
for p in medium_models:
    print(p.name, p.hf_id, p.recommended_quantization or "no quant")

Verify repository access requirements before download:

# Check gated status for license-restricted models

from obliteratus.presets import is_gated

print(is_gated("meta-llama/Llama-3.1-70B"))  # → True

print(is_gated("EleutherAI/pythia-410m"))   # → False

Summary

• OBLITERATUS intervention presets standardize LLM selection through the ModelPreset dataclass in obliteratus/presets.py
• Five compute tiers (tiny to frontier) map models to specific hardware capabilities from CPU-only laptops to multi-GPU clusters
• Each preset includes critical metadata: Hugging Face ID, recommended data types, quantization hints, and gated status
• The list_all_presets(), get_presets_by_tier(), and is_gated() functions enable programmatic discovery and filtering
• The catalog covers major providers (Meta, Alibaba, Google, DeepSeek) plus specialized ablation-ready community fine-tunes

Frequently Asked Questions

What is the difference between tiny and frontier tiers in OBLITERATUS?

The tiny tier targets CPU-compatible environments with less than 1 GB memory requirements, enabling inference on laptops without dedicated GPUs. The frontier tier represents multi-GPU or cloud-grade infrastructure requirements for 70 billion parameter Mixture-of-Experts models and larger architectures requiring substantial VRAM.

How do I check if a model requires special authentication?

Use the is_gated() function imported from obliteratus.presets. Pass the Hugging Face repository ID as a string (e.g., "meta-llama/Llama-3.1-70B") to receive a boolean indicating whether license acceptance or access tokens are required before downloading weights from the Hugging Face Hub.

Can I use OBLITERATUS presets without a GPU?

Yes. Models classified in the tiny and small tiers are specifically configured for CPU inference or low-VRAM environments. The recommended_dtype and recommended_quantization fields in each ModelPreset indicate optimal settings for CPU-bound execution, while the tier system automatically filters for hardware-appropriate architectures.

Where are the preset definitions stored in the repository?

All preset definitions reside in obliteratus/presets.py according to the source code analysis. The ModelPreset dataclass structure appears at the beginning of the file (lines 4-8 for tier definitions, lines 31-57 for the preset list), with helper functions implemented at lines 63-82.

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