Tess-4.5-27B

Tess-4.5-27B is an open-weights, 27-billion-parameter dense model developed by Continuity Research, engineered specifically for autonomous software development and local agentic execution. Released in October 2026 under the permissive Apache 2.0 license, the model is a targeted post-train of Qwen3.8-27B. It is designed to solve one of the most persistent bottlenecks in local engineering workloads: verbose, wasteful reasoning chains that clog context windows and throttle execution speed on consumer silicon.

Rather than trading general competence for coding specialization, Tess-4.5-27B preserves its foundation model baseline while dramatically compressing execution traces. In benchmark evaluations across local workflows, it matches the raw success rate of its base model while generating 25 percent fewer tokens overall. For developers seeking a capable local AI model with 27B parameters in 2026, Tess-4.5-27B bridges the gap between massive frontier models and the operational constraints of desktop hardware.

Continuity Research ships the model with full ecosystem support out of the box, including upstream weights for Hugging Face Transformers, vLLM, and SGLang, alongside pre-quantized GGUF binaries and dedicated speculative decoding draft heads for llama.cpp. This makes Tess-4.5-27B one of the most accessible and practical options for developers building local autonomous coding pipelines without relying on external cloud APIs.

Tess-4.5-27B uses a dense transformer architecture inherited from Qwen3.8-27B, totaling approximately 27.8 billion parameters in BF16 precision. Unlike Mixture-of-Experts (MoE) architectures that swap active parameter subsets per token, a dense 27B architecture keeps all weights resident and active during every forward pass. This gives Tess-4.5-27B consistent memory traffic characteristics and predictable compute requirements across both prompt processing and token generation.

The architectural profile features 64 layers utilizing an interleaved attention layout (combining linear attention layers with full self-attention), a hidden dimension of 5120, and Grouped-Query Attention (GQA) with 24 query heads over 4 key-value heads. This GQA structure drastically shrinks the KV cache footprint during sustained agent sessions compared to standard multi-head attention. Rotary position embeddings (RoPE) are tuned for extended context scaling, allowing the model to comfortably manage multi-file codebases, shell outputs, and system interaction logs without degrading attention clarity.

A key technical addition by Continuity Research is the bundled multi-token-prediction (MTP) draft head. Designed for speculative decoding in runtimes like llama.cpp, this one-layer draft head predicts subsequent tokens in parallel with base token verification. Because code and system commands contain high syntactic redundancy (such as indentation, boilerplate, and shell arguments), the speculative acceptance rate is notably high, providing substantial throughput gains on consumer GPUs without requiring a secondary external draft model.

Tess-4.5-27B targets real terminal work, codebase modification, and multi-turn autonomous tool orchestration. Its training specifically minimizes the common failure modes of open-weight agent models: path hallucination, phantom tool calls, and runaway inner monologues.

Using Tess-4.5-27B for coding differs from using typical conversational models. The model treats source code and terminal environments pragmatically:

• Terminal and CLI Navigation: In the CLI-40 suite of BenchLocal, Tess-4.5-27B scored 31 out of 40, leading its base model while using 32 percent fewer tokens. It issues succinct bash commands, evaluates standard error output, and avoids speculative directory traversal.
• Bug Localization and Patching: In the BugFind-15 pack, the model achieved a perfect 15 out of 15 score. It isolates regressions, reads diffs cleanly, and writes syntactically valid patches without regurgitating unchanged files.
• Strict Environment Grounding: Across 182 scored tool-use responses in validation testing, the model registered zero calls to non-existent tools. When presented with a constrained tool schema, it relies strictly on provided functions or falls back to direct instruction-following.

On the BenchLocal evaluation, Tess-4.5-27B scored 133 out of 150 scenarios on a best-of-three basis (128 on the first attempt), matching Qwen3.8-27B. Crucially, it generated only 262,047 tokens across the full run compared to 349,009 tokens for the base model. This efficiency matters directly for local operations:

• Fast Answers: By shedding 25 percent of unnecessary tokens across general tasks and up to 43 percent on structured data extraction, latency to completion is noticeably reduced.
• Preserved Context: Because the model consumes significantly fewer tokens to reason through intermediate steps, multi-turn agent sessions run longer before exhausting context capacity or triggering cache eviction.

To run Tess-4.5-27B locally, practitioners need to plan their memory budgets around both model weights and KV cache overhead. Dense 27B models require dedicated memory planning, but they sit within reach of high-end consumer hardware.

At full 16-bit precision (BF16/FP16), the model weights require roughly 55 GB of VRAM, necessitating dual RTX 3090/4090 GPUs or an enterprise accelerator. However, running the model in 4-bit or 5-bit quantization fits comfortably into single-GPU consumer workstations and modern unified-memory systems.

• NVIDIA RTX 4090 (24 GB): The premier single-GPU desktop target. Fits 4-bit quantized variants (Q4_K_M) with sufficient headroom for KV cache up to moderate context depths.
• Dual NVIDIA RTX 3090 / RTX 4090 (48 GB total): Easily hosts 8-bit quantized weights (Q8_0) or unquantized BF16 with tensor parallelism via vLLM or SGLang, leaving ample room for long-context KV caches.
• Apple Silicon (MacBook Pro / Mac Studio with 36 GB+ Unified Memory): An M3/M4 Max with 36 GB, 48 GB, 64 GB, or 128 GB unified memory runs 4-bit and 5-bit GGUF builds natively via Metal.

Here is a breakdown of estimated Tess-4.5-27B VRAM requirements across common quantization formats:

For most developers, the best quantization for Tess-4.5-27B is Q4_K_M. At 4-bit medium quantization, the model retains virtually all its instruction-following and tool-calling precision while dropping base memory footprint to approximately 16.5 GB. This allows an RTX 4090 to load the weights and allocate 4 to 6 GB for dynamic KV cache allocations. If you have 32 GB or more of addressable VRAM, stepping up to Q5_K_M provides a slight boost in complex mathematical reasoning at the cost of roughly 3.3 GB additional memory.

Inference speed varies widely based on memory bandwidth and speculative decoding configuration:

• NVIDIA RTX 4090 (llama.cpp, Q4_K_M, baseline): 48.9 tokens per second.
• NVIDIA RTX 4090 (llama.cpp, Q4_K_M, with MTP draft head on code): 96.1 tokens per second.
• NVIDIA RTX 4090 (llama.cpp, Q4_K_M, with MTP draft head on shell tasks): 85.5 tokens per second.
• Apple M4 Max (Metal, Q4_K_M, baseline): 24.4 tokens per second.
• Apple M4 Max (Metal, Q4_K_M, with MTP draft head on code): 37.8 tokens per second.

When using speculative execution with the bundled draft head, an RTX 4090 nearly doubles its generation throughput on source code, achieving near 100 tok/s. This makes interactive coding, shell execution, and live agent iteration feel instantaneous.

For fast local experimentation, Ollama provides the quickest setup path:

1# Run the quantized model via Ollama
2ollama run tess-4.5:27b

For production workflows requiring speculative decoding and maximum throughput:

1. llama.cpp: Use native GGUF builds along with the official draft head (--draft flag) to activate the multi-token-prediction layer. This delivers the highest single-GPU token generation speeds.
2. vLLM / SGLang: Ideal for serving multi-turn agent frameworks (such as OpenHands or custom LangGraph/CrewAI loops) where PagedAttention and continuous batching optimize overall throughput across multiple concurrent requests.

Evaluating Tess-4.5-27B against other models in the 25B to 35B parameter class highlights its distinct design philosophy.

Because Tess-4.5-27B is a direct fine-tune of Qwen3.8-27B, the comparison comes down to efficiency and agent alignment:

• Reasoning Density: In benchmark testing, both models achieve an identical 133/150 best-of-three score on BenchLocal. However, Tess generates 25 percent fewer tokens to reach those answers.
• Tool Grounding: Tess shows higher environmental discipline, zero tool hallucinations in benchmark evaluations, and improved CLI performance (31/40 vs 30/40).
• Inference Speed: The base model requires standard decoding passes, whereas Tess-4.5 ships with an integrated MTP draft head tailored to its specific output patterns, enabling up to 96 tok/s on an RTX 4090.

Google's Gemma 2 27B is one of the standard dense references at this weight class:

• Tool Calling and Function Use: Gemma 2 27B excels at raw academic knowledge and text reasoning, but it lacks native, reliable function calling out of the box. Tess-4.5-27B is explicitly optimized for structured JSON outputs, bash interactions, and tool dispatch.
• Speed and Efficiency: Gemma 2 utilizes a sliding-window attention mechanism that demands careful runtime configuration. Tess-4.5-27B offers higher real-world coding generation speeds due to its native multi-token draft heads and streamlined output style.
• License: Tess-4.5-27B is released under the permissive Apache 2.0 license, making it fully royalty-free and unrestricted for commercial pipelines, whereas Gemma carries custom terms of use.

Choose Tess-4.5-27B when your priority is running an autonomous agent, managing terminal pipelines, or generating code locally on an RTX 4090 or Apple Silicon workstation without the latency and token overhead common to general-purpose chat models.