Instructions to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Build from source code

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-app
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama serve -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama cli -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Use Docker

docker model run hf.co/pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Llama new
LM Studio
Jan

vLLM

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

SGLang

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with Ollama:
```
ollama run hf.co/pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M
```
Unsloth Desktop

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with Docker Model Runner:
```
docker model run hf.co/pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M
```

Lemonade

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Run and chat with the model

lemonade run user.MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF-Q4_K_M

List all available models

lemonade list

Hermes Agent

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF:Q4_K_M" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

Access is granted only to my Patreon Supporters

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Access to this release is reserved exclusively for active supporters on Patreon. Direct requests sent via this native form are not processed manually. To unlock instant repository access, join via https://www.patreon.com/pragmaticcs

Exclusive Model Access

This model repository is available exclusively to my Pro Patreon Members.

Become my Pro Patreon Member:

Navigate to this Patreon model post containing a secret link to a form.

Input your Hugging Face username into the form to unlock access instantly to this repo and download model weights.

Direct requests submitted through the native Hugging Face form above are NOT approved manually. Access is granted ONLY through an active Patreon subscription.

This repository provides quantized GGUF builds of pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B

Most 9B reasoning models have an annoying flaw: they burn thousands of tokens second-guessing themselves before writing a single line of functional code.

Ask them for a complex web interface or an autonomous terminal command, and they get trapped in recursive chain-of-thought loops, debating non-existent edge cases, re-checking basic syntax, only to eventually run out of context.

MiMo-HERO-Frontier-Agentic-Coder-9B eliminates this overthinking trap.

The model is a targeted surgical graft that fuses two complementary specializations on the Qwen 3.5 9B architecture:

XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B (The Brain): High-density algorithmic reasoning, deep syntax comprehension, and complex architectural synthesis.
XLearning-SCU/HERO-9B (The Antidote): An RL-trained execution policy designed specifically to minimize token waste, bypass hesitation loops, and prioritize immediate action.

By grafting HERO's high-efficiency decision vectors directly into MiMo's reasoning core, the model cures MiMo's tendency to go into thinking loops unlocking its real potential.

The result is a fast, disciplined and extremely capable local workhorse that excels at frontend/UI design and website creation while .

Live One-Shot Demo 🎯

As a stress test, I asked the model (running locally on my machine at Q5_K_M quantization in Unsloth Desktop) to one-shot a full landing page with the following minimal prompt:

Prompt:
"Create a one-file landing page website with HTML, CSS and JavaScript that sells a premium Japanese water bottle."

No web search, no tool-calls and no additional system prompts were used during this test, to fairly benchmark the raw model output. This way, the model had to come up with the design, style, contents and functionality of the page all on its own.

You can check out the landing page generated by the model by visiting the link below (the page is hosted via a Hugging Face static space):

Technical Specifications
Mathematical Formulation: Subspace-Guarded Grafting
Subsystem Protection Policies
Chat Template & Agentic Protocol
Recommended Generation Parameters
Inference and Deployment
Unlocking Model Access
Citation & References

Technical Specifications

Parameter	Specification
Total Base Parameters	8.9B (Vision tower preserved; Multi-Token Prediction excised)
Foundation Architecture	Hybrid Recurrent-Attention Causal LM (`Qwen3_5ForCausalLM`)
Recurrent Topology	Gated DeltaNet linear-attention layers interleaved with standard attention
Attention Configuration	Grouped-Query Attention (GQA) with YaRN RoPE scaling
Context Window	262,144 tokens native
Native Precision	`bfloat16`
Primary Capabilities	Agentic coding and software engineering

Mathematical Formulation: Subspace-Guarded Grafting

Direct linear blending, spherical interpolation (SLERP), and uniform DARE perturbations degrade hybrid DeltaNet networks. Linear attention recurrence relies on strictly contractive transition states; arbitrary parameter shifts introduce runaway eigenvalues that destroy long-range memory and break special control tokens.

To prevent degradation, the parameter integration is governed by non-interfering geometric constraints.

1. Delta Task Disentanglement

Let W₀ denote the underlying base model parameters (Qwen3.5-9B), W_MiMo the primary anchor, and W_HERO the donor. The task vectors are defined as:

$\Delta_{\text{MiMo}} = W_{\text{MiMo}} - W_{0}$

$\Delta_{\text{HERO}} = W_{\text{HERO}} - W_{0}$

2. Spectrally Tapered Bi-Subspace Guard

To guarantee that HERO does not overwrite the fundamental representations discovered during MiMo's distillation, HERO's update is projected orthogonally away from the dominant singular directions of MiMo's task vector.

For any weight matrix with singular value decomposition:

$\Delta_{\text{MiMo}} \approx U_k \Sigma_k V_k^T$

The overlapping projection tensor is computed across rank k = 32 and tapered according to spectral energy:

$\Omega = \left(\frac{\operatorname{diag}(\Sigma_k)}{\tau}\right)^2$

$\Delta_{\text{HERO}}^{\perp} = \Delta_{\text{HERO}} - U_k \left( \Omega \odot (U_k^T \Delta_{\text{HERO}} V_k) \right) V_k^T$

Components of the agentic donor that directly compete with MiMo's primary singular subspace are eliminated, allowing new procedural capabilities to occupy unutilized parameter dimensions.

3. Sign Consensus Damping

When fine-tuning objectives pull individual weights in opposite directions, blind averaging causes catastrophic cancellation and syntax corruption. For coordinates where updates conflict:

$\operatorname{sign}\left(\Delta_{\text{MiMo}}^{(i, j)}\right) \neq \operatorname{sign}\left(\Delta_{\text{HERO}}^{\perp (i, j)}\right)$

An antagonistic penalty coefficient $\Phi$ is evaluated against relative weight salience:

$\Phi_{(i, j)} = 1.0 - 0.50 \cdot \left( \frac{|\Delta_{\text{MiMo}}^{(i, j)}|}{|\Delta_{\text{MiMo}}^{(i, j)}| + |\Delta_{\text{HERO}}^{\perp (i, j)}| + \epsilon} \right)$

$\widetilde{\Delta}_{\text{HERO}}^{(i, j)} = \Phi_{(i, j)} \cdot \Delta_{\text{HERO}}^{\perp (i, j)}$

Antagonistic donor noise is suppressed, ensuring that settled code generation rules are never inverted.

4. DARE Energy-Preserved Trimming

To eliminate low-magnitude parameter drift, the bottom 4% energy of the sanitized update is zeroed out. The surviving parameters are rescaled by the inverse square root of the retained energy ratio to preserve exact variance:

$\widehat{\Delta}_{\text{HERO}} = \operatorname{Mask}\left(\widetilde{\Delta}_{\text{HERO}}, \, p=0.96\right) \cdot \sqrt{\frac{1.0}{0.96}}$

5. Bell-Plateau Depth Routing

Layer-wise integration follows a smooth transition profile across the network's depth index l over total layers L:

$g(l) = \begin{cases} 0.50 + 0.50 \cdot S\left(\frac{l}{0.20 L}\right) & 0 \le l < 0.20 L \\ 1.00 & 0.20 L \le l \le 0.80 L \\ 1.00 - 0.30 \cdot S\left(\frac{l - 0.80 L}{0.20 L}\right) & 0.80 L < l \le L \end{cases}$

where S(t) represents the smooth cubic step function:

$S (t) = 3 t^{2} - 2 t^{3}$

Early Layers (0% to 20%): Lower graft gain (0.50) safeguards token embeddings and initial sensory projections.
Mid Layers (20% to 80%): Full-strength injection (1.00) transforms core reasoning and planning pathways.
Late Layers (80% to 100%): Scaled down (0.70) to protect tool-call formatting, stopping tokens, and output logits.

6. Dual Trust Region Clamping

To prevent distribution collapse, the effective step size is bound simultaneously by Frobenius norm ratio $\rho$ and spectral radius $\sigma_{\max}$:

$s = \min\left( s_{\max}, \; \rho \cdot \frac{\|\Delta_{\text{MiMo}}\|_F}{\|\widehat{\Delta}_{\text{HERO}}\|_F}, \; \kappa \cdot \frac{\sigma_{\max}(\Delta_{\text{MiMo}})}{\sigma_{\max}(\widehat{\Delta}_{\text{HERO}})} \right)$

Final parameter state:

$W_{\text{final}} = W_{\text{MiMo}} + \big(s \cdot g(l)\big) \cdot \widehat{\Delta}_{\text{HERO}}$

Subsystem Protection Policies

Subsystem	Target Tensors	Policy	Objective
Embeddings & Heads	`embed_tokens`, `lm_head`	Strict Anchor Lock	Prevents vocabulary misalignment and maintains exact output logit distribution.
Vision Subsystem	`visual.*`	Preserved Intact	Keeps multimodal parsing and visual document understanding fully functional.
Recurrent Core	`linear_attn.*`	Conservative Gain (0.80)	Protects Gated DeltaNet state-space stability across 128k context steps.
Attention Routing	`self_attn.q_proj`, `k_proj`	Attenuated Gain (0.85)	Prevents attention-head defocusing during long-sequence tool tracking.
Value & Projections	`self_attn.v_proj`, `o_proj`	Elevated Gain (0.95)	Facilitates smooth transfer of semantic agentic representations.
MLP Blocks	`mlp.down_proj`, `up_proj`	Full Strength (1.00)	Maximizes transfer of practical code implementation heuristics.
Outlier Coordinates	\|W\| > 8 · rms(W)	Coordinate Shield	Protects critical emergent outlier features from perturbation.

Chat Template & Agentic Protocol

This model integrates the Improved Chat Template for Qwen 3.x directly into its tokenizer configuration and Jinja runtime environment.

Protocol Highlights

Multi-Tier Chain-of-Thought Control: Isolates internal reasoning paths within explicit <thought>...</thought> delimiters prior to tool calling or terminal emission.
Dual Tool Schemas: Fully supports both JSON-RPC function payloads and structured XML tool execution tags, enabling zero-shot integration with platforms like Browser-Use, OpenHands, and native agent loops.
Anti-Repetition Circuit Breaker: Suppresses cyclical generation traps when linters, compilers, or shell environments return non-zero exit codes.
Strict Whitespace & Prompt Hygiene: Eliminates redundant framing tokens, conserving the active context budget for long-sequence programming and multi-turn debugging.

Recommended Generation Parameters

For repository-level software engineering, bug localization, and automated tool use:

Parameter	Recommended Value	Description
Temperature	`0.6`	Balances strict syntactic validity with algorithmic path exploration.
Top-P	`0.95`	Eliminates low-probability token tails while preserving alternative logic paths.
Top-K	`20`	Restricts token candidate pools to prevent architectural syntax drift.
Min-P	`0.0` (Off)	Disabled in favor of explicit Top-K / Top-P governance.
Repetition Penalty	`1.0` (Off)	Disabled to prevent syntax degradation in repetitive code patterns (indentation, braces).
Presence Penalty	`0.0`	Prevents naming mutations across long-context symbol resolution.

Inference and Deployment

Serving via vLLM

Thanks to the excision of multi-token prediction layers, the model deploys natively without custom engine flags:

vllm serve pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B \
  --dtype bfloat16 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90 \
  --enable-auto-tool-choice \
  --tool-call-parser hermes \
  --enable-reasoning \
  --reasoning-parser qwen3

Serving via SGLang

python -m sglang.launch_server \
  --model-path pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B \
  --port 30000 \
  --host 0.0.0.0 \
  --context-length 32768

Python API Execution

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B"

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

conversation = [
    {
        "role": "user",
        "content": "Create a beautiful one-file landing page for a travel agency using HTML, CSS and JavaScript.",
    },
]

inputs = tokenizer.apply_chat_template(
    conversation, add_generation_prompt=True, enable_thinking=True, return_tensors="pt"
).to(model.device)

outputs = model.generate(
    inputs, max_new_tokens=65536, temperature=0.6, top_p=0.95, top_k=20, do_sample=True
)

response = tokenizer.decode(outputs[0][inputs.shape[-1] :], skip_special_tokens=True)
print(response)

Citation & References

@article{yu2024dare,
  title={Language Models are Super Mario: Absorbing Abilities from Homologous Models as a Free Lunch},
  author={Yu, Le and Yu, Bowman and Yu, Haiyang and Huang, Fei and Li, Yongbin},
  journal={arXiv preprint arXiv:2311.03099},
  year={2023}
}

@inproceedings{yadav2023ties,
  title={Resolving Interference When Merging Models},
  author={Yadav, Prateek and Tam, Derek and Choshen, Leshem and Raffel, Colin and Bansal, Mohit},
  booktitle={Advances in Neural Information Processing Systems (NeurIPS)},
  volume={36},
  pages={7093--7115},
  year={2023}
}

@article{yang2024deltanet,
  title={Gated Delta Networks: Improving Mamba2 with Delta Rule for Linear Recurrent Attention},
  author={Yang, Songlin and Wang, Bailin and Shen, Yikang and Panda, Rameswar and Kim, Yoon},
  journal={arXiv preprint arXiv:2412.06464},
  year={2024}
}

Downloads last month: -

GGUF

Model size

9B params

Architecture

qwen35

Hardware compatibility

4-bit

5-bit

6-bit

8-bit

Model tree for pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

Qwen/Qwen3.5-9B

XLearning-SCU/HERO-9B

XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B

Merge model

this model

Space using pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF 1

Collection including pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

MiMo-HERO-Frontier-Agentic-Coder-9B

Collection

9B merge of MiMo-V2.6-Distill and HERO delivering frontier intelligence on consumer hardware • 2 items • Updated 6 days ago

Papers for pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

Gated Delta Networks: Improving Mamba2 with Delta Rule

Paper • 2412.06464 • Published Dec 9, 2024 • 16

Language Models are Super Mario: Absorbing Abilities from Homologous Models as a Free Lunch

Paper • 2311.03099 • Published Nov 6, 2023 • 38

pragmaticcs
/

MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

Access is granted only to my Patreon Supporters

Exclusive Model Access

Live One-Shot Demo 🎯

Contents

Technical Specifications

Mathematical Formulation: Subspace-Guarded Grafting

1. Delta Task Disentanglement

2. Spectrally Tapered Bi-Subspace Guard

3. Sign Consensus Damping

4. DARE Energy-Preserved Trimming

5. Bell-Plateau Depth Routing

6. Dual Trust Region Clamping

Subsystem Protection Policies

Chat Template & Agentic Protocol

Protocol Highlights

Recommended Generation Parameters

Inference and Deployment

Serving via vLLM

Serving via SGLang

Python API Execution

Citation & References

Model tree for pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

Space using pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF 1

Collection including pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

MiMo-HERO-Frontier-Agentic-Coder-9B

Papers for pragmaticcs/MiMo-HERO-Frontier-Agentic-Coder-9B-GGUF

Gated Delta Networks: Improving Mamba2 with Delta Rule

Language Models are Super Mario: Absorbing Abilities from Homologous Models as a Free Lunch