Salience — 27B

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

Vection Labs

Weights · Quickstart · Limitations

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

The family: Pro (35B-A3B MoE) · Flash (30B-A3B MoE) · 27B Preview (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.

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

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.

Built on Qwen3.6 (Apache-2.0).