You can deploy this model and start earning money today!

vectionlabs/
Salience-27B-R5

Name: Salience-27B-R5
Rating: 2.5 (872 reviews)

Views

No views yet

Salience — 27B

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

Vection Labs

Weights · Reasoning effort · Quickstart · Limitations

[!Note] R5. Fifth revision of the Salience Ridge 27B tier, rebuilt on the Qwen3.8 architecture. Stable for daily use; rough edges get fixed in the stable release — report them 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 (Pro, Flash) 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.

R5's headline change 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". R5 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 behaviour rather than something you have to ask for.

Reasoning effort

Thinking is on by default: the model reasons inside <think>...</think> before answering, and serving stacks expose it as reasoning_content. What R5 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

python

# 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.

Highlights

Reasoning economy by default. Deliberation is proportional to difficulty. The model is no longer instructed to validate assumptions and weigh alternatives on every single 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 to produce 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 screenshot, 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 R5 (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 task execution.
Deep reasoning — structured, inspectable chains of thought for hard, multi-step problems.
Multimodal perception — diagrams, screenshots, documents, and video as first-class inputs.

Tool calling

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

Intended use

Salience 27B R5 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.

What ships here

18 safetensors shards, 8 JSON configs, a chat template, this README and a banner. No pickle files, no .bin, no .py. Safetensors is a flat tensor container with no mechanism for executing code, which is why it replaced pickle — the file list is on this page and you do not have to take my word for any of it.

Weights cannot run anything on their own; a harness runs things. If you hand any model shell access inside an agent loop that is your risk surface, and it is identical here and for the stock base model.

Quickstart

python

from transformers import AutoModelForImageTextToText, AutoProcessor
import torch

repo = "vectionlabs/Salience-27B-R5"
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.

Running it locally

build	format	notes
bartowski/vectionlabs_Salience-27B-R5-GGUF	GGUF	full range of sizes
mradermacher/Salience-27B-R5-i1-GGUF	GGUF	imatrix
mradermacher/Salience-27B-R5-GGUF	GGUF	static
McG-221/Salience-27B-R5-mlx-8Bit	MLX	Apple silicon

Thanks to everyone who built those.

bash

llama-server -m Salience-27B-R5-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 standard quant intuition applies: Q4_K_M and up hold quality well; use Q5_K_M/Q6_K when VRAM allows. (The MoE tiers of the family need Q5/Q6 minimum — that constraint does not apply here.) Keep the MTP layers if your quant includes them: they enable self-speculative decoding for free extra speed.

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 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 yet. Not withheld — not run.

When they exist they will be against a plain Qwen3.8-27B baseline on the same harness and the same day, because a number without its baseline is not a measurement. Until then, treat everything above as a description of what this model was built to do rather than proof that it does it.

Limitations & responsible use

May hallucinate APIs or facts under ambiguity; verify critical output.
Review generated code before running it, especially anything touching production systems.
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.

_{Built on Qwen3.8 (Apache-2.0).} _{Build with love by the vectionlabs' team (Apache-2.0).}