Xyntetik Runner, a Zenova AB product
Lifecycle engine with inference you can prove.
One file that runs AI models on your own machine. It does four things no other engine measured does, and every number on this page links to how it was measured.
Four things you cannot get elsewhere
Measured, not promised.
Train the compressed file you actually serve.
The usual path trains a full-precision copy and ships a different file. Runner trains a small adapter through the 4-bit file you already run, with no Python stack. A Qwen3-4B went from 0.69 to 1.00 on held-out tool calls, two runs wrote the identical adapter, and an outside tester reproduced it on their own card.
Tool calls that survive running out of words.
Six engines were cut off in the middle of a tool call by the token limit. Only Runner handed back something a program could still run, at every budget tested. The others returned nothing usable below the control budget.
A server that gives memory back.
A 63 GB model sitting idle holds 35 MB of your memory under Runner. On the same Mac, llama-server holds 60.8 GB until the process dies. On an 8 GB laptop the pair is 8 MB against 3,819 MB. The cost is one reload on the next request.
Prove afterwards what the model said.
Every served turn can be a signed record, and records chain. Someone else replays them on the same build and gets one of three verdicts: VERIFIED, DIVERGED or UNVERIFIABLE. One command gathers the records, the model's signature and the measured envelope into an evidence pack a reviewer checks offline.
The same discipline runs through the whole lifecycle: a model it does not know is refused by name, a training run records its seed and config, and a 4-bit merge that would erase the fine-tune is refused instead of written.
Replay and pack checks are gated in CI on every release. None of the engines measured claims this. Records a reviewer can check →Why it is hard to copy
Measured side by side, on the same machine.
Runner uses the same model files as llama.cpp, so trying it costs nothing. What is not easily copied is the record behind it: twelve model families scored against their publishers' own implementations, every rejected experiment kept, and a verifier that checks the engine's own claims. These are the rows where the measurements differ.
| Question | Runner | Others measured |
|---|---|---|
| Can you train the compressed file you actually run, and get the same result twice? | Yes, byte for byte, with a provenance record | The adapter Runner writes scores the same in stock llama.cpp, which itself trains only a full-precision model |
| A tool call is cut short by the token limit. What does the program get? | A call it can run, at every budget from 1 to 16 tokens | Nothing usable from vLLM, llama.cpp, Ollama, TensorRT-LLM or SGLang below the control budget |
| How much memory does an idle model keep from the rest of the machine? | 35 MB with a 63 GB model; 8 MB on an 8 GB Mac | llama-server: 60.8 GB and 3,819 MB on the same two machines |
| Can someone else verify what the model said? | Signed, chained records that replay to VERIFIED, DIVERGED or UNVERIFIABLE | Not claimed by the engines measured |
| How close is the output to the model publisher's own implementation? | Closer than llama.cpp on 21 of 22 rows across twelve model families | llama.cpp, given its stronger configuration at each size |
Training: docs/train-lora-on-quantized-gguf.md. Tool calls: 2026-08-19, docs/truncation-benchmark.md. Idle memory: 2026-09-01, docs/idle-coexistence-120b-m5max-2026-09-01.md. Publisher reference: 2026-09-07, docs/golden-pass-2026-09-07.md. Speed tables and every other measurement are on the evidence page.
Before any of that
It read 16 MB of a 5 GB model and already knew.
Before you download anything, Runner looks at the first few megabytes of a model file and tells you whether it will run on your machine, how much lands on the graphics card, and what each memory setting would buy you. Checked against what really happened on load, it named the right split in 70 of 72 tests and was never too optimistic.
Once it fits, the same file can be shrunk with a one-line plan and the cost shown, and the notes a model keeps while it reads fit in about 41% of the usual memory with full agreement on models from 4B to 30B.
Ask before you download →An AI model is a file, a few gigabytes of numbers that do nothing on their own. An engine is the player that opens it and answers on your own computer, so nothing you type is sent anywhere. Runner is a player that shows its work.
Try it
Sixty seconds to a served model.
Download the binary and its checksum file, verify, fetch a model, serve. It speaks the OpenAI and Anthropic APIs, so Claude Code, Codex, OpenCode and your own apps point at it without changes.
Linux and Windows assets, the macOS quarantine note, building from source and the container image are on the Runner page.
curl -LO https://github.com/Joakimpalm-Zen/xyntetik-runner/releases/latest/download/runner-macos-arm64
curl -LO https://github.com/Joakimpalm-Zen/xyntetik-runner/releases/latest/download/SHA256SUMS
shasum -a 256 --check --ignore-missing SHA256SUMS
chmod +x runner-macos-arm64 && mv runner-macos-arm64 runner
curl -L -o model.gguf https://huggingface.co/ibm-granite/granite-4.1-3b-GGUF/resolve/main/granite-4.1-3b-Q8_0.gguf
./runner -m model.gguf --servecurl localhost:8080/v1/chat/completions \
-d '{"messages":[{"role":"user","content":"Say hello in one sentence."}]}'The Xyntetik-Lab on Hugging Face
Model files, with the measurements behind them.
A 3-bit Qwen3.8-27B that fits a 16 GB card whole
Every block scale retrained against the original; the lab's most downloaded file, shown side by side with its source.
Get the file →Kvist-14B, half the size of its parent
Distilled from a 30B model for tool-calling agents on a 24 GB card; it solves 57 of the 60 held-out tasks its parent solves.
Meet Kvist →What survives surgery on a 30B model
Nine preregistered cuts on one frozen Muse-Glimmer-30B; two run with up to 6% of the decoder gone and still pass the fidelity bar.
See the surgery →GENESIS: learning with no human text
Eighteen preregistered experiments on tiny models that only ever saw programs they ran themselves, failures included.
Read the record →