Loom Weave 4

55.6M parameters · 24 layers · 8K context (trained to 32K) · runs on phones · Textile Labs

The best-scoring Loom yet, and the first that runs in phone and desktop chat apps — PocketPal, LM Studio, Jan, llama.cpp, Ollama — straight from the GGUF. Successor to Loom Weave 3. Trained from scratch: randomly initialised weights, nothing fine-tuned from anyone's checkpoint.

127 of 133 on the Loom acceptance battery — the highest of any Loom, including the 155M Crucible Preview — at a third of its size. The phone build (Q4, 44 MB) scores the same 127.

What changed from Weave 3

Measured against Weave 3

Same tests, same scripts, same settings (repeat penalty 1.0), both through Ollama. Every test prompt is scrubbed from the training data.

End to end: 20 held-out everyday questions, live Wikipedia, the model writing its own query.

The acceptance battery, row by row:

Held-out behaviour tests:

Every Loom text model

† scored on a battery with every test prompt scrubbed from training. Earlier rows are each model's release score.

Read this before you use it

Every point here was measured. Weave 4 was built to try three new things; one worked, two did not yet.

• Reasoning on new kinds of task is not reliable. On 100 hand-written tasks of kinds it never trained on (triage, comparing plans, meeting slots, spotting a mistake, filling a form…) it got 11/100. It learned the shape of working things out better than the substance. It shows its working (<think>…</think>) and its answer matches that working, so you can check it — and you should.
• Arithmetic: the working is usually right, the final number often isn't. It writes the column steps correctly ("ones 7 + 5 = 12, write 2 carry 1 …") and then sometimes assembles the result wrongly. Check any sum it gives you.
• The confidence word is not calibrated. Answers end in (sure), (I think) or (not sure). On checkable tasks it was right 13 of 25 times it said sure. Treat it as a hint, not a guarantee.
• Long documents don't work. It was trained in a 32,768-token stage, and llama.cpp will run it at that length, but it could not find a planted fact in a 2,000–8,000-token text. Use it for conversations (it holds a 10-turn chat well), not for reading long documents.
• Standard benchmarks are low, as expected at this size: GSM8K 4/100, ARC-Easy 27/100, StrategyQA 15/100 (it often, correctly, declines world-knowledge questions with tools off).
• It gets half of everyday questions right with search (10/20). "I looked that up" means it searched, not that it read the result correctly — the harness's --show prints what it read. A search can land on the wrong page ("the Four Seasons" → the hotel company).
• Short answers. Replies are a sentence or two — it's built to be brief.
• Warmth is uneven (10/20 on our good-news/bad-news test).
• <recall> and <tool> tags exist in its vocabulary for agent harnesses, but the shipped harness only runs web search.

Usage — phone and desktop chat apps (PocketPal, LM Studio, Jan)

Download loom-weave-4-q4_k_m.gguf (44 MB) or loom-weave-4-q8_0.gguf (60 MB) and load it. The chat template and the stop token are inside the file. Set repeat penalty 1.0.

Usage — the harness (search)

python3 harness.py "whats the capital of peru"
python3 harness.py --show "who wrote hamlet"     # see what it searched and read
python3 harness.py --no-tools "who are you"

Stdlib only; Wikipedia needs no key. Never feed a failed lookup back as a result — the model answers from the error text.

Usage — Ollama / llama.cpp

ollama run hf.co/textilelabs/Loom-Weave-4 "who are you"
llama-cli -m loom-weave-4-q8_0.gguf --jinja -cnv      # uses the template in the GGUF

template and params are read automatically by Ollama. Do not add a repetition penalty.

Usage — transformers (4.50 or newer)

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
tok = AutoTokenizer.from_pretrained("textilelabs/Loom-Weave-4")
model = AutoModelForCausalLM.from_pretrained("textilelabs/Loom-Weave-4").eval()
prompt = tok.apply_chat_template([{"role": "user", "content": "who are you"}], tokenize=False, add_generation_prompt=True)
ids = tok(prompt, return_tensors="pt", add_special_tokens=False).input_ids
out = model.generate(ids, max_new_tokens=160, do_sample=False, eos_token_id=0, pad_token_id=1)
print(tok.decode(out[0][ids.shape[1]:], skip_special_tokens=True))

Raw format (tools on or off): <tools:off>\n<user>\n{message}\n<|eot|>\n<loom>\n.

How it was built

Files

model.safetensors / config.json            the model (transformers)
tokenizer.json / tokenizer_config.json     tokenizer + chat template
loom-weave-4-f16.gguf                      full precision GGUF (112 MB)
loom-weave-4-q8_0.gguf / -q4_k_m.gguf      phone builds (60 / 44 MB) — Q4 scores the same 127/133
template / params / Modelfile              Ollama
harness.py                                 runnable search harness — stdlib only
ATTRIBUTION.md                             required credits for the training data

Thanks

Thanks to Andrew Thompson for his analysis of the vocabulary's share of a small model, which directly shaped Weave 4's 16K tokenizer — the word table is 13% of the model, not 20%.

License

Model: MIT. Training data keeps its original licences — see ATTRIBUTION.md.