Agens Volundr 32B v1

Main model card, benchmarks and discussion: Blockway/Agens-Volundr-32B-v1

INT4 build (4-bit weights, group size 128) of Agens Volundr 32B v1. It runs on a single 48 GB GPU with the Blockway sglang build. The results section below is the bf16 model; this INT4 checkpoint, measured on the same harness:

Recipe: GPTQ W4A16, group size 128, the KDA projections included (except in_proj_b); output head, Engram and mHC projections, BCSA indexer and vision tower bf16. Against the bf16 model on held-out text the INT4 build has a mean KL of 0.0419 nats and agrees on the top-1 token 94.20 % of the time. 24.6 GB.

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:

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)

▲ 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):

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:

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):

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

Volundr's chat format uses Blockway's control tokens: <|agens_start|> / <|agens_end|> for turns, <|think|> … <|/think|> for reasoning, <|call|> … <|/call|> for tool calls and <|result|> … <|/result|> for tool results. Each is a single reserved id, so turn boundaries, reasoning and tool calls never depend on how ordinary text tokenises. When no system message is supplied, the template inserts You are Agens, an AI assistant developed by Blockway.

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). INT4 on one 48 GB GPU:

docker run --rm --gpus '"device=0"' --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-INT4 \
    --tp-size 1 --attention-backend flashinfer --page-size 1 \
    --disable-radix-cache --disable-prefill-cuda-graph \
    --mem-fraction-static 0.86 --context-length 16384 \
    --max-mamba-cache-size 8 --max-running-requests 8 --cuda-graph-max-bs 8 \
    --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

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.