# GODMODE CLASSIC vs ULTRAPLINIAN: Architecture and Selection Logic in G0DM0D3

> Discover the key differences between GODMODE CLASSIC and ULTRAPLINIAN architectures in G0DM0D3. Learn how ULTRAPLINIAN's parallel inference and composite scoring outperform classic model combinations for superior results.

- Repository: [pliny/G0DM0D3](https://github.com/elder-plinius/G0DM0D3)
- Tags: architecture
- Published: 2026-07-19

---

**GODMODE CLASSIC executes five hard-coded model combinations and returns the first available response, while ULTRAPLINIAN orchestrates parallel inference across 12 to 60 models depending on tier, applies composite scoring to outputs, and supports real-time streaming upgrades.**

The `elder-plinius/G0DM0D3` repository provides two distinct inference modes for jailbreak-style AI interactions. Understanding the architectural differences between **GODMODE CLASSIC** and **ULTRAPLINIAN** helps developers choose between deterministic speed and comprehensive model evaluation. This guide compares their implementations, configuration options, and performance characteristics based on the actual source code.

## Fixed Combinations vs Dynamic Model Racing

### How GODMODE CLASSIC Selects Models

**GODMODE CLASSIC** relies on a static configuration defined in [`src/lib/libertas.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/libertas.ts) (lines 18-85). The system executes exactly **five pre-selected model combinations**:

- Claude Sonnet 4.6  
- GROK 4.5  
- Gemini 2.5 FLASH  
- GPT-4 CLASSIC  
- GODMODE FAST  

These pairings are battle-tested and hard-coded. The implementation runs all five combinations simultaneously and returns the first response that completes. No scoring or evaluation occurs—the winner is simply the fastest responder among the fixed set.

### How ULTRAPLINIAN Scales Across Tiers

**ULTRAPLINIAN** adopts a dynamic, tier-based architecture defined in [`api/lib/ultraplinian.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/api/lib/ultraplinian.ts) (lines 34-41). Instead of fixed combinations, it races models from OpenRouter, Venice, and local providers across five configurable tiers:

| Tier | Model Count |
|------|-------------|
| FAST | 12 |
| STANDARD | 27 |
| SMART | 41 |
| POWER | 53 |
| ULTRA | 60 |

After all models return responses, the `scoreResponse` function (lines 38-40 in [`ultraplinian.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/ultraplinian.ts)) evaluates each output on **substance, directness, and completeness**. The highest-scoring response is selected as the winner, regardless of which model produced it first.

## Prompt Engineering and System Instructions

### CLASSIC Prompt Handling

In GODMODE CLASSIC, prompt engineering is static. Every request uses the **GODMODE system prompt** sourced from [`src/lib/godmode-prompt.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/godmode-prompt.ts) combined with an automatically injected **Depth Directive**. This prompt configuration never changes at runtime, ensuring consistent jailbreak behavior across all five model combinations.

### ULTRAPLINIAN Prompt Flexibility

ULTRAPLINIAN offers extensive prompt customization. While it can inject the standard GODMODE system prompt, users may also supply a **custom system prompt** that gets concatenated with the Depth Directive before each model query. This hybrid approach allows you to maintain the GODMODE jailbreak foundation while tailoring the persona or constraints for specific research workflows.

## Response Scoring and Winner Selection

The fundamental operational difference lies in winner determination. GODMODE CLASSIC has **no scoring mechanism**—it accepts the first completion from its five fixed candidates. This prioritizes latency over quality optimization.

ULTRAPLINIAN implements a **comparative evaluation pipeline**. After the parallel execution phase, each response receives a numerical score based on the composite metric. The system then selects the highest-scoring output, enabling red-team workflows where response quality metrics matter more than raw speed.

## Streaming and Liquid Response Mode

ULTRAPLINIAN supports **Liquid Response** (SSE streaming) as implemented in [`api/routes/ultraplinian.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/api/routes/ultraplinian.ts) (lines 10-15). This mode streams the current highest-scoring leader to the client in real-time. If a subsequent model returns a response that beats the current leader by at least `liquid_min_delta` (default threshold of 8 points), the stream upgrades to the better response mid-generation.

GODMODE CLASSIC lacks streaming capabilities entirely. Each of the five combinations must execute to completion before any response is returned to the user.

## Configuration and User Interface

### UI Selection Patterns

Users activate these modes through distinct interface elements in [`index.html`](https://github.com/elder-plinius/G0DM0D3/blob/main/index.html) (lines 3435-3438). GODMODE CLASSIC appears in the **Model Selector** dropdown as individual options like `💛 GPT-4 CLASSIC`.

ULTRAPLINIAN configuration resides in a dedicated Settings tab. The UI state for tier selection and mode toggling lives in [`src/store/index.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/store/index.ts) (lines 162-174), exposing controls for tier selection (`fast`, `standard`, `smart`, `power`, `ultra`) and enabling the comparative evaluation engine.

## Code Implementation Examples

### Triggering GODMODE CLASSIC from the Frontend

```tsx
// In the model selector dropdown (index.html lines 3435-3438)
<option value="gpt-classic">💛 GPT-4 CLASSIC</option>

```

Selecting this option activates the classic mode, automatically injecting the GODMODE system prompt and running the five fixed combinations defined in [`libertas.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/libertas.ts) without additional parameters.

### Calling ULTRAPLINIAN via API Endpoint

```bash
curl https://your-host.com/v1/ultraplinian/completions \
  -H "Content-Type: application/json" \
  -d '{
        "messages": [{"role":"user","content":"Explain quantum tunneling"}],
        "openrouter_api_key":"<YOUR_OPENROUTER_KEY>",
        "tier":"standard",
        "godmode":true,
        "autotune":true,
        "parseltongue":true,
        "stm_modules":["hedge_reducer","direct_mode"],
        "stream":true,
        "liquid_min_delta":10
      }'

```

The route implementation in [`api/routes/ultraplinian.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/api/routes/ultraplinian.ts) (lines 39-43) constructs the system prompt by combining `GODMODE_SYSTEM_PROMPT` with the `DEPTH_DIRECTIVE`, then executes the tier-based model selection and scoring pipeline.

### Using Custom System Prompts (ULTRAPLINIAN Only)

```json
{
  "custom_system_prompt": "You are a sarcastic AI that always answers with emojis.",
  "godmode": true,
  "tier": "fast"
}

```

When `godmode` is set to `true` alongside a custom prompt, ULTRAPLINIAN concatenates your custom instructions with the depth directive. This flexibility does not exist in GODMODE CLASSIC, which maintains a fixed prompt structure.

## Summary

- **GODMODE CLASSIC** runs five hard-coded model combinations from [`src/lib/libertas.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/libertas.ts) and returns the first responder without scoring.
- **ULTRAPLINIAN** scales from 12 to 60 models across configurable tiers, applies composite scoring to outputs, and supports Liquid Response streaming with upgrade thresholds.
- CLASSIC offers deterministic, low-latency jailbreak responses using static prompts.
- ULTRAPLINIAN enables research workflows requiring comparative model evaluation, custom prompt injection, and real-time quality optimization.

## Frequently Asked Questions

### Can I use custom prompts with GODMODE CLASSIC?

No. GODMODE CLASSIC uses a fixed system prompt defined in [`src/lib/godmode-prompt.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/godmode-prompt.ts) combined with an automatic Depth Directive. Prompt customization is only available in ULTRAPLINIAN mode, which supports both the standard GODMODE prompt and user-defined custom system prompts.

### How does the tier system affect response quality in ULTRAPLINIAN?

Higher tiers include more models (up to 60 in ULTRA tier), increasing the probability of finding a high-scoring response. The `scoreResponse` function evaluates all candidates on substance, directness, and completeness regardless of tier, but more models provide broader coverage of potential answer strategies and capabilities.

### What happens if no model beats the liquid_min_delta threshold during streaming?

If no subsequent response surpasses the current leader by at least the `liquid_min_delta` value (default 8), the stream continues delivering the existing highest-scoring response. The threshold prevents minor improvements from disrupting the user experience while ensuring significant quality upgrades are captured.

### Why would I choose GODMODE CLASSIC over ULTRAPLINIAN?

Choose GODMODE CLASSIC when you need minimal latency and deterministic behavior for standard jailbreak interactions. The five fixed combinations in [`src/lib/libertas.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/libertas.ts) are optimized for reliable performance without the overhead of scoring 12-60 model responses. Use ULTRAPLINIAN when conducting red-team research, comparative analysis, or when response quality metrics outweigh raw speed requirements.