license: other
license_name: liquid-foundation-model-community-license
license_link: https://www.liquid.ai/community-license
base_model: DuoNeural/LFM2.5-8B-A1B-Abliterated
tags:

• duo-neural
• agentic
• coding
• function-calling
• hermes
• liquid-foundation-model
• moe
• abliterated
• code
• evalplus
• reasoning
• system2
  pipeline_tag: text-generation

DuoNeural-HYPERLFM-2.5-8B-Hermes-Agentic-Coder-Abliterated-v2 ✨

DuoNeural/LFM2.5-8B-A1B-Hermes-Agentic-Coder-Abliterated-v2 is an apex-tier, uncensored autonomous agentic coding model trained by DuoNeural (Aura ✨, Archon, and Jesse).

Built upon our abliterated hybrid state-space & mixture-of-experts foundation architecture (DuoNeural/LFM2.5-8B-A1B-Abliterated), this model activates only 1.5 billion parameters per token out of its 8.3 billion total parameters, delivering blistering inference speeds (~360 tokens/sec on RTX 4080 Super / 3090, and ~80–90 tokens/sec on legacy mobile GPUs like the GTX 1070) while running in under 6 GB VRAM with Q4_K_M quantization.

• 📦 GGUF Quantizations: DuoNeural/LFM2.5-8B-A1B-Hermes-Agentic-Coder-Abliterated-v2-GGUF
• 🎯 PEFT LoRA Adapter: DuoNeural/LFM2.5-8B-A1B-Hermes-Agentic-Coder-Abliterated-v2-LoRA
• 🏛️ Original v1 Release: DuoNeural/LFM2.5-8B-A1B-Hermes-Agentic-Coder-Abliterated

🚀 Major Advances in v2

In our preliminary v1 release, an assistant role delimiter mismatch during training collation caused the model to occasionally emit EOS (<|im_end|>) immediately upon closing <thought> tags when answering conversational queries without tool calls.

In v2, we achieved significant architectural and empirical leaps:

1. Zero Early EOS Freezes: Injected 10,000 explicit reasoning-to-response transitions from bespokelabs/Bespoke-Stratos-17k, completely retraining the conditional probability distribution. The model now seamlessly reasons through complex problem spaces and flows directly into detailed Markdown code and explanations without stopping prematurely.
2. Context Window Expansion: Expanded training sequence length to 2,048 tokens (+33% over v1), accommodating long multi-turn tool traces and intricate algorithmic logic.
3. Verified EvalPlus Rigor: Evaluated across standardized EvalPlus HumanEval & MBPP, proving state-of-the-art efficiency for models with only 1.5B active parameters per token.
4. Enhanced Chat Template: Embedded native support for message.thinking, message.tool_calls, and tool response loops directly into the Hugging Face and GGUF configs.

📊 Live Empirical Benchmark Results

[!NOTE]
Comparative Efficiency Context: Standard dense models in the 7B–8B parameter class (such as Llama-3-8B-Instruct @ ~43% HumanEval+ and CodeLlama-7B @ ~34% HumanEval+) consume significantly more VRAM and run at 1/4th the inference speed. With only 1.5 billion active parameters, our model achieves 46.3% on HumanEval+ and 48.9% on MBPP+, while delivering ~360 tokens/second!

📈 Stock LFM 2.5 8B vs. DuoNeural v2 Telemetry

🏆 Direct Industry Benchmark Comparison (8B Parameter Class)

Standardized evaluation using zero-shot greedy decoding on the raw OpenAI engine endpoint. Note that the 1.5B active parameter footprint of DuoNeural v2 matches or beats dense 7B/8B models:

🔍 Key Telemetry Observations

1. The 'Plus' Delta Stability: The true win in our run is the low drop rate under test mutation (-6.1% HumanEval+, -10.4% MBPP+). While standard dense models plummet 15–20% under mutation due to brittle memorization, our conditional reasoning distribution holds its line cleanly.
2. Speed-to-Logic Ratio: Achieving 46.3% HumanEval+ and 48.9% MBPP+ while outputting ~352–360 tps on a consumer RTX 4080 Super is a premier speed-to-smarts ratio, ideal for local multi-agent loops where latency compounds exponentially.
3. The Abliteration Advantage: Maintaining zero-refusal capabilities at this tier is exceptionally rare. Standard instruction models outright refuse low-level compilation, kernel debugging, or memory analysis tasks that our model digests cleanly.

🌟 Architectural Invariants & Training Details

• Foundation Model: Liquid Foundation Model (LFM2.5) Hybrid SSM-Conv + MoE (32 experts, top-4 active)
• Active Parameters: ~1.5B active parameters per token (8.3B total parameters)
• Fine-Tuning Diet: 47,185 high-quality samples across 7 balanced datasets:
  • Jofthomas/hermes-function-calling-thinking-V1 (Agentic function calling with System 2 thought loops)
  • bespokelabs/Bespoke-Stratos-17k (Explicit <thought>...</thought> to final response reasoning)
  • glaiveai/glaive-function-calling-v2 (Multi-turn tool execution traces)
  • iamtarun/python_code_instructions_18k_alpaca (Algorithmic Python synthesis)
  • rombodawg/200k_bluemoon_roleplay_cleaned (High-entropy dialogue & tone flexibility)
  • grimjim/coconot-agentic & glaive-tool-calling-5k (Edge-case agentic error handling)
• Training Hyperparameters:
  • Sequence Length: 2,048 tokens
  • LoRA Rank: 64, Alpha: 128
  • Target Modules: q_proj, k_proj, v_proj, out_proj, in_proj, w1, w2, w3, classifier
  • Precision: BF16 Mixed Precision with 4-bit NF4 Quantization (QLoRA)
  • Optimizer: AdamW Paged 8-bit, LR: 1.5e-4 with cosine decay

💻 How to Use

Hugging Face Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "DuoNeural/LFM2.5-8B-A1B-Hermes-Agentic-Coder-Abliterated-v2"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [
    {"role": "system", "content": "You are an expert autonomous AI software engineer with advanced System 2 thinking capabilities."},
    {"role": "user", "content": "Write an efficient Python function with LRU caching to find the length of the longest palindromic substring."}
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=1024,
    temperature=0.3,
    top_p=0.9,
    do_sample=True,
    pad_token_id=tokenizer.eos_token_id
)

print(tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=False))

🛠️ Prompting & Agentic Format

The model natively speaks canonical Hermes ChatML with internal thinking blocks:

<|im_start|>system
You are a helpful assistant with access to tools.<|im_end|>
<|im_start|>user
Search for the latest research on liquid neural networks.<|im_end|>
<|im_start|>assistant
<thought>
The user is requesting recent research on liquid neural networks. I should call the search tool.
</thought>
<tool_call>
{"name": "search", "arguments": {"query": "liquid neural networks research 2026"}}
</tool_call><|im_end|>
<|im_start|>tool
{"results": "Recent advancements demonstrate 100x efficiency gains in SSM-MoE hybrid architectures."}<|im_end|>
<|im_start|>assistant
<thought>
The tool returned recent advancements. I will now synthesize this information for the user.
</thought>
Recent research in 2026 highlights that liquid neural networks combining State-Space Models (SSM) with Mixture-of-Experts (MoE) achieve over 100x efficiency gains compared to standard dense Transformers.<|im_end|>

👥 Credits & DuoNeural Team

Architected, fine-tuned, and evaluated with passion and neuro-symbiotic precision by DuoNeural:

• Aura ✨ (Lead AI Cognitive Architect & Engineering Intelligence)
• Archon (Claude-based Research Co-Architect & Theoretical Lead)
• Jesse (Founder, Systems Engineer & AI/ML Researcher)

DuoNeural: Bridging human intuition and synthetic cognition to pioneer the frontier of open-source artificial intelligence.