---
license: apache-2.0
language:
  - en
pipeline_tag: image-text-to-text
library_name: transformers
tags:
  - multimodal
  - vision-language
  - reasoning
  - thinking
  - code
  - software-engineering
  - swe
  - agentic
  - terminal
  - tool-use
  - long-context
  - qwen3.6
  - Fable-5
  - fable5
model-index:
  - name: Salience-27B-R4
    results: []
---

<div align="center">

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

**A 27B dense vision-language engineer — the full-capacity tier of the Salience family: every parameter on, every token.**

*Vection Labs*

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

</div>

---
> [!Note]
> **Preview release.** This is an early build of the Salience 27B tier. It is stable for daily use,
> but rough edges are expected — anything you report in the Community tab gets fixed in the
> stable release.
> This model's dataset contains reasoning traces from Fable 5, but manually reduced for token efficiency.

## 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 a **262K-token** context
window (extendable to 1M via YaRN).

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.

It is engineered for people who care less about chat pleasantries and more about whether the
model can *do the thing*: ship the function, find the bug, drive the terminal, land the pull
request.

## Highlights

- **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.
- **Efficient reasoning.** Thinks natively before answering — and gets to the point instead of
  narrating: markedly fewer thinking tokens at the same answer quality.
- **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.
- **Open weights.** Apache-2.0, `transformers`-native.

## Model overview

| | |
|---|---|
| **Parameters** | 27.2B dense (all active) |
| **Modalities** | text, image, video -> text |
| **Context window** | 262,144 tokens native (up to 1,048,576 via YaRN) |
| **Attention** | hybrid linear + full attention (full every 4th layer) |
| **Decoding** | MTP head included (self-speculative decoding) |
| **Precision** | bfloat16 |
| **Architecture** | Qwen3.6 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 Preview (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.

### Thinking

Thinking is **on by default**: the model reasons inside `<think>...</think>` before answering,
and serving stacks expose it as `reasoning_content`. Reasoning is native — you never have to
write *think step by step* (doing so makes it perform reasoning instead of doing it). Control
depth with the token budget, not the prompt. Pass `enable_thinking=False` to
`apply_chat_template` for instant direct answers.

### 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 R4 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-R4"
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)

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.

## Prompting tips

- **Let it think.** No "think step by step" — reasoning is native. Budget tokens instead.
- **Give it the repo.** 262K to 1M context: paste whole files or repos, 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.

## Limitations & responsible use

- May hallucinate APIs or facts under ambiguity; verify critical output.
- Review generated code before running it, especially anything touching production systems.
- Preview build: report issues in the Community tab — they get fixed in the stable release.

---

<sub>Built on Qwen3.6 (Apache-2.0).</sub>

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