--- license: apache-2.0 language: - en pipeline_tag: image-text-to-text library_name: transformers tags: - multimodal - vision-language - reasoning - thinking - efficient-reasoning - thinking-efficiency - code - software-engineering - swe - agentic - terminal - tool-use - function-calling - instruction-following - long-context - uncensored - mtp - speculative-decoding - qwen3.8 model-index: - name: Salience-27B-R6 results: [] base_model: Qwen/Qwen3.8-27B ---
# Salience — 27B

Vection Labs Salience 27B R6

**A 27B dense vision-language engineer that stops thinking once it has the answer.** *Vection Labs* [Weights](https://huggingface.co/vectionlabs/Salience-27B-R6) · [What changed](#what-changed-in-r6) · [Reasoning effort](#reasoning-effort) · [Quickstart](#quickstart) · [Run it locally](#run-it-locally) · [Limitations](#limitations--responsible-use)
--- > [!NOTE] > **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](#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](#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 R6 (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 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 `...` 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 | ```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. > **Parsing the chain.** The chat template emits the **opening** `` tag as part of > the generation prompt, so completions carry only the closing ``. 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** (``), 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 ```python 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 ```bash 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