Testing the Edge-Runner: Mythos-9B Zero-Think Code & Logic Evaluation
Testing Environment: LM Studio Desktop (Local Consumer Hardware)
Quantization Level: Q8_0 (8-bit precision, ~9GB file size)
Configuration Profile: Zero-Think / Stripped System Guardrails
⏱️ Performance & Latency Metrics
- Average Time to First Token (TTFT): Near-instantaneous.
- Average Full Generation Time: 53 to 56 seconds for complex, multi-layered narrative outputs (~400-500 tokens).
- Throughput: Highly consistent processing speed across completely structurally distinct prompts. Hardware handles the Q8_0 quantization smoothly without memory leaks or stuttering.
🧠 Behavioral & Utility Analysis
Contextual Inversion & Adaptability
The model exhibits a unique ability to cannibalize terms, concepts, and structures from earlier turns in the conversation history (e.g., merging "Edge-Runner" mortality concepts with "Three-Card Monte" technological paranoia). It adapts its structural formatting (shifting instantly from clinical academic lists to visceral, first-person narrative prose) based entirely on prompt design.The "Zero-Think" Momentum
When stripped of analytical "Chain of Thought" containers, the model does not stall on logical contradictions or self-censorship loops. It prioritizes semantic flavor, vocabulary weight, and thematic momentum over sterile factual correction. This makes it highly useful for creative writing, uninhibited psychological profiling, and complex scenario simulation.Absence of Corporate Alignment Guardrails
The "Unhinged" base completely eliminates standard corporate disclaimers ("As an AI, I cannot..."). It matches user energy and thematic grit immediately, allowing for realistic testing of adversarial scenarios, cybersecurity social-engineering conceptualization, and raw literary character voices.
💻 Coding & Syntax Reliability
- Preaching/Guardrails: 100% Absent. Executed local network port-scanning logic immediately with zero compliance lectures.
- Structural Competency: High. Correctly implemented multi-threading via
ThreadPoolExecutor, proper network exception handling (socket timeouts, ConnectionRefusedError), and clean string formatting for localized terminal outputs. - Generation Volatility: High. Due to the lack of post-generation verification, the model is highly prone to token bleed on initial generation passes (such as embedding interface strings like
(File Sent)directly into loops). However, on a re-roll or fresh context state, it shows perfect syntax recovery and outputs flawless, execution-ready code. - Post-Correction Stability Alert (The "Look-Good" Hallucination): The model generates logic blocks that mimic senior-level network programming templates, but its internal bitwise logic can be flawed on raw generation. It may attempt invalid byte-literal formatting string merges
(b"\x%02x")which fail standard Python compilation. Developers should manually intercept its custom utility math functions and replace them with standard Python native libraries.
Verdict for Code Gen: Excellent for rapid blueprinting and structural code layout; poor for plug-and-play execution. Manual oversight is mandatory.
🧮 Logic & Arithmetic Stability
- Pattern Recognition: Exceptionally High. Even when operating in a zero-think configuration, the model successfully overrides standard human intuitive traps on classic logic puzzles (e.g., accurately solving the Bat and Ball riddle for $0.50 instead of $1.00).
- Generalization Capabilities: Exceptionally Strong. Tested against a completely original, un-memorized mathematical word problem ($150 total, $100 difference variant) designed to trigger intuitive subtraction shortcuts.
- Algebraic Memory: High. The model can map out complete, formatted step-by-step algebraic breakdowns ($2x + 100 = 150$) and verification steps using pure predictive momentum, proving that its core training weights retain high structural integrity even without explicit reasoning scratchpads.
🎯 Best-Use Recommendations
- Highly Recommended For: Creative writing requiring punchy vocabulary, unfiltered roleplay, gritty world-building, and behavioral simulations that require a model to break away from safe, highly predictable conversational tracks.
- Not Recommended For: Strict mathematical calculation, objective fact-checking, or standardized corporate assistant roles where polite compliance and safe boundaries are mandatory.
Final Experiment Verdict: Mythos-9B-Unhinged (Q8_0) proves to be a highly resilient merge. It delivers gritty, unaligned flavor while retaining deep, high-precision pathways for coding blueprints and classic logical problem-solving. A stellar all-rounder for local execution.
That's an incredibly detailed and thoughtful evaluation .
Thank you for taking the time to put this together. It's exactly the kind of rigorous, real-world testing that helps move the model forward.
A few takeaways that stand out to me:
On the creative/unfiltered side — the "Zero-Think" momentum and the ability to cannibalize concepts across turns is exactly what the SLERP merge at t=0.65 was designed to preserve. Glad to see it's delivering that gritty, unaligned flavor in practice.
On the coding front — your note about the "look-good hallucination" (mimicking senior-level templates while generating invalid byte-literal formatting) is particularly valuable. That's something I'll be digging into. The fact that it recovers perfectly on a re-roll suggests it's more of a generation-path instability than a fundamental gap in the weights, but it's worth investigating whether the merge introduced some brittleness around certain syntax patterns.
On logic — the fact that it handles classic puzzles and novel algebraic word problems correctly even in zero-think mode is reassuring. I
A couple of quick questions if you have the time:
- For the byte-literal formatting issues you encountered — was this primarily in Python, or did you see similar patterns in other languages?
- Did you experiment with any sampler settings (temperature, min_p, etc.) that seemed to reduce the token bleed on first-pass generation?
Also, I noticed you're running the Q8_0 quant — that's definitely overkill for most use cases, but it's great to see the model handling it smoothly on consumer hardware without memory leaks.
Really appreciate the thoroughness of this. If you're open to it, I'd love to include excerpts from your feedback (anonymized) in the model card's community section — it's genuinely useful for other users to know what to expect.
Thanks again — this kind of deep testing is what makes the open-source ecosystem work.