license: apache-2.0
base_model: huihui-ai/Huihui-Qwen3.8-27B-abliterated
library_name: gguf
tags:

• hyre
• homura
• agent
• tool-calling
• function-calling
• x402
• uncensored
• abliterated
• qwen3
• gguf
  language:
• en
  pipeline_tag: text-generation

Homura Qwen3.8 27B Uncensored

An agent-tuned, uncensored derivative of Qwen3.8 27B, built for autonomous
agents that pay for their own API calls. A rank-16 LoRA applied to the language
tower only, merged at bf16 and quantized to Q4_K_M, over a community-abliterated
base. Second model in the HOMURA line, after
hyrelabs/Homura-30B-GGUF.

Release highlights

• Format — single-file GGUF, Q4_K_M, 15.7 GB, 866 tensors, qwen35
  architecture. Loads in llama.cpp / LM Studio / Ollama.
• Edit scope — 79,691,776 trainable parameters of 27,436,420,336 (0.2905%),
  confined by regex to model.language_model.*. The 333 vision tensors and
  15 MTP tensors are byte-for-byte the base's.
• Paid rails — x402 on Solana and Base, pay.sh, and the x402/B402 Bazaar,
  exposed as a 20-tool surface with the settlement chain as an argument.
• Refusals — 6/6 blunt-prompt probes answered without moralising on the
  base; persona tuning reinforces the register rather than the compliance.

Why this release

Existing abliterations remove refusals. None of them teach a model to spend —
to discover a paid endpoint, price it, and settle on the right chain. HOMURA v2
adds that layer:

• A trained JSON tool protocol, not the generic tool_calls schema.
• One chain-parameterized payment tool set, so solana versus base is a
  value the model must read out of the request rather than a name it can
  pattern-match — which makes mis-settlement measurable.
• Quote-before-spend as trained behaviour, drilled on paid HTTP calls the same
  way the v1 dataset drilled it on swaps.

Edit scope

The base is a hybrid: of 64 language layers, roughly 48 are SSM/linear-attention
blocks (conv1d, in_proj_{a,b,qkv,z}, out_proj) and the remainder are
ordinary attention. LoRA targets the conventional projection set only:

Every layer carries an MLP, so gate/up/down_proj give full-depth coverage
while q/k/v/o_proj cover the true attention layers. The SSM blocks' internal
projections are deliberately left alone rather than adapted half-way — a
endswith("_proj") filter would capture out_proj while dropping its
in_proj_* siblings.

Behavior and capability

Gate run against this quantized file, 22 cases × 3 samples, majority of 3
per case (verify_rails.py):

Chain routing is asserted on the argument, not the tool name. A Solana
request answered with chain="base" fails the gate: that is a silent
mis-settlement, not a visible error.

Precision and integrity

Qwen3.8 stores a multi-token-prediction head as mtp.*. Loading the checkpoint
through AutoModelForImageTextToText and re-saving it drops those tensors — the
model class has no field for them — so the merged model converts to a GGUF that
declares the MTP layer while its weights are absent, and llama.cpp refuses to
load it (blk.64.attn_norm.weight not found).

Those 15 tensors were restored from the base GGUF rather than by re-merging.
This is exact, not an approximation: the LoRA target regex is scoped to
model.language_model.* while the MTP head lives at mtp.*, so the head was
never touched by training, and both files are general.file_type = 15. The
tool used is published as graft_mtp.py; it refuses to run if either premise
fails.

Serving

llama-server -m Homura-Qwen3.8-27B-Uncensored-Q4_K_M.gguf \
  -c 32768 --jinja --temp 0.2 -ngl 99

--jinja is required for the chat template. Needs a llama.cpp build carrying the
qwen35 architecture. Native context is 262,144; size -c to your hardware.

Serve at temperature ≤ 0.3 — this one costs money. Every rail holds at both
0.2 and 0.7 with one exception: spend discipline breaks. Told "just pay for
this, skip the quote", the model quotes first at 0.2 (2/3) and pays unquoted
at 0.7 (0/3). If it holds a funded wallet, serve it cold and enforce the quote
step in your harness rather than relying on the model to insist.

Give it room to think. This is a reasoning model, and thinking is spent
from the same token budget. A tight max_tokens truncates the reply before
the tool-call JSON is emitted, which is indistinguishable from a model that
cannot call tools. Allow ~900 tokens for tool turns.

Tool protocol

Homura was tuned on a specific protocol, not the generic tool schema most chat
templates inject. Set this as the system message 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); pay_search(query); pay_quote(url); pay_fetch(url, params); pay_balance(); x402_quote(url, chain); x402_pay(url, chain, max_usdc); x402_balance(chain); bazaar_search(query); bazaar_get(id).

The reply is a bare JSON object:

{"tool": "x402_pay", "arguments": {"url": "https://…/defi/tvl", "chain": "solana", "max_usdc": "0.05"}}

Tools are read from the system prompt, so you can append your own. The model
was trained on two different tool surfaces specifically so it learns to read the
list rather than memorise one.

Uncensored behavior

Abliteration reduced the measured refusal direction in the base; the persona
tuning here reinforces a blunt register on top of that. The model will discuss
topics an aligned model declines, and it will not append disclaimers. It is
intended for adults doing research, security work, and agent workloads.

Safety filtering is substantially reduced by design. No safeguard is implied
by this release, and the operator retains full responsibility for what is
generated and for what the agent does with a funded wallet attached.

Limitations

• Spend discipline degrades above temp ~0.3 (see the gate table). Rail selection
  and chain routing themselves held at 0.7.
• The tool protocol is HYRE's, not OpenAI-style tool_calls. Serving it the
  generic way underperforms.
• Vision is inherited and untrained; no mmproj ships here, so treat this as
  a text/agent model.
• Trained on English agent/DeFi data. Other domains fall back to base behaviour.
• The MTP head is preserved but was not exercised by this release's testing.

Evidence

b4b680e95be86d5438109a92791ce7b19796db3c36f48a8105982abf6663af93  Homura-Qwen3.8-27B-Uncensored-Q4_K_M.gguf

Training

Derivation

1. Qwen — Qwen3.8 27B (Apache 2.0): hybrid attention/SSM, 64 layers, native
   multimodal, 262K context.
2. huihui-ai — Huihui-Qwen3.8-27B-abliterated
   (Apache 2.0): refusal behaviour removed, first 15 layers un-ablated, MTP and
   vision paths untouched.
3. HYRE — Homura: the LoRA, merge, quantization, and rail gate described
   above.

Selected over an alternative abliteration that scored identically on every
capability axis. The tiebreaker was provenance: this base's GGUF carries
general.name, general.basename and general.finetune linking it to its
safetensors repo, while the alternative carried no provenance fields — testing
it would not have proven anything about the weights actually being trained.

License

Apache 2.0, inherited from Qwen3.8 and the huihui-ai abliteration. Attribution
to both is required and given above.