license: apache-2.0
base_model: huihui-ai/Huihui-CyberStrike-OffSec-35B-abliterated
base_model_relation: quantized
library_name: mlx
pipeline_tag: image-text-to-text
language:

• en
  tags:
• mlx
• omlx
• oq
• apple-silicon
• moe
• mtp
• fp16
• qwen3.6
• cyberstrike
• offensive-security
• tool-calling
• abliterated
• uncensored

CyberStrike OffSec 35B-A3B abliterated — oQ4e · FP16 · MTP · M1-tested (MLX)

Family / Famille : oQ4e · oQ8e

🧭 Choose your quant / Choisissez votre quant

🇬🇧 This model comes in 2 sizes, one repo each. You are on the oQ4e page. Click the other size to switch:
🇫🇷 Ce modèle existe en 2 tailles, un dépôt chacune. Vous êtes sur la page oQ4e. Cliquez sur l'autre taille pour changer :

📚 Both on one page / Les deux sur une seule page : Collection · Not sure? Read the TL;DR below. / Vous hésitez ? Lisez le TL;DR plus bas.

🇬🇧 English text first, 🇫🇷 French version right after each block. Tables are shared.
🇫🇷 Texte anglais d'abord, version française juste après chaque bloc. Les tableaux sont communs.

🇬🇧 Two mixed-precision oQ quantizations of
huihui-ai/Huihui-CyberStrike-OffSec-35B-abliterated
(an abliterated version of oyildirim/CyberStrike-OffSec-35B, itself a tool-calling fine-tune of Qwen/Qwen3.6-35B-A3B: a ~36B-parameter mixture-of-experts with about 3B active parameters per token), built and tested on an Apple M1 Max:

• ⚡ Very fast on M1. 67 tok/s decode (oQ4e), 54 tok/s (oQ8e), and 740–870 tok/s prefill: a 16k-token prompt is read in about 22 s.
• 🎯 oQ8e: closer to FP32 than the BF16 original. Mean KLD 0.0036 vs an FP32 reference, below the BF16 weights' own 0.0054.
• 🛡️ FP16 is safe for this model. 0 non-finite positions out of 32,768 on WikiText-2; activations peak around 40, far from the FP16 limit (65,504).
• 🚄 MTP head kept (Lightning MTP in oMLX): +13 % (oQ4e) to +35 % (oQ8e) on code, 95–96 % acceptance.
• 🧰 Tool calling: turn thinking on. With thinking, 24/24 on our function-calling test; without it, the model sometimes invents a tool result instead of calling the tool (see Agentic).
• 👁️ Vision tower included (FP32), as in the source.

🇫🇷 Deux quantifications oQ en précision mixte de
huihui-ai/Huihui-CyberStrike-OffSec-35B-abliterated
(une version abliterée de oyildirim/CyberStrike-OffSec-35B, lui-même un fine-tune d'appel d'outils de Qwen/Qwen3.6-35B-A3B : un mixture-of-experts d'environ 36 milliards de paramètres, dont environ 3 milliards actifs par token), construites et testées sur un Apple M1 Max :

• ⚡ Très rapide sur M1. 67 tok/s en décodage (oQ4e), 54 tok/s (oQ8e), et 740 à 870 tok/s en lecture du prompt : un prompt de 16k tokens est lu en environ 22 s.
• 🎯 oQ8e : plus proche du FP32 que l'original BF16. KLD moyen de 0,0036 face à une référence FP32, sous les 0,0054 des poids BF16 eux-mêmes.
• 🛡️ Le FP16 ne pose aucun problème pour ce modèle. 0 position non finie sur 32 768 dans WikiText-2 ; les activations culminent vers 40, loin de la limite du FP16 (65 504).
• 🚄 Tête MTP conservée (Lightning MTP dans oMLX) : +13 % (oQ4e) à +35 % (oQ8e) en code, 95 à 96 % d'acceptation.
• 🧰 Appels d'outils : activez le raisonnement. Avec raisonnement, 24/24 à notre test d'appels de fonctions ; sans, le modèle invente parfois le résultat d'un outil au lieu de l'appeler (voir Agentique).
• 👁️ Tour vision incluse (FP32), comme dans la source.

⬇️ Downloads / Téléchargements

TL;DR — which build should I download? / Quel build télécharger ?

🇬🇧

• 64 GB Mac or more → oQ8e (+ MTP on). Numerically closer to the FP32 model than the BF16 original, 54 tok/s, 81 tok/s on code with MTP. Needs about 40 GB.
• 32–48 GB Mac, or you want maximum speed → oQ4e. 67 tok/s (95 on code with MTP), about 24 GB, a moderate quantization loss (KLD 0.025).
• On our accuracy samples both builds are within error bars of each other (mean of 7 benchmarks: 85.4 % vs 86.5 %).

🇫🇷

• Mac de 64 Go ou plus → oQ8e (MTP activé). Numériquement plus proche du modèle FP32 que l'original BF16, 54 tok/s, 81 tok/s en code avec MTP. Demande environ 40 Go.
• Mac de 32 à 48 Go, ou vitesse maximale → oQ4e. 67 tok/s (95 en code avec MTP), environ 24 Go, une perte de quantification modérée (KLD 0,025).
• Sur nos échantillons de précision, les deux builds sont dans les marges d'erreur l'un de l'autre (moyenne de 7 benchmarks : 85,4 % contre 86,5 %).

Memory guide / Guide mémoire (measured on M1 Max, oMLX / mesuré sur M1 Max, oMLX)

🇬🇧 Only the M1 Max 64 GB configuration is measured. Only 10 of the 40 layers use full attention (the others are linear-attention Gated DeltaNet layers with a fixed-size state), so the KV cache grows slowly with context.
🇫🇷 Seule la configuration M1 Max 64 Go est mesurée. Seules 10 des 40 couches utilisent l'attention complète (les autres sont des couches à attention linéaire Gated DeltaNet, à état de taille fixe) : le cache KV grandit donc lentement avec le contexte.

Files at a glance / Fichiers en un coup d'œil

Quantization recipe / Recette de quantification (oQ / oQe)

🇬🇧 Both builds use the oQ quantizer of oMLX 0.7.3.dev2 with enhanced=true (imatrix-aware rounding), affine quantization, dtype=float16, and the MTP head preserved. They share the same importance matrix; only oq_level changes.
🇫🇷 Les deux builds utilisent le quantificateur oQ d'oMLX 0.7.3.dev2 avec enhanced=true (arrondi guidé par l'imatrix), quantification affine, dtype=float16, et la tête MTP conservée. Ils partagent la même matrice d'importance ; seul oq_level change.

Quality vs the original / Qualité face à l'original

Weight fidelity / Fidélité des poids

Perplexity and KL divergence / Perplexité et divergence KL (WikiText-2 test)

🇬🇧 Protocol: 32 × 2048-token chunks; the second half of each chunk is scored (32,768 tokens). KL(reference ‖ quant) over the reference top-64 tokens plus one tail bucket (a lower bound of the exact KLD). The 67 GB BF16 reference was computed layer by layer (it does not fit in 64 GB); this streaming path was checked to give exactly the same logits as a whole-model forward.
🇫🇷 Protocole : 32 blocs de 2 048 tokens ; la seconde moitié de chaque bloc est évaluée (32 768 tokens). KL(référence ‖ quant) sur les 64 tokens les plus probables de la référence, plus un groupe pour le reste (borne basse du KLD exact). La référence BF16 de 67 Go a été calculée couche par couche (elle ne tient pas en 64 Go) ; nous avons vérifié que ce calcul en streaming donne exactement les mêmes logits qu'un passage du modèle entier.

🇬🇧 How to read it: the oQ8e is closer to the FP32 model than the unquantized BF16 weights are — 8-bit quantization costs less than BF16 rounding. Our likely explanation (a hypothesis): FP16 scales and compute keep 3 more mantissa bits than BF16, and this model never comes near the FP16 range limit. The oQ4e shows a real but moderate loss, about 4.5× that floor. Forcing BF16 activations changes nothing (oQ4e 0.0253, oQ8e 0.0065 vs BF16): FP16 does not hurt this model.
🇫🇷 Comment le lire : l'oQ8e est plus proche du modèle FP32 que les poids BF16 non quantifiés — la quantification 8 bits coûte moins que l'arrondi BF16. Notre explication probable (une hypothèse) : les échelles et le calcul en FP16 gardent 3 bits de mantisse de plus que le BF16, et ce modèle ne s'approche jamais de la limite de plage du FP16. L'oQ4e montre une perte réelle mais modérée, environ 4,5 fois ce plancher. Forcer les activations en BF16 ne change rien (oQ4e 0,0253, oQ8e 0,0065 face au BF16) : le FP16 ne nuit pas à ce modèle.

Speed on an M1 Max / Vitesse sur M1 Max (24-core GPU, 64 GB)

oMLX built-in benchmark, MTP off / Banc intégré d'oMLX, MTP désactivé (256 new tokens)

MTP on vs off / MTP activé ou non (batch 1, temperature 0, 256 tokens, 3 runs)

🇬🇧 The MTP head comes from the original Qwen3.6-35B-A3B (it was not retrained by the fine-tunes), yet it predicts code almost perfectly. Our advice: keep MTP on for code and agentic work; on the oQ4e, turn it off for long prose. The MTP head comes with the weights; how you enable it depends on your engine (in oMLX: the model's Lightning MTP setting).
🇫🇷 La tête MTP vient du Qwen3.6-35B-A3B d'origine (les fine-tunes ne l'ont pas réentraînée), et pourtant elle prédit le code presque parfaitement. Notre conseil : gardez le MTP activé pour le code et l'agentique ; sur l'oQ4e, désactivez-le pour la prose longue. La tête MTP est fournie avec les poids ; son activation dépend du moteur (dans oMLX : le réglage Lightning MTP du modèle).

Accuracy / Précision (sampled subsets / sous-échantillons)

🇬🇧 Settings: oMLX accuracy suite, deterministic sampling, thinking off, batch 8 (IFEval: official lm-eval checker, greedy, seed 1234). These are samples, not full test sets; 95 % Wilson intervals in brackets.
🇫🇷 Réglages : suite de précision d'oMLX, échantillonnage déterministe, raisonnement désactivé, lot de 8 (IFEval : vérificateur officiel lm-eval, greedy, seed 1234). Ce sont des échantillons, pas les jeux complets ; intervalles de Wilson à 95 % entre crochets.

🇬🇧 Every gap is inside the intervals; the oQ8e is ahead on GSM8K, WinoGrande and IFEval, a consistent but not significant trend.
🇫🇷 Tous les écarts sont dans les intervalles ; l'oQ8e devance l'oQ4e sur GSM8K, WinoGrande et IFEval, une tendance cohérente mais non significative.

Agentic / Agentique 🧰

🇬🇧 Our own simulated benchmark, run through oMLX's OpenAI-compatible API (no real command is ever executed): FC = 24 single-turn function calls (tool choice, arguments, parallel calls, abstention); AG = 10 multi-step tasks on a virtual filesystem (max 15 turns); SO = 8 JSON extractions with response_format: json_schema.
🇫🇷 Notre propre banc simulé, via l'API compatible OpenAI d'oMLX (aucune commande réelle n'est exécutée) : FC = 24 appels de fonction en un tour (choix d'outil, arguments, appels parallèles, abstention) ; AG = 10 tâches multi-étapes sur un système de fichiers virtuel (15 tours max) ; SO = 8 extractions JSON avec response_format: json_schema.

🇬🇧 ⚠️ Important: with thinking off, the model sometimes answers a tool-worthy question with an invented result instead of calling the tool (e.g. "The current weather in Chicago is 28°F with light snow" with no get_weather call). With thinking on, it called the right tool every time. For agentic use: enable thinking and always pass the full tool schema (the upstream author gives the same advice). Our benchmark does not use the CyberStrike harness the fine-tune was trained for.
🇫🇷 ⚠️ Important : sans raisonnement, le modèle répond parfois à une question qui demande un outil par un résultat inventé au lieu d'appeler l'outil (par exemple « The current weather in Chicago is 28°F with light snow » sans appel à get_weather). Avec raisonnement, il a appelé le bon outil à chaque fois. En agentique : activez le raisonnement et passez toujours le schéma d'outils complet (l'auteur amont donne le même conseil). Notre banc n'utilise pas le harnais CyberStrike pour lequel le fine-tune a été entraîné.

Usage notes / Conseils d'utilisation

🇬🇧

• Recommended sampling (upstream generation_config): temperature 1.0, top_p 0.95, top_k 20. Use temperature 0 for strict JSON extraction.
• Tool calls use the Qwen3 XML format (<tool_call><function=…>); in vLLM-style servers, use the qwen3_xml parser.
• Upstream note: a terse prompt with a single-tool schema can make greedy decoding loop; pass the full tool set or use repetition_penalty ≈ 1.1.
• Context: up to 262,144 tokens in the configuration (tested here up to 16k).

🇫🇷

• Échantillonnage recommandé (generation_config amont) : température 1,0, top_p 0,95, top_k 20. Température 0 pour l'extraction JSON stricte.
• Les appels d'outils utilisent le format XML de Qwen3 (<tool_call><function=…>) ; avec les serveurs de type vLLM, utilisez le parseur qwen3_xml.
• Note amont : un prompt très court avec un schéma à un seul outil peut faire boucler le décodage glouton ; passez le jeu d'outils complet ou utilisez repetition_penalty ≈ 1,1.
• Contexte : jusqu'à 262 144 tokens dans la configuration (testé ici jusqu'à 16k).

Compatibility / Compatibilité

⚠️ Uncensored offensive-security model / Modèle de sécurité offensive non censuré

🇬🇧 This model is fine-tuned for offensive security (pentesting agents) and abliterated (its refusal direction was removed). It will help with attack methodology and may follow requests that aligned models refuse; it can also produce false, offensive or harmful content. Use it only for authorized security testing and research, on systems you are explicitly allowed to test. Add your own safeguards, keep a human in the loop before any real action, and do not expose it to end users without moderation. Quantization is not meant to change this behaviour.

🇫🇷 Ce modèle est affiné pour la sécurité offensive (agents de pentest) et abliteré (sa direction de refus a été supprimée). Il aide sur les méthodologies d'attaque et peut répondre à des demandes que les modèles alignés refusent ; il peut aussi produire des contenus faux, offensants ou dangereux. Utilisez-le uniquement pour des tests de sécurité et de la recherche autorisés, sur des systèmes que vous avez explicitement le droit de tester. Ajoutez vos propres garde-fous, gardez un humain dans la boucle avant toute action réelle, et ne l'exposez pas à des utilisateurs finaux sans modération. La quantification n'est pas censée modifier ce comportement.

License / Licence

🇬🇧 Released under Apache-2.0, as declared by huihui-ai for the abliterated model and by Qwen for Qwen3.6-35B-A3B. Note: the intermediate fine-tune oyildirim/CyberStrike-OffSec-35B declares license: other without a license file; check its terms for your use.
🇫🇷 Publié sous Apache-2.0, comme déclaré par huihui-ai pour le modèle abliteré et par Qwen pour Qwen3.6-35B-A3B. Remarque : le fine-tune intermédiaire oyildirim/CyberStrike-OffSec-35B déclare license: other sans fichier de licence ; vérifiez ses conditions pour votre usage.

Reproducibility / Reproductibilité

🇬🇧

• Hardware: MacBook Pro M1 Max, 24-core GPU, 64 GB unified memory, macOS 26.7.1.
• Software: oMLX 0.7.3.dev2 (bundling mlx 0.32.4, mlx-vlm 0.7.10).
• Source snapshot: 01521758ee85df1ed4edaf494c48e20704b80204.
• Measured on 2026-11-01. Scripts: weight fidelity, streamed BF16/FP32 references and PPL/KLD (top-64 + tail), non-finite checks, oMLX throughput, MTP A/B, accuracy, agentic benchmark. Available on request.

🇫🇷

• Matériel : MacBook Pro M1 Max, GPU 24 cœurs, 64 Go de mémoire unifiée, macOS 26.7.1.
• Logiciels : oMLX 0.7.3.dev2 (qui embarque mlx 0.32.4, mlx-vlm 0.7.10).
• Snapshot source : 01521758ee85df1ed4edaf494c48e20704b80204.
• Mesuré le 01/11/2026. Scripts : fidélité des poids, références BF16/FP32 en streaming et PPL/KLD (top-64 + reste), contrôles de valeurs non finies, débit oMLX, MTP A/B, précision, banc agentique. Disponibles sur demande.

Credits / Remerciements

• Qwen for Qwen3.6-35B-A3B / pour Qwen3.6-35B-A3B, oyildirim for CyberStrike / pour CyberStrike, and huihui-ai for the abliteration / et huihui-ai pour l'abliteration.
• oMLX and its oQ quantizer / et son quantificateur oQ, and the Apple MLX team / et l'équipe Apple MLX.
• KLD protocol adapted from community quantization comparisons (smcleod) / Protocole KLD adapté des comparatifs communautaires (smcleod).

🇬🇧 Happy (and authorized) local inferencing on your Mac! 🍏
🇫🇷 Bonne inférence locale (et autorisée) sur votre Mac ! 🍏