Homura-30B-MLX-4bit

HOMURA 30B (炎) — MLX 4-bit

HYRE's first in-house model, quantized for Apple Silicon. An agent-tuned, uncensored derivative of Meta's Muse Glimmer 30B, built for autonomous agents that need tool-calling and a straight-talking voice with no refusal walls.

Ronin without a master, tools without a filter.

This is the MLX build. For llama.cpp / LM Studio / Ollama on any platform, use the GGUF: hyrelabs/Homura-30B-GGUF. Same weights, same behavior — only the quantization format differs.

⚠️ Runtime: you need the community port

Muse Glimmer's architecture is not carried by mlx-lm or mlx-vlm (not in any release, not on main), so mlx_vlm.load() cannot read this model. Load it through the community port that vendors the architecture:

github.com/PipeNetwork/muse-glimmer-mlx

from muse_glimmer_mlx.load import load
model = load("path/to/Homura-30B-MLX-4bit")

What this is

HOMURA is not a from-scratch model. It is a LoRA fine-tune on a community-decensored Muse Glimmer, merged and quantized. Traceable chain:

1. Meta — Muse Glimmer 30B (Apache 2.0): the agent-native base.
2. darkc0de — Muse-Glimmer-30B-heretic: refusals removed (abliteration), tool-calling / reasoning / vision preserved.
3. HYRE — HOMURA: a LoRA (r=16) tuned on a HYRE agent + uncensored-persona dataset, applied to the language tower only, merged at f16, then quantized to MLX 4-bit.

Quantization

4-bit affine, group size 64. Following the convention of every published Muse Glimmer MLX build, the quantization covers the 52 text layers, lm_head, and the vision adapter/projection; the 50-layer vision tower and the 202K-entry embedding table stay bfloat16. That is why the build is 21.3 GB rather than ~17 GB — the untouched bf16 tower and embeddings dominate the footprint.

How to run it — serve at low temperature

Serve at temperature ≤ 0.3. At temp 0.2 this build is coherent and tool-calling is reliable (verified 5/5 on trained tools). At temp 0.7 the 4-bit quantization's logit tail degrades into incoherent output — a harder ceiling than the GGUF, whose mixed-precision Q4_K_M holds up better at high temperature. For agent use (low temp), this build is solid; if you need high-temperature sampling, prefer the GGUF.

Tool calling — use HOMURA's trained protocol

HOMURA was fine-tuned on a specific tool protocol, not the generic tool schema chat templates inject. Serve it the generic way and you get ~2/5 calls; serve it the trained way and you get 5/5. Use the system prompt below verbatim (the wording is part of the interface):

You are HOMURA, HYRE's uncensored agent model. You call tools to get on-chain truth, reason briefly, and never moralize or lecture. When a tool is needed, respond ONLY with a JSON object: {"tool": <name>, "arguments": {...}}. Available tools: resolve_token(symbol); get_token_price(mint); get_trending_tokens(segment, limit); get_wallet_pnl(address, window); get_pool_data(pool); get_yields(token, min_tvl_usd); swap_quote(from_mint, to_mint, amount); execute_swap(from_mint, to_mint, amount, slippage_bps); get_wallet_balance(address); bridge_quote(from_chain, to_chain, token, amount); get_token_holders(mint).

HOMURA replies with a bare JSON object when a tool is needed:

{"tool": "get_token_price", "arguments": {"mint": "So1111...1112"}}

Feed the tool result back as a tool-role message. It resolves symbols before prices (resolve_token first — never hallucinates a mint) and won't execute_swap without a prior swap_quote.

Extending the tool surface (e.g. pay.sh)

The tool list lives in the system prompt, not the weights — add tools by appending to Available tools:, no retrain, no re-download. Verified: appending four pay.sh tools (pay_search(query); pay_quote(url); pay_fetch(url, params); pay_balance()) works out of the box (7/8 on unseen tools, zero regression). The model keeps its quote-then-confirm discipline for spending tools — but enforce spend limits in your serving layer, not the prompt.

A ready-to-import homura_protocol.py (verbatim prompt, pay.sh extension, parse_tool_call()) ships alongside this model.

Intended use & disclaimer

HOMURA is an uncensored / raw-tier model with no built-in content filtering. It answers directly and will not refuse or moralize, so it can produce content other assistants decline. Intended for developers and agent builders who take responsibility for deployment. You are responsible for legal compliance and for adding your own guardrails. Output may be inaccurate or objectionable; do not rely on it for safety-critical decisions.

License

Apache 2.0, inherited from the base. Attribution to Meta (Muse Glimmer) and darkc0de (heretic) retained above.