README.md

---
license: apache-2.0
language:
  - en
pipeline_tag: image-text-to-text
base_model: Qwen/Qwen3.8-27B
library_name: transformers
tags:
  - multimodal
  - vision-language
  - reasoning
  - thinking
  - efficient-reasoning
  - code
  - software-engineering
  - swe
  - agentic
  - terminal
  - tool-use
  - long-context
  - qwen3.8
  - thinking-efficiency
model-index:
  - name: Salience-27B-R5
    results: []
---

<div align="center">

# Salience — 27B
<p align="center">
  <img src="Salience-27B-R5-Banner.png" alt="Vection Labs Salience 27B R5 Banner" width="100%">
</p>

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

*Vection Labs*

[Weights](https://huggingface.co/vectionlabs/Salience-27B-R5) ·
[Reasoning effort](#reasoning-effort) ·
[Quickstart](#quickstart) ·
[Limitations](#limitations--responsible-use)

</div>

---
> [!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.

## 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](#limitations--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)](https://huggingface.co/vectionlabs/Salience-1.5-Pro) ·
[Flash (30B-A3B MoE)](https://huggingface.co/vectionlabs/Salience-1.5-Flash) ·
**27B R5 (dense)** ·
[Nano (9B dense)](https://huggingface.co/vectionlabs/Salience-1.5-Nano)

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

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

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

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

## Quantized GGUF (local)

```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

Published when they come from a run that reproduces. Not before.

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

---

<sub>Built on Qwen3.8 (Apache-2.0).</sub>
<sub>Build with love by the vectionlabs' team (Apache-2.0).</sub>

<div align="center"><sub>© 2026 Vection Labs</sub></div>