Agens Volundr 32B v1

Agens Volundr 32B is Blockway's open-weights model for coding, reasoning and agent work — the model behind Agens. v1 is the full release the Preview (2026-10-05) announced: the same architecture, continued pre-training run to its end, and post-training built for long agent sessions.

Ahead of Qwen3.8-27B on competitive coding (LiveCodeBench v6: 67.9, +8.4) and competition maths (AIME 2025: 80.0, +6.7), measured on one harness with the same settings for every model (best of the repeated runs, for every model).
Built for agent loops: bounded reasoning per step, no repetition loops in 50 SWE-bench tasks, and session continuation — a conversation is prefilled once and each later turn processes only the new messages (follow-up turns 2.9× faster).
Fast where it matters: with the DFlash2 drafter, structured output runs at up to 125 tok/s on one 48 GB GPU and 76 tok/s on a 48 GB pair (up to 3.0× over plain decoding), and decode speed stays flat from 1K to 128K context.
Long context that stays cheap: only 18 of 72 layers keep a KV cache; a single 131K-token input fits on one 48 GB GPU with the INT4 build (24.6 GB).
Runs on one 16 GB GPU with Agens Engine (MIT): the Engine-16GB build keeps a 262K-token context inside a 16 GiB memory cap at 86–150 tok/s with the drafter (see below).

Volundr speaks English, Chinese (Simplified and Traditional) and Cantonese, handles text and images, calls tools, and ships with Blockway's control tokens and chat template. Apache-2.0.

What v1 fixes from the Preview

The Preview was an early checkpoint (step 1,000 of 20,000) with post-training that had never seen a long agent session. v1 closes that gap:

Preview behaviour	v1	How
Repetition loops in long sessions (36 of 50 SWE-bench tasks)	0 of 50	Supervised fine-tuning on multi-turn agent trajectories, then anti-repetition preference pairs mined from the model's own sessions
Runaway thinking: longest steps hit the 32K limit and were cut off	Median 120 tokens per step, longest 12K, no step ≥ 16K	An "answer, then stop" length preference and length pairs taken from real agent states
Every turn re-prefilled the whole conversation	Session continuation: prefill once, each turn processes only the new messages (follow-up turns 2.9× faster; 1.6 s median with the drafter)	The serving build carries the linear-attention state and the Engram context of the cached prefix into the next request
Agentic results	SWE-bench Verified mini 22 → 27 of 50, τ²-bench 89 → 92 of 120, LiveCodeBench 63.4 → 67.9, AIME 76.7 → 80.0; median SWE-bench task 124 → 82 minutes	Continued pre-training to the final checkpoint plus the agent post-training above

Same tokenizer, chat template (high now accepted as an alias of xhigh), control tokens and serving flags as the Preview. The DFlash2 drafter is retrained on the v1 weights and published separately; use it, not the Preview drafter, with v1.

Results (same harness for every row)

Benchmark	Agens Volundr 32B v1	Agens Volundr 32B Preview	Qwen3.8-27B	Agens Pilot
Coding
Competitive coding — LiveCodeBench v6 (2025-02 to 2025-05), best of 2 runs	67.9 ▲ +8.4	63.4	59.5	60.3
Code completion — HumanEval	78.7 ▲ +1.3	81.7	77.4	80.5
Agentic coding — SWE-bench Verified, 50 tasks (Codeway)	54.0	44.0	58.0	64.0
Agent
Knowing when not to call — BFCL v4 irrelevance	82.1 ▲ +0.4	80.8	81.7	85.8
Multi-turn tool use — τ²-bench (airline, retail, telecom)	76.7	74.2	79.2	80.0
Parallel function calls — BFCL v4 parallel	94.0	92.0	94.0	92.0
General
Competition maths — AIME 2025, avg@4, best of 2 runs	80.0 ▲ +6.7	76.7	73.3	67.5
Maths — MATH-500	96.8 ▲ +0.2	98.2	96.6	97.2
Instruction following — IFEval (prompt strict)	87.2	87.6	88.4	85.6
Instruction following — IFBench (prompt strict)	64.3	66.3	69.3	63.0
Scientific reasoning — GPQA Diamond	80.3	84.3	85.4	82.8
Knowledge — MMLU-Pro	80.0	79.9	80.4	80.3
Chinese knowledge — CMMLU	85.9	86.5	86.4	86.1

▲ v1 ahead of Qwen3.8-27B (difference in points). Thinking on, temperature 0.6 and the same output-token limit for every model unless noted; answers cut off by the limit count as wrong. HumanEval: greedy code completion. GPQA Diamond: 6K-token thinking budget, then the answer is forced, for every model (best of 4 runs for every model). τ²-bench: agent at temperature 0, Qwen3.8-27B as the user simulator for every model; the 13 retail tasks that need an LLM judge are scored as failed for every model (no LLM judges are used anywhere). BFCL v4: non-live categories, official harness at temperature 0.001. AIME 2025 and LiveCodeBench: best of 2 runs. SWE-bench: 50-task subset of SWE-bench Verified ("Verified mini") run through Codeway, Blockway's coding-agent harness, with each model's default sampling and identical limits. MMLU-Pro and CMMLU: fixed stratified subsets (1,400 and 2,010 questions). Qwen3.8-27B and Agens Pilot were run by us on the same harness; these are not their publishers' figures. Run-by-run (best shown): GPQA Diamond v1 79.3 / 78.8 / 80.3 / 78.8, Preview 79.3 / 79.8 / 83.3 / 84.3, Qwen3.8-27B 83.8 / 84.8 / 82.3 / 85.4, Agens Pilot 81.8 / 81.3 / 82.8 / 80.3; AIME 2025 v1 78.3 / 80.0, Preview 76.7 / 72.5, Qwen3.8-27B 70.0 / 73.3, Agens Pilot 65.8 / 67.5; LiveCodeBench v1 66.4 / 67.9, Preview 63.4 / 63.4, Qwen3.8-27B 59.5 / 58.8, Agens Pilot 60.3 / 57.3.

v1 leads Qwen3.8-27B on competitive coding, competition maths, code completion, MATH-500 and BFCL irrelevance, matches it on BFCL parallel, and is within a point on knowledge (MMLU-Pro, CMMLU) and IFEval. Against the Preview the gains land where the agent training was aimed — SWE-bench +10 points, τ²-bench +2.5, LiveCodeBench +4.5, AIME +3.3 — while GPQA Diamond, HumanEval and IFBench give back a few points (the HumanEval and IFBench differences are within one standard error). Where a benchmark was run more than once, the table shows each model's best run; the run-by-run values are in the footnote. On agentic coding and multi-turn tool use v1 sits between the Preview and Agens Pilot.

Speed

Volundr is built so that long sessions do not slow down: 54 of its 72 layers keep a fixed-size state instead of a growing KV cache, and decode speed is flat from 1K to 128K tokens of context. Prefill runs at about 2,100 tok/s on a 48 GB pair (bf16) or one 48 GB GPU (INT4) for short prompts and still 1,300 tok/s at 128K.

Speculative decoding. The DFlash2 drafter trained on the v1 weights (Blockway/Agens-Volundr-32B-v1-DFlash2) multiplies decode speed for a single user (greedy, 400-token replies, same output as without it):

Setup	JSON / structured output	Code	Replies with thinking	Cantonese chat
bf16, two 48 GB GPUs	3.0× (75.9 tok/s)	2.2×	1.5×	1.4×
INT4, one 48 GB GPU	3.0× (124.7 tok/s)	1.9×	1.3–1.4×	1.2×

The drafter is for one or two concurrent streams; with many users plain decoding gives more total throughput (see the drafter card and the serving README).

Session continuation. An agent sends the whole conversation again on every turn. With the prefix cache on, the server carries the KDA state and the Engram context of the cached prefix into the follow-up request, so a new turn prefills only the new messages: on a greedy replay of 20 multi-turn agent transcripts (484 turns, INT4 on one 48 GB GPU), follow-up turns ran 2.9× faster than with the cache off, and 1.6 s median with the drafter on as well (3.0 s with the cache alone). Outputs are greedy-equivalent, not byte-identical, because a cached prefix is prefilled in different pieces from a cold one. Recommended session configurations (two 48 GB GPUs bf16 up to 12 concurrent sessions; one 48 GB GPU INT4 up to 4, where a single 131K-token input fits) are in the serving README.

On one 16 GB GPU — Agens Engine

Agens Engine is Blockway's open-source (MIT) inference engine for Volundr on a single consumer GPU: it stores each layer at 2, 3 or 4 bits (2.82 bits per weight on average), keeps the embedding and Engram tables in host RAM and the long-context KV cache in host memory, and plans everything inside a hard GPU-memory budget. It serves an OpenAI-compatible API and uses the v1 DFlash2 drafter for speculative decoding, with greedy and sampled decoding; from Engine 1.2 an optional MTP head (Blockway/Agens-Volundr-32B-v1-MTP, 0.22 GB) acts as a second draft source beside the drafter; in Engine 1.3 it also works with image input and under tensor parallelism (3.45 / 3.42 accepted tokens per verify step at tp2 / tp4, against 3.10 without it).

With the Engine-16GB build (Blockway/Agens-Volundr-32B-v1-Engine-16GB) Volundr v1 runs a 262K-token context (measured to 239K) at a peak of 15.5 GiB of GPU memory, inside the engine's 16 GiB cap. Measured with Engine 1.1.0 on a 48 GB GPU held to that cap, single stream, decode tokens per second:

	chat	code	thinking	tool calls	agent (8K context)
Short context, greedy	98	129	117	122	150
Short context, temperature 0.6	86	114	92	120	123
After a 219K-token document, greedy	67	93	85	74	83
After a 219K-token document, temperature 0.6	57	79	71	67	72

Prefill of that 219K-token document took 147 s.

With --mtp on the same 16 GB profile (Engine 1.3.0 with MTP head v1.0, images off, one run per cell; accepted tokens per verify step in brackets):

	Short context, greedy	Short context, temperature 0.6	After a 219K-token document, greedy	After a 219K-token document, temperature 0.6
chat	108.0 (2.67)	93.2 (2.72)	71.2 (2.46)	64.4 (2.51)
code	140.7 (3.47)	122.4 (3.57)	103.1 (3.60)	93.1 (3.66)
thinking	122.2 (3.04)	97.3 (2.85)	88.4 (3.07)	81.8 (3.21)
tool calls	124.1 (3.06)	135.7 (3.94)	75.1 (2.56)	64.5 (2.51)
agent (8K context)	155.2 (4.24)	131.6 (4.18)	89.2 (3.12)	94.8 (3.73)

Context with --mtp: 237,572 tokens on the 16 GB profile, 217,092 with image input on (peak 16.75–16.76 GB inside the cap on Engine 1.3.0 with head v1.0; 16.82 GB on Engine 1.3.5 with head v1.1, same contexts); the 24 GB profile keeps 258,052 with images and MTP. Sampled cells and classes with few prompts carry run-to-run noise.

MTP head v1.1 (2026-10-23). The head repo's current version (Blockway/Agens-Volundr-32B-v1-MTP) is self-distilled on the model's own samples; v1.0, the head the tables above were measured with, stays under its tag v1.0. In a paired re-measurement on Engine 1.3.5 with the same profiles and prompts, v1.1 commits more tokens per verify step than v1.0 (greedy; 16 GB profile: code 3.47 → 3.67, tool calls 3.06 → 3.27, agent 4.26 → 4.42, chat 2.67 → 2.71; 24 GB profile: agent 3.99 → 4.45, tool calls 3.38 → 3.63), up to about 11% faster decode. The tables above keep the v1.0 numbers; the head card has v1.1's.

Quality against the bf16 weights on the same harness (bf16 in brackets): GPQA Diamond 73.7 best of 4 runs [80.3], HumanEval 73.2 [78.7], AIME 2025 avg@4 80.0 best of 4 runs, mean 76.7 [80.0 best of 2, mean 79.2], MATH-500 96.4 [96.8], IFEval prompt-strict 86.5 [87.2], BFCL v4 parallel 94.0 [94.0], BFCL v4 irrelevance 81.7 [82.1] (8 of 240 answers hit a 32K client cap), mean KL 0.117 and top-1 agreement 90.4 % — a build for running locally, not for leaderboards. Known limitation of this low-bit build: thinking over long documents (32K tokens and up) can loop or answer wrongly where the bf16 and INT4 builds do not (110K-token test: 6 of 10 correct, 3 of 10 looped, against 10 of 10 for INT4 in the same engine); for long documents use thinking off or the INT4 build until a revised 16 GB build lands. The download is 25 GB because the files store the linear weights in 4-bit containers and keep the embedding and memory tables at full precision; the engine repacks them at load. On a GPU that also drives a display, usable memory can be below 15.5 GiB, so use a shorter context there. On the same 48 GB GPU with the same INT4 weights and drafter, Agens Engine decoded 1.4–1.8× faster than the Blockway sglang build with greedy decoding and 1.1–1.6× with sampling (single stream, one run per side). Image input is available on the 16 GB profile with --images on (context then 223K, the vision encoder's activations take the rest). These weights run only on Agens Engine: quickstart and requirements at github.com/BlockWayz/agens-engine (image ghcr.io/blockwayz/agens-engine:1.3.5, :latest tracks the newest release; the no-MTP figures above were measured on 1.1.0, the MTP figures on 1.3.0; 1.1.1 added a thinking repetition guard and a default output cap that limit the damage of the long-document loops without fixing them; compute capability 8.9 and 9.0 validated by us, 8.6 reported working by a user).

Format and serving

Thinking is on by default (enable_thinking: false turns it off); reasoning_effort accepts low / medium / xhigh (the default; high is an alias). Our sglang build also takes a per-request reasoning_budget that closes the thinking block after N generated tokens, after which the model writes its reply (inference only, weights untouched). Tool calls use the <function=…><parameter=…> form; the agens parsers expose them as OpenAI-style tool_calls.

Serving. Volundr runs on the Blockway sglang build (ghcr.io/blockwayz/agens-sglang:v1-sm89 for 48 GB Ada GPUs, :v1-sm90 for H100/H200; source and flag-by-flag README at github.com/BlockWayz/agens-sglang). bf16 on two 48 GB GPUs:

docker run --rm --gpus '"device=0,1"' --ipc=host --network host --shm-size 32g \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  ghcr.io/blockwayz/agens-sglang:v1-sm89 \
  python3 -m sglang.launch_server \
    --model-path Blockway/Agens-Volundr-32B-v1 \
    --tp-size 2 --attention-backend flashinfer --page-size 1 \
    --disable-radix-cache --disable-prefill-cuda-graph --disable-custom-all-reduce \
    --mem-fraction-static 0.87 --context-length 32768 \
    --max-mamba-cache-size 16 --max-running-requests 16 --cuda-graph-max-bs 16 \
    --reasoning-parser agens --tool-call-parser agens \
    --host 127.0.0.1 --port 30000

Session continuation: set VOLUNDR_RADIX_SESSION=1 and replace --disable-radix-cache with --mamba-radix-cache-strategy no_buffer --disable-overlap-schedule. Images: add --enable-multimodal --mm-feature-transport cpu. The serving README has the INT4 single-GPU, H200, drafter and session-serving commands. GGUF files for llama.cpp (Blockway's volundr branch) are in Blockway/Agens-Volundr-32B-v1-GGUF.

Architecture

Component	Layers	How it works	What it buys
KDA (Kimi Delta Attention)	54	Linear attention: a gated delta-rule update of a fixed-size state per head, with per-channel decay	Memory and per-token decode cost independent of context length; no KV cache in these layers
BCSA (Blockway Compressed-Sparse Attention)	17	Exact attention over a 4,096-token sliding window, plus the far field pooled into 4-token blocks of which a learned indexer selects the top 512; both halves share one softmax	Attention cost per token bounded by the window plus 512 blocks, while keeping precise local detail and long-range recall
Dense attention	1	Standard full attention	One exact global read of the whole context
Engram	2	Hashed 2-gram and 3-gram lookup into a 1M-row × 512 memory table, gated into the residual stream at layers 2 and 22	Extra parametric memory read by a table lookup instead of matrix multiplies, at almost no compute cost
mHC	all	Four residual streams mixed by learned matrices kept doubly stochastic (Sinkhorn projection)	Stable signal propagation through a 72-layer stack

About 32 billion parameters. Only 18 of 72 layers keep a KV cache: on two 48 GB GPUs (bf16) the server holds a 220K-token cache pool, and the INT4 build (24.6 GB) runs on a single 48 GB GPU.

Training

v1 is the Preview trunk continued to its final checkpoint (step 20,000): continued pre-training on repository-level code (each repository packed in dependency order, tests next to their sources), code and maths corpora, web text in English, Chinese and Cantonese, and GitHub issues, with chat-format replay under logit distillation so reasoning and turn-taking stay intact.

Post-training targeted agent work: supervised fine-tuning on identity, tool use (parallel calls, and declining when no tool fits) and multi-turn agent trajectories — coding and tool-use sessions generated with Agens Pilot and Qwen3.8-27B as agents, and with Kimi K3 for the hardest tasks, keeping only trajectories whose result passed the task's own checks — then three rounds of preference training on pairs mined from the model's own samples (identity, tool use, reasoning anchors and anti-repetition; "answer, then stop"; length pairs from agent states). The released weights average two preference-training checkpoints.

Teacher outputs in the training data come only from open-weight models under permissive licences (Apache-2.0, MIT, and the Kimi K3 License with Moonshot AI's written permission): Qwen3.8-27B, DeepSeek-V4-Pro-0813, Agens Pilot and Kimi K3. There are no outputs from Anthropic, OpenAI or Google models.

Scope notes

Agentic coding and multi-turn tool use: much improved over the Preview; on our harness v1 sits between the Preview and Agens Pilot (SWE-bench Verified mini 27 of 50, τ²-bench 92 of 120).
Retrieval validated to 107K tokens (needle-in-a-haystack 100/100); the full 262K window has not been re-validated on this checkpoint.
Long-document question answering with thinking on can still degenerate: in our test (a 110K-token novel plus a factual question, 32K/64K/110K windows, 3–12 samples per cell) the model sometimes re-quotes the document while searching for the passage until it hits the token limit — 7 of 39 thinking runs, concentrated at reasoning_effort: medium and at the shorter windows; xhigh and low were mostly clean (0 of 12 at 110K xhigh), and thinking off always answered. A reasoning_budget closes the thinking block but does not always recover the answer. This is a known limitation we are working on.
Cantonese is a supported language, not a specialty.
The drafter is for one or two concurrent streams; for many-user session serving use the no-drafter configurations in the serving README.

Acknowledgements

The mixer stack builds on published research: Kimi Delta Attention (Moonshot AI), and DeepSeek's sparse attention, Engram and manifold hyper-connections. The combination, the BCSA design and the training programme are Blockway's.

Licence

Apache-2.0. The licence files and MODIFICATIONS.md ship with the weights.