vectionlabs/Salience-27B-R6

Salience — 27B

A 27B dense vision-language engineer that stops thinking once it has the answer.

Vection Labs

Weights · What changed · Reasoning effort · Quickstart · Run it locally · Limitations

---

R6. Sixth revision of the Salience 27B tier, and a drop-in replacement for R5 — same interface, same context window, same tool contract. Report anything rough in the Community tab.

Abstract

Salience 27B is a 27-billion-parameter dense vision-language model built for hard, practical engineering work: writing and debugging real code, repo-scale edits, multi-step terminal agency, and quantitative reasoning — with native vision and 1,048,576 tokens of context.

Where the MoE tiers of the family route a few billion active parameters per token, Salience 27B runs all 27B on every token: maximum per-token capacity, a hybrid linear + full attention stack for long-context speed, and an MTP head for self-speculative decoding.

The line's defining property is reasoning economy. A reasoning model pays for accuracy in tokens, and most of them pay the same price for "what does this flag do" as for "why does this deadlock under load". Salience does not: it reasons hard when the problem needs it and answers directly when it does not — and unlike the stock configuration, that is the default rather than something you have to ask for.

What changed in R6

In R5, reasoning economy was a configuration choice: the model stopped instructing itself to deliberate on every turn, and the effort ladder did the rest. R6 moves it into the weights.

Shorter chains for the same answer. R6 is built to reach a clean stopping point sooner rather than to produce a longer visible chain. The unit that matters in an agent loop is not accuracy on one turn — it is wall-clock time to a finished task across fifty of them. A model that adds five seconds per turn adds four minutes to a fifty-turn job.

Draft acceptance. This tier ships an MTP head, so a higher fraction of accepted draft tokens converts directly into decode speed on any stack that uses it — llama.cpp, vLLM and SGLang all do. R6 targets that acceptance rate, not just raw token throughput.

Constraint-stacking loops. R5 could fall into a non-converging self-verification loop when two output-format constraints were stacked in one instruction — asking for no prose and no markdown together, for example — spending the whole token budget on repeated re-checking instead of answering. For a model whose premise is spending tokens in proportion to difficulty, that is the worst failure mode available. R6 rebuilds the reasoning path that produced it.

The trade, stated plainly. Optimising for shorter chains is not free. Expect R6 to sit slightly behind R5 on saturated multiple-choice knowledge benchmarks, and ahead of it on time to a finished answer. If your workload is one hard question at maximum effort, reasoning_effort="xhigh" still buys the long chain. If it is a fifty-turn agent loop, R6 is the one you want.

None of the above has been measured by us against a formal suite. It describes what this revision was built to do, not a result we are reporting. See Benchmarks. A reproduction in the Community tab is worth more here than a table we did not run.

Highlights

• Reasoning economy by default. Deliberation proportional to difficulty. The model is not instructed to validate assumptions and weigh alternatives on every turn — it decides. Ask for depth explicitly and you still get it.
• Dense capacity. All 27B parameters active on every token — no routing, no expert misses, maximum depth on every step of a hard problem.
• SWE-agent first. Tuned for runnable code, repo-scale edits, methodical debugging, and well-formed native tool calls.
• Lives in a terminal. Plans the command sequence, checks each result before the next step, and recovers from failures instead of repeating them.
• A million tokens. Paste the repository, not the fragment.
• Genuinely multimodal. Images and video are first-class inputs — read a diagram, a UI screenshot, a stack trace, or a whiteboard photo mid-task.
• Fast decode for its size. Hybrid linear + full attention (full every 4th layer) plus an MTP head for self-speculative decoding.
• Direct. Reduced refusal behaviour: it answers the question you asked. See responsible use.
• Open weights. Apache-2.0, transformers-native.

Model overview

Parameters	27.8B dense (all active)
Modalities	text, image, video → text
Context window	1,048,576 tokens (YaRN + Dual Chunk Attention)
Attention	hybrid linear + full attention (full every 4th layer)
Decoding	MTP head included (self-speculative decoding)
Precision	bfloat16
Architecture	Qwen3.8 dense (27B) + native vision encoder
License	Apache-2.0
Library	🤗 transformers (AutoModelForImageTextToText)

The family: Pro (35B-A3B MoE) · Flash (30B-A3B MoE) · 27B R6 (dense) · Nano (9B dense)

Capabilities

• Code & SWE execution — runnable code, repo-scale edits, methodical debugging, robust backends.
• Terminal & agentic work — multi-step planning, tool orchestration, long-horizon execution.
• Deep reasoning — structured, inspectable chains for hard, multi-step problems.
• Multimodal perception — diagrams, screenshots, documents and video as first-class inputs.

Reasoning effort

Thinking is on by default: the model reasons inside <think>...</think> before answering, and serving stacks expose it as reasoning_content. What Salience changes is how much.

value	behaviour	use it for
low	keeps the chain short and moves straight to the conclusion	chat, lookups, formatting, refactors
medium	default — no deliberation instruction; the model decides	everyday engineering work
xhigh	deliberate at length, validate assumptions, weigh alternatives	hard debugging, architecture, math

# default: proportional reasoning, nothing to configure
text = proc.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# ask for depth when the problem earns it
text = proc.apply_chat_template(messages, tokenize=False, add_generation_prompt=True,
                                reasoning_effort="xhigh")

# skip thinking entirely
text = proc.apply_chat_template(messages, tokenize=False, add_generation_prompt=True,
                                enable_thinking=False)

Reasoning is native — you never have to write think step by step. Doing so makes a model of this kind perform reasoning instead of doing it.

Parsing the chain. The chat template emits the opening <think> tag as part of the generation prompt, so completions carry only the closing </think>. A parser that hunts for a matched pair will report zero thinking and dump the chain into the answer. Split on the closing tag alone.

Tool calling

The model emits XML-style tool calls (<tool_call><function=...><parameter=...>), parsed natively by the vLLM / SGLang tool parsers for this model family, and by llama-server --jinja. Provide tool schemas through the chat template's tools argument.

Intended use

Salience 27B R6 targets software engineering, coding agents, and technical research:

• Code generation, explanation, debugging, review, and repo-scale tasks.
• Terminal / tool-using agent workflows (CLI agents, browsing, ML engineering, DevOps).
• Backend and systems design, infrastructure-as-code.
• Step-by-step reasoning and quantitative problem solving.
• Screenshot / diagram / document understanding inside engineering workflows.

It is not intended for high-stakes decisions without human review, nor as a source of truth for medical, legal, or financial advice.

Quickstart

from transformers import AutoModelForImageTextToText, AutoProcessor
import torch

repo = "vectionlabs/Salience-27B-R6"
proc = AutoProcessor.from_pretrained(repo)
model = AutoModelForImageTextToText.from_pretrained(
    repo, dtype="auto", device_map="auto"
)

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Implement an LRU cache in Python with O(1) get/put."}],
}]
text = proc.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = proc(text=[text], return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=2048)
print(proc.batch_decode(out[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)[0])

Requires a recent transformers (>= 5.8). Vision works the same way with {"type": "image", "image": ...} content items.

Run it locally

llama-server -m Salience-27B-R6-Q4_K_M.gguf \
  --jinja --reasoning-format deepseek \
  -c 32768 -ngl 999

--jinja is not optional for agent use: it applies the model's own chat template, which is what turns XML tool calls into proper OpenAI-style tool_calls — and what makes the reasoning defaults above take effect. Without it you get malformed calls and stock behaviour.

This is a dense model, so ordinary quant intuition applies: Q4_K_M and up hold quality well, and Q5_K_M / Q6_K are worth it when VRAM allows. (The MoE tiers of this family need Q5/Q6 minimum — that constraint does not apply here.) Keep the MTP tensors if your quant includes them: they are what make self-speculative decoding work, and on this revision that is where a meaningful part of the speed lives.

Long context

Ships with YaRN (factor 4.0, original_max_position_embeddings 262144) and a dual_chunk_attention_config block. Static YaRN taxes short prompts slightly; that is the cost of having the full window available by default. vLLM and SGLang read the DCA block, transformers ignores it.

Prompting tips

• Let it think. No "think step by step" — reasoning is native. Reach for reasoning_effort instead of prompt scaffolding.
• Give it the repo. A million tokens: paste whole files or repositories, not fragments.
• Agentic loops. Use --jinja with llama-server (or the vLLM / SGLang parsers) so XML tool calls become proper OpenAI-style tool_calls.
• Vision mid-task. Screenshots of stack traces and UI states work as debugging inputs.

Benchmarks

None have been run. Not withheld — not run.

Published when they come from a run that reproduces, with the harness, the version and the base column measured under the same conditions. Every claim on this page above that line is a description of what this revision was built to do, and is labelled as such.

Limitations & responsible use

• May hallucinate APIs or facts under ambiguity; verify critical output.
• Review generated code before running it, especially anything touching production systems.
• Check indentation on long Python output. Deeply nested generated Python — nested loops, try / except inside a class method — can come back with broken indentation. Run it, or python -m py_compile it, before trusting it. Reports in the Community tab are welcome.
• Reduced refusal behaviour. There is no content filter in the weights and no system-level guardrail — the model will attempt requests a stock model declines, and it will not decline on your behalf. Whatever policy your deployment needs is yours to add at the application layer. You are responsible for what you generate and for complying with the law where you operate.
• medium reasoning by default means shorter chains on genuinely hard problems than a model pinned to maximum effort. Pass reasoning_effort="xhigh" when the problem deserves it.
• Shorter chains are a trade, not a free win. On saturated multiple-choice knowledge benchmarks this revision may read slightly behind R5.

---

_{Built on Qwen3.8 (Apache-2.0).}

_{© 2026 Vection Labs}