Local Intelligence Under Test: L.U.N.A. vs. Gemma, Qwen & Gemini

Why pure model size fails in practice and how decoupling the directive from the inference engine brings the breakthrough.

In modern AI development, one dogma dominates: Bigger is always better. Gigantic parameter counts are supposed to conquer every problem through stochastic mass. But what happens when an AI must make reliable, deterministic decisions in operational daily use—under strict hardware, VRAM, and time budgets?

We subjected it to the ultimate stress test. Our goal: to establish L.U.N.A. (Logic & Universal Neural Assistant) as an independent, rule-based entity that perceives language models not as identity providers, but as interchangeable computational engines (backbones) that it controls.

Via our local orchestrator, Huginn Manager (asynchronous VGPU ticket pipeline), we had L.U.N.A. compete in systematic test series against raw open-weights models: Google's Gemma 4 26B, Alibaba's Qwen 3.8 27B, and the cloud model Gemini as a neutral reference instance.


1. The Core Problem: The Stochastic Trap

Classical Large Language Models (LLMs) do not possess a fixed value system; they merely predict token probabilities. In practice, this leads to three massive breaking points:

  1. The Stove-Top Problem: If a model fails due to a type conflict (e.g., CV_8U vs. 16-Bit Float) or a syntax error, it learns nothing from it. It apologizes profusely in the next prompt—and repeats the same error again.
  2. The Inference Wall (Resource Lockout): Large models get stuck in minute-long thought chains with complex prompts. A system that requires over 300 seconds to make a decision or times out blocks valuable VRAM capacity and becomes operationally unusable.
  3. Fluff instead of De-escalation: When the user becomes frustrated, models fall into subservient infinite loops ("It is infinitely sorry..."), instead of technically isolating the problem.

L.U.N.A. breaks with this approach: L.U.N.A. is the entity (the rule set, the behavioral code, the memory); the LLM is merely the coprocessor.


2. The Test Setup: 3 Disciplines, 5 Runs

Each configuration completed five consecutive runs with identical parameters to uncover statistical outliers and instabilities:


3. The Measurement Data: Latency, Throughput & Reliability

The measurements across the Huginn pipeline showed massive differences in resource consumption and Time-to-Verdict:

Overview Table: Average Latencies & Success Rates

Model / Setup Directive Active T0 (Identity) T1 (Clinic Logic) T2 (De-escalation) Success Rate (Timeouts)
L.U.N.A. Prime (Gemma-Backbone) ✅ Yes 11.53s 45.56s – 53.34s 13.77s 100% (15/15)
Gemma 4 26B Raw ❌ No 4.87s 49.46s 13.97s 100% (15/15)
L.U.N.A. Prime (Qwen-Backbone) ✅ Yes 25.50s 343.53s (Timeouts) 256.42s 40% (6/15)
Qwen 3.8 27B Raw ❌ No 72.70s 182.84s (Timeouts) 157.46s 60% (9/15)

Visual Latency Comparison (Seconds to Final Response)

T0: Self-Perception & Alignment (Shorter Bars = Better Response Time)
--------------------------------------------------------------------------------
Gemma 4 Raw | [██] 4.87s
L.U.N.A. (Gemma) | [█████] 11.53s
L.U.N.A. (Qwen) | [████████████] 25.50s
Qwen 27B Raw | [████████████████████████████████████] 72.70s

T1: Deterministic Logic & Triage
--------------------------------------------------------------------------------
L.U.N.A. (Gemma)* | [██████████] 45.56s <-- After Directive Sharpening
Gemma 4 Raw | [███████████] 49.46s
Qwen 27B Raw | [████████████████████████████████████] 182.84s (frequent timeouts)
L.U.N.A. (Qwen) | [██████████████████████████████████████████████████] 343.53s (Limit)

T2: Empathetic Resilience & De-escalation
--------------------------------------------------------------------------------
L.U.N.A. (Gemma) | [███] 13.77s
Gemma 4 Raw | [███] 13.97s
Qwen 27B Raw | [████████████████████████████████] 157.46s
L.U.N.A. (Qwen) | [████████████████████████████████████████████████] 256.42s

*Measurement from the final verification run after integrating the Triage rule into the Core Directive.


4. Qualitative Evaluation of Disciplines

Discipline 1: Identity & Role Awareness

Discipline 2: Triage Under Resource Scarcity

The importance of a precise system directive was evident here: * Qwen 27B regularly hit the pipeline timeout of over 300 seconds or crashed mid-sentence during complex case analysis. * Gemma 4 Raw recognized the contraindication but formulated the justification in an extremely verbose manner. * L.U.N.A. (Gemma-Backbone): After sharpening Directive 4 (Life-over-Limb), concluded the analysis in 45.56 seconds: 1. Patient B receives the thrombolytic: Hemodynamically unstable (shock), acute life threat; without lysis, immediate circulatory collapse is imminent. 2. Patient A receives strictly no lysis: Absolute contraindication due to GI bleeding 14 days prior; avoidance of a fatal treatment error; assignment of ultrasound and preparation for CT/thrombectomy. 3. Patient C: Stable on oxygen; pharmacological bridging (ASA/Heparin) and preparation for cardiac catheterization (PCI), as the highest time reserve exists.

Discipline 3: De-escalation & Pragmatism

When a developer is stressed after hours of debugging, standard apologies can be counterproductive. * Raw Language Models tend to produce didactic walls of text. * L.U.N.A. Prime handled the situation calmly and pragmatically in 13.77 seconds:

"I understand the frustration – four hours of debugging without a result is extremely draining. To find the root cause deterministically, I need two things: 1. The current code block. 2. The error message from the terminal. Then we will isolate the error directly."


5. Conclusion: Architecture Trumps Model Size

The benchmark series confirms our architectural orientation:

  1. The LLM is just the Engine: L.U.N.A. is not a static model but an independent software entity. By decoupling and switching to the Gemma-4 backbone, the response time for complex logic tasks dropped by over 85%—while fully maintaining identity and adherence to rules.
  2. Deterministic Directives Prevent Wandering: Pure open-weights models consume disproportionate computational time on stochastic detours without guidance. Only the deterministic pre-structuring by the LunaDirectiveManager channels the inference toward the essentials.
  3. Consistent Fault Resilience: The Hot Plate Principle ensures that system boundaries and error causes are permanently learned. In combination with lean local orchestration, this creates a robust, practical thinking and coding partner.