crane-next-80b

crane-next-80b is a CRANE merge: it is produced by merging two Qwen3-Next-80B-A3B checkpoints (an Instruct base and a Thinking donor) with the CRANE method — it is not trained or fine-tuned from scratch. CRANE (Constrained Reasoning Injection for Code Agents via Nullspace Editing) injects reasoning ability from the Thinking donor into the tool-disciplined Instruct / code base while preserving the base model's output format and tool-calling behavior.

Project page: https://rpi-nsl.github.io/CRANE/ · Code: github.com/rpi-nsl/CRANE

Note: this is the CRANE weight-merging method for code agents. It is unrelated to the similarly-named "CRANE: Reasoning with constrained LLM generation" (arXiv 2502.09061), despite the shared acronym.

How it was made (CRANE)

CRANE is a training-free, parameter-editing weight merge that injects reasoning ability from a "Thinking" donor into a tool-disciplined Instruct / code base, while constraining the edit so the base model's output format and tool-calling behavior are preserved. It treats the Thinking − Instruct delta δ=θthink​−θinst​ as a pool of candidate reasoning edits, and applies three composable stages per layer l and parameter component c:

θmerged(l,c)​=θinst(l,c)​+Stage 3Πτ,q(l,c)GSP​​​(α⋅Stage 2SCTG​(c,l)​​⋅Stage 1T(δ(l,c))​​)

👁 CRANE / GSP merge pipeline

Three small calibration sets drive the stages — DR​ (reasoning transfer), DA​ (agent-behavior / tool-use preservation), and DF​ (format preservation):

• Stage 1 — Magnitude thresholding T(δ). A deterministic median-magnitude threshold keeps only the larger (top-half) delta coordinates and rescales them by 2, discarding low-confidence noise.
• Stage 2 — Conservative Taylor Gate SCTG​. From a signed, direction-aware score sK​(j)=−gK,j​δj​ per calibration loss, CTG keeps the positive part of the per-coordinate minimum over the reasoning and agent-behavior objectives, pj​=[min{sR​(j),sA​(j)}]+​ — rewarding a coordinate only when the edit helps both. These aggregate into the per-component, per-layer coefficient SCTG​(c,l), scaled by the single global merge strength α.
• Stage 3 — Graduated Sigmoidal Projection (GSP). From the SVD of format-critical Instruct activations Hq​=Uq​Σq​Vq⊤​, a smooth sigmoidal weight wq​ (set by singular amplitude and threshold τ) gives the projector Πτ,qGSP​(Δq​)=Δq​−Δq​Vq​diag(wq​)Vq⊤​, attenuating high-amplitude format directions so reasoning is injected without perturbing chat-template tokens, tool-call delimiters, or JSON/schema structure.

The result is a merge that gains planning / reflection / recovery reasoning while keeping the base agent's compact, tool-call-disciplined behavior — the entire merge is a closed-form edit of the Instruct weights, with no fine-tuning.

This checkpoint's recipe

This checkpoint merges Qwen/Qwen3-Next-80B-A3B-Instruct (base) and Qwen/Qwen3-Next-80B-A3B-Thinking (donor) with:

• Global injection strength — α=0.15, multiplied by the per-component CTG coefficients, so the Thinking delta is added at low strength.
• Per-layer / per-component gating — attention, expert (FFN), norm, and router components each get their own SCTG​(c,l) coefficient, varying by layer index rather than a single flat scalar.
• Architecture-aware norm handling — Qwen3-Next's zero-centered (1+w) RMSNorm keeps the effective norm multiplier bounded, so norm edits are merged through the standard gated path without special clamping.
• GSP projector — a freshly rebuilt Qwen3-Next-80B graduated-sigmoidal projector protects the format / tool-call subspace before injection.

Architecture

The merge preserves the standard Qwen3-Next-80B-A3B (hybrid MoE) topology unchanged:

Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "zmzfpc/crane-next-80b"

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

messages = [
 {"role": "user", "content": "Write a Python function that returns the nth Fibonacci number."},
]

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

outputs = model.generate(inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0][inputs.shape[-1]:], skip_special_tokens=True))

Requires a recent transformers with Qwen3-Next support (the model was exported with transformers >= 4.57.0.dev0).

Citation / attribution

If you use this model or the CRANE method, please cite:

@misc{zhu2026crane,
 title = {CRANE: Constrained Reasoning Injection for Code Agents via Nullspace Editing},
 author = {Zhu, Mingzhi and Merler, Michele and Pavuluri, Raju and Patterson, Stacy},
 year = {2026},
 eprint = {2605.14084},
 archivePrefix= {arXiv},
 primaryClass = {cs.SE},
 url = {https://arxiv.org/abs/2605.14084}
}

Project page: https://rpi-nsl.github.io/CRANE/ · Code: github.com/rpi-nsl/CRANE

Base models — built from two Apache-2.0 checkpoints:

• Qwen/Qwen3-Next-80B-A3B-Instruct (base / backbone)
• Qwen/Qwen3-Next-80B-A3B-Thinking (reasoning donor)

License: Apache-2.0 (consistent with both base models and the CRANE code).

Qwen/Qwen3-Next-80B-A3B-Instruct

Qwen/Qwen3-Next-80B-A3B-Thinking

2 items • Updated 8 days ago