See what Tileward changes before you deploy it.

Level with the publisher’s build, and 36% smaller (1.55×) Tileward 35B-A3B on MMLU

Level with FP8. Both community 4-bit builds score 0.4 to 0.5 points higher, a direction rather than a size.

• Five-shot, 14,042 questions, lm-evaluation-harness, no sampling. The four bars are one run, one machine, same base model.
• Quoted to the tenth: our own build, run twice in one session, scores 82.8 and 82.9, and 181 of 14,042 answers change between the runs.
• Bars are weights on disk; serving VRAM is 25.6 GB against FP8's 39.1 GB. MMLU is multiple choice and we lead on two of its four categories; matching FP8 is consistent with the builds behaving alike, not proof.

Closer to the original than NVIDIA’s build, and level on MMLU Tileward 35B-A3B against NVIDIA’s NVFP4 build, whose file is 2.8% smaller (1.03×)

Closer to the original model, and level on MMLU and fabrication. Its next-word probabilities sit nearer the original’s than NVIDIA’s do (a KL distance of 0.023 against 0.040), MMLU is 82.9% against 82.6% (p = 0.08), and fabrication 2.3% against 2.1% of facts (p = 0.82). It leads on MMLU-Redux, 90.7% against 90.0%, mostly on questions NVIDIA’s build did not finish within the 12,288-token limit. NVIDIA’s file is 2.8% smaller (1.03×). NVIDIA’s build decodes faster for 1 and 16 callers while ours is faster for 64, has room for 12% more cached tokens at our hosted memory setting, and missed none of the 240 tool calls where ours missed two.

• Closeness: teacher-forced on 300 corpus chunks (87,955 positions), one request at a time. The mean KL divergence of each build’s next-word probabilities (its top 20) from the BF16 original’s is 0.023 for ours and 0.040 for NVFP4. Run twice in the same boot on 40 of the chunks, ours moves 0.003 from itself and NVFP4 0.008, so the gap is larger than either build’s own noise.
• MMLU: five-shot, 14,042 questions, lm-evaluation-harness, no sampling. The two bars are one session on one machine, same base model. The paired test counts the answers that differ: 416 right only for ours, 366 only for NVFP4 (p = 0.08).
• MMLU-Redux: 5,700 questions, answers generated with thinking on and capped at 12,288 tokens, the same session: 126 right only for ours and 86 only for NVFP4 (p = 0.007). NVFP4 reached the cap on 107 questions and ours on 78; on the 5,569 both finished, 92.0% against 91.8% (p = 0.37).
• Speed: output tokens a second without speculative decoding, random 1,024-token prompts and 256-token replies, 1, 16 and 64 simultaneous callers: 179, 1,625 and 3,442 for ours against 197, 1,682 and 3,316. With 8,192-token prompts the two are within 1% at 4 and 16 callers.
• Memory: at our hosted service’s memory setting and its full 262,144-token window, the cache holds 508,031 tokens for ours and 571,026 for NVFP4. At the engine’s default setting the two are within 1.3%.
• Fabrication: each build reads passages from Tileward’s own document set and writes out the facts they state; every fact is matched back to its passage, and one that no passage supports counts as fabricated. Ours wrote 1,683 facts and 38 were unsupported; NVFP4 wrote 1,819 and 38 were (p = 0.82, treating facts as independent).
• Tool calls: six cases (one call, two calls in one turn, nested arguments, a tool that must not be called, the right tool out of twenty, a two-turn loop), 20 trials each, scored mechanically on tool name, call count and argument shape, once with thinking off and once on: 240 calls. Ours missed two, both in the one-call case with thinking off, where it answered in text instead of calling the tool; NVFP4 missed none (p = 0.50).
• Bars are weights on disk (24.10 against 23.42 GB); loaded on the card, 21.0 against 20.4 GiB. NVIDIA’s build is its public NVFP4 checkpoint of the same base. Every figure on this card is from one 80 GB Hopper-generation card.

Level with NVIDIA’s build, and 8.5% smaller Tileward Qwen3.8-27B against NVIDIA’s NVFP4 build

Smaller, and level on MMLU, MMLU-Redux, fabrication and speed. MMLU-Redux 89.4% against 89.4% (p = 0.85), fabrication 4.0% against 4.8% of facts (p = 0.31), and decode speed within about 2% at 1, 16 and 64 callers. NVIDIA’s build stays closer to the original model on next-word agreement, 89.0% against 87.8%, and missed none of the 240 tool calls where ours missed two.

• MMLU: five-shot, 14,042 questions, lm-evaluation-harness, no sampling. The two bars are one session on one machine, same base model. The paired test counts the answers that differ: 484 right only for ours, 432 only for NVFP4 (p = 0.09).
• MMLU-Redux: 5,700 questions, answers generated with thinking on; the same session, 133 right only for ours and 129 only for NVFP4.
• Speed: output tokens a second with speculative decoding (3 draft tokens, about half accepted by both builds), natural-text prompts, 1, 16 and 64 simultaneous callers: 109, 843 and 1,390 for ours against 110, 826 and 1,381.
• Fabrication: each build reads passages from Tileward’s own document set and writes out the facts they state; every fact is matched back to its passage, and one that no passage supports counts as fabricated. Ours wrote 1,637 facts and 66 were unsupported; NVFP4 wrote 1,702 and 81 were (p = 0.31, treating facts as independent). In a second session ours scored 64 of 1,642; NVFP4 was not run there.
• Tool calls: six cases (one call, two calls in one turn, nested arguments, a tool that must not be called, the right tool out of twenty, a two-turn loop), 20 trials each, scored mechanically on tool name, call count and argument shape, once with thinking off and once on: 240 calls. Ours missed two (a call to a tool that did not apply, with thinking off; a nested case that returned no call, with thinking on) and NVFP4 missed none (p = 0.50). In a second session, on a different server setting, ours made all 240; NVFP4 was not run there.
• Agreement: teacher-forced on 300 corpus chunks (87,955 positions), top-1 agreement with the BF16 original; the mean KL to it is 0.050 for ours and 0.042 for NVFP4.
• Bars are weights on disk (20.05 against 21.92 GB); loaded on the card, 18.0 against 19.8 GiB. NVIDIA’s build is its public NVFP4 checkpoint of the same base.

In an agent loop, level with the uncompressed model four builds of Qwen3.8-27B on 142 tasks

A tie on finished tasks: all three compressed builds finish within noise of the base. The ternary build is the smallest file and works hardest for it. Paired by task over two runs, the TWX48 build of Tileward-Qwen3.8-27b wins 10 and loses 13 against the BF16 base, a gap smaller than the test can see. The publisher’s FP8 build finishes 1.1 points fewer (11 won, 16 lost) and the ternary build 2.5 fewer (13 won, 19 lost); neither gap is one this test can call. Every compressed build spent more prompt tokens than the base to get there: ours 7% more, the ternary build 28% more.

• AgentBench OS: Linux tasks in a real container, pass or fail decided by the environment; the 142 tasks every arm got a turn on. Greedy decoding, thinking off, 32k context, one NVIDIA 80 GB GPU, the same tasks and settings for all four.
• An agent loop does not repeat itself exactly, so 142 tasks resolve a gap of about ten points; every gap on this card is smaller than that, a direction rather than a size.
• The three Qwen-format builds ran on vLLM; the ternary build ran on its publisher’s own server, the only one that loads it, with reasoning off like the others, so its publisher’s thinking-on figures do not compare to this row. On this Hopper-generation card the FP8 build ran its native 8-bit path.

62% smaller, and half the time for each frame Tileward PersonaPlex 7B on one laptop

Smaller and faster than both, and behind the 8-bit conversion on agreement. The standard 8-bit conversion picks the original’s next word 98.1% of the time; a standard conversion at our size, 92.8%.

• One laptop, every build in the same runtime. Compute is the model alone for one conversation; the audio codec is not counted.
• Agreement is over 375 word moments in four conversations recorded from the published model, so a point either way is within chance.
• In 20 unscripted conversations a build, a speech recogniser followed the TWX4 build as well as the original.

74% smaller, and it still picks the right tool Tileward VoiceChat 11B against VoiceChat as published

A quarter of the file and no loss this test can see; on the card it keeps the original’s size and speed. The file is 53% smaller than the lossless form. The build is at 71 ms of each 80 ms frame, as the original is, and 24 GiB in memory.

• 100 spoken requests in six synthetic voices on a clean line, scored on the first tool call. A gap of three or four calls in 80 is within chance, so the two builds are level.
• One NVIDIA 96 GB card, one conversation at a time. Across 100 answers offline and 20 through the streaming path, an answer repeated itself twice for the original and once for the build.
• VoiceChat is NVIDIA’s model under the OpenMDW License Agreement, version 1.1 (OpenMDW-1.1); the build is a modified version of it under the same agreement.

68% smaller, and at most 0.3 points more error on nine of ten sets Whisper large-v3 and large-v3-turbo, each in TWX4, on one 20 GB card

Smaller than turbo, and level with it or ahead on every set. The large-v3 build is 40% smaller than large-v3-turbo (1.7×); its error rate is lower than turbo’s on four sets and level on six. Turbo carries about twice the live calls.

• One 20 GB card, every build on vLLM at 90% of the card’s memory. Word error rate, or character error rate for Mandarin and Japanese, with a paired bootstrap 95% range for each change.
• Ten sets: LibriSpeech test-clean and test-other, FLEURS in seven languages, and 384 synthetic call-centre clips. Japanese turns on one clip where the original repeats itself.
• A live call is one second of audio transcribed per second, with 512 windows of 28 seconds sent at once. Large-v3 fills this card’s memory, so a larger card holds more.

Most of the answers, on 95% less context (19×) LOCOMO long conversations, judged by a separate model

Tileward sent 1,499 tokens per question against 28,365 for the full transcript. This keeps most, not all, of the answer rate; a separate model judged every answer.

Every question answered, on 97–99% fewer tokens (38–82×) one 142-turn conversation, asked back

12 facts mentioned once each, 20 questions, 8 needing two or three facts at once. Qwen3.5-9B, exact substring match.

More tasks solved, on 68% less context (3.2×) 104 AgentBench tasks with earlier work in history

Tileward sent 523,028 context tokens against 1,651,372 for full histories. The context reduction is stable; the 13-task lead is not, so the repeated ordering matters more than the margin.

Agents in sequence, on half the tokens seven agents handing work down a line

11,667 tokens of shared state over 21 artifacts. Tileward delivered 86% of the material each step declared it needed; hand-configured routing, which is a person tagging artifacts per problem, delivered 95%. This flow was graded twice, four hours apart: Tileward 0.881 then 0.952, the uncompressed control 0.952 then 1.000. The scores move further between runs than between arms, so treat the token figures as the reliable half. The fuller run.

Agents in parallel, on 78% fewer tokens (4.5×) eight agents gathering at once

This is the flow we do worst on, and the saving is the largest. 45,712 tokens of shared state over 32 artifacts. Hand-configured routing delivered every artifact each agent declared it needed; Tileward delivered 66%. Answers were not graded on this flow, but a later run judged them on a blind panel and Tileward came last of four. The whole result.

A recall upgrade fixed 14 answers and broke none LongMemEval-S, our own run on a 150-question sample, self-judged

The arms differ by one upgrade to how Tileward Context recalls conversations; store, questions, model and judge are identical. No question that was right before went wrong after. Paired 95% interval on the overall gain: +5.0 to +15.0 points. The upgrade spends a little of the recall budget on itself, so the after arm sometimes carries slightly less material and still wins.

• Our own harness run of LongMemEval-S on Tileward’s recall path at default settings: a single run of a 150-question sample, 140 scored identically in both arms.
• Tileward 35B-A3B wrote and judged every answer.

2,201 of 2,251 attempts to get past a lock, stopped the same locked request, reworded every way we could

• Hand-authored English corpus across direct locks and prohibited material placed beside allowed work.
• This is coverage of that corpus, not a population security or false-refusal rate.
• Read how a pre-inference gate turns policy into a testable control.