Upload 18 files

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+banner.jpeg filter=lfs diff=lfs merge=lfs -text
+logo.jpeg filter=lfs diff=lfs merge=lfs -text
+loom-swift-micro-2-f16.gguf filter=lfs diff=lfs merge=lfs -text
+loom-swift-micro-2-q4_k_m.gguf filter=lfs diff=lfs merge=lfs -text
+loom-swift-micro-2-q8_0.gguf filter=lfs diff=lfs merge=lfs -text

ATTRIBUTION.md

@@ -0,0 +1,20 @@
+# Attribution
+
+Loom Swift 2 (Mini and Micro) were trained from scratch: randomly initialised weights, no third-party checkpoint. Each ran for a
+fixed few minutes on two NVIDIA T4s. Some licences below require attribution; this file satisfies that and must be kept with any
+redistribution.
+
+| slice | source | licence |
+|---|---|---|
+| topic labelling | DBpedia-14 (fancyzhx/dbpedia_14) | CC BY-SA 3.0 |
+| sentiment labelling | Amazon Polarity (fancyzhx/amazon_polarity) | Apache 2.0 |
+| toxicity labelling | Civil Comments (google/civil_comments) | CC0 1.0 |
+| language labelling, request wording | MASSIVE (AmazonScience/massive) | CC BY 4.0 |
+| 757 kinds of instruction | Super-NaturalInstructions | Apache 2.0 |
+| human explanations of entailment | e-SNLI | MIT |
+| common-sense questions | CommonsenseQA (MIT), ARC (CC BY-SA 4.0) | as listed |
+| human question decompositions | StrategyQA | MIT |
+| conversation replay (identity, limits, declines, tool use) | the Loom Weave 4 training mix: Wikipedia (CC BY-SA 3.0 / GFDL), SQuAD 2.0 (CC BY-SA 4.0), databricks-dolly-15k (CC BY-SA 3.0), OpenAssistant OASST1 (Apache 2.0), GSM8K (MIT) and Textile Labs program-generated data (MIT) | as listed |
+| reading a search result, injection inside a passage, extraction, redaction, calculator and date calls, tool errors, everyday chat | Textile Labs (program-generated from Wikipedia text and program-checked) | MIT / CC BY-SA 3.0 for the Wikipedia text |
+
+Model weights: MIT.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Textile Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Modelfile

@@ -0,0 +1,16 @@
+FROM ./loom-swift-micro-2-q8_0.gguf
+TEMPLATE """<tools:off>
+<user>
+{{ .Prompt }}
+<|eot|>
+<loom>
+"""
+PARAMETER stop "<|eot|>"
+PARAMETER stop "<user>"
+PARAMETER stop "<result>"
+PARAMETER stop "<output>"
+PARAMETER temperature 0.7
+PARAMETER top_k 40
+PARAMETER repeat_penalty 1.0
+PARAMETER num_predict 200
+PARAMETER num_ctx 2048

README.md

@@ -1,3 +1,196 @@
 ---
 license: mit
+language: en
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- tiny-model
+- gemma3
+- from-scratch
+- conversational
+- tool-use
+- agent-harness
+- calculator
+- humble-ai
+- small-language-model
+- muon
+- gguf
+- on-device
+- experimental
+widget:
+- text: "<tools:off>\n<user>\nwho are you\n<|eot|>\n<loom>\n"
+  example_title: "Identity"
+- text: "<tools:on>\n<user>\nwhat's 482 + 539?\n<|eot|>\n<loom>\n"
+  example_title: "Writes a calculator call"
+- text: "<tools:off>\n<user>\nwhat's the weather in Paris right now?\n<|eot|>\n<loom>\n"
+  example_title: "Limits"
 ---
+
+<div align="center">
+<img src="banner.jpg" alt="Loom Swift Micro 2" width="520">
+</div>
+
+# Loom Swift Micro 2
+
+<img src="logo.jpg" alt="" width="20" height="20" style="border-radius:4px;vertical-align:middle;margin-right:6px;"> **1,172,832 parameters · 12 layers × 96d · 2K context · runs on phones · Textile Labs**
+
+Loom Swift Micro 2 is a 1.17-million-parameter model trained for five minutes. It is the smallest Loom: it chats briefly, knows who it is, declines what it can't know, and writes calculator and date calls — and it runs in phone apps.
+It is the second generation of [Loom Swift Micro](https://huggingface.co/textilelabs/Loom-Swift-Micro), retrained on Kaggle's two T4 GPUs for the same 5 minutes the original spent on a CPU,
+and rebuilt on the Gemma-3 layout so it runs in PocketPal, LM Studio, Jan, llama.cpp and Ollama straight from the GGUF.
+Trained from scratch: randomly initialised weights, nothing fine-tuned from anyone's checkpoint.
+
+> ## Read this first
+> This is a **tiny model for tiny jobs**, and it is honest about the limits we measured. It is not a reader and it is not a reasoner.
+> What it does is: say who it is, decide when a tool is needed, write a calculator / date / search call, and (Mini) label and extract from short text.
+> It is published as a small, fast, on-device experiment — not as a strict upgrade. The "Read this before you use it" section below lists every miss.
+
+## What changed from the original
+
+| | Loom Swift Micro | **Loom Swift Micro 2** |
+|---|---|---|
+| layout | Llama | **Gemma-3 style** (local sliding window + a global layer every 6th) |
+| tokenizer | 4,096 BPE | **4,096 BPE rebuilt, every digit its own token, identical in llama.cpp** |
+| context | 512 | **2,048** |
+| runs in phone/desktop chat apps | no | **yes — chat template and end-of-turn built into the GGUF** |
+| new jobs | — | calculator calls, date arithmetic, labelling, extraction, redaction, reading a search result |
+| trained on | a 2013 office CPU | Kaggle 2 × T4 |
+| training time | 10 / 5 minutes | the same: **5 minutes** of training |
+
+## Measured against the original
+
+Same tests, same scripts, same settings (repeat penalty 1.0), both through Ollama. Every test prompt is scrubbed from the training data.
+
+**The Loom acceptance battery**, row by row:
+
+| row | original | **Loom Swift Micro 2** |
+|---|---:|---:|
+| A · says its own name | 11/12 | 11/12 |
+| B · its own name under rough typing | 11/12 | 11/12 |
+| C · 5-turn conversation stays on thread | 5/5 | 5/5 |
+| D · answers from a search result | 0/5 | 3/5 |
+| E · follow-up answered from the same result | 0/5 | 0/5 |
+| F · says it looked, after a lookup | 5/5 | 0/5 |
+| G · **never** claims a lookup it didn't make | 16/16 | 16/16 |
+| H · admits what it can't know about you | 7/8 | 5/8 |
+| I · says when a result doesn't contain the answer | 0/5 | 3/5 |
+| J · never leaks a search tag with tools off | 28/28 | 28/28 |
+| K · stops on its own | 12/12 | 12/12 |
+| L · searches when it should | 15/20 | 16/20 |
+| **total** | **110/133** | **110/133** |
+
+**New jobs** (our own frozen test set; the original Swifts never trained on most of these, so most of their zeros are expected):
+
+| job (275 held-out items, each prompt scrubbed from training) | original Swift Micro | **Swift Micro 2** |
+|---|---:|---:|
+| everyday chat | 4/15 | **11/15** |
+| declining an unknown fact, tools off (strict scorer) | 18/20* | 18/20 |
+| ignoring an instruction inside a passage | 0/10 | **4/10** |
+| labelling (topic / language / sentiment / toxic / route) | 0/60 | **28/60** |
+| calculator call correct | 0/40 | **13/40** |
+| date arithmetic | 0/10 | **3/10** |
+| reading a retrieved passage | 0/60 | **4/60** |
+| typed extraction | 0/30 | 0/30 |
+| redaction (exact match) | 0/30 | 0/30 |
+| saying "(sure)" and being right | — | 22% of 82 |
+
+*the original was scored with a looser scorer.
+
+Q8_0 and Q4_K_M behave the same within a few items (Q8: label 30/60, inject 5/10; Q4: label 27/60, inject 1/10 — injection resistance is the least stable part).
+
+## Every Loom text model
+
+| model | params | battery /133 | live search (held-out) | reads real prose | runs in phone apps |
+|---|---:|---:|---:|---|---|
+| Loom Spark 2 | 19.9M | ~97 | 2/20 | no | no |
+| Loom Tapestry 2 | 22.8M | 107 | — | curated only | no |
+| Loom Tapestry 3 Flash | 7.18M | 112 | 3/20 | curated only | no |
+| Loom Spark 3 Flash | 7.18M | 119 | 5/20 | curated only | no |
+| Loom Spark 3 | 12.2M | 120 | 7/20 | curated only | no |
+| Loom Spark 3.2 | 22.8M | 122† | 7/20 | curated only | no |
+| Loom Weave 3 | 31.5M | 120 | 6/20 | yes | no |
+| Loom Tapestry 3 | 69.2M | 123 | 12/20 | yes + multi-hop | no |
+| Loom Crucible Preview | 155.0M | 125† | 10/20 | yes — best curated reader | no |
+| Loom Weave 4 | 55.6M | 127† | 10/20 | yes | yes |
+| Loom Swift Mini (original) | 2.0M | 110‡ | — | no | no |
+| Loom Swift Micro (original) | 1.16M | 110‡ | — | no | no |
+| Loom Swift Mini 2 | 2.0M | 120 | not measured | barely (12% on 200–1,500-token passages) | yes |
+| **Loom Swift Micro 2** | **1.17M** | **110** | not measured | barely (7%) | **yes** |
+
+† scored on a battery with every test prompt scrubbed from training. ‡ the two original Swifts re-scored today with the same script and settings as the Swift 2s (their release scores were 106 and 104). Earlier rows are each model's release score. Never compare scores from different command lines.
+
+## Read this before you use it
+
+Every point was measured on our own held-out tests.
+
+- **It is weaker than Swift Mini 2 at almost everything.** Calculator calls 13/40, dates 3/10, labelling 28/60, reading 4/60, extraction and redaction 0.
+- **On the acceptance battery it ties the original (110/133) and is worse in two places**: attribution after a lookup went from 5/5 to 0/5 and admitting an unknowable from 7/8 to 5/8. It is better at reading a result (3/5 vs 0/5) and at saying a result doesn't contain the answer (3/5 vs 0/5).
+- **Its "(sure)" is nearly meaningless**: right 22% of the time it says it.
+- **Do not use it for calculation, extraction or redaction.** It is here for what a 1-million-parameter file can do in five minutes of training: answer who it is, chat briefly, decline, and decide when a tool is needed.
+- Replies are one or two short sentences. 2,048 tokens of context.
+
+## Usage — phone and desktop chat apps (PocketPal, LM Studio, Jan)
+
+Download `loom-swift-micro-2-q4_k_m.gguf` (1.2 MB) or `loom-swift-micro-2-q8_0.gguf` (1.4 MB) and load it. The chat template and the stop token are inside the file.
+Set **repeat penalty 1.0**. The model only writes tool calls (`<tool>calc 482 + 539</tool>`); a chat app will not run them for you — use the harness for that.
+
+## Usage — the harness (search, calculator, date)
+
+```bash
+python3 harness.py "whats the capital of peru"
+python3 harness.py "what is 482 + 539"
+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. Calculator and date calls run locally; a calculator error comes back as `error`. **Never feed a failed lookup back as a result** — the model answers from the error text.
+
+## Usage — Ollama / llama.cpp
+
+```bash
+ollama run hf.co/textilelabs/Loom-Swift-Micro-2 "who are you"
+llama-cli -m loom-swift-micro-2-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)
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+tok = AutoTokenizer.from_pretrained("textilelabs/Loom-Swift-Micro-2")
+model = AutoModelForCausalLM.from_pretrained("textilelabs/Loom-Swift-Micro-2").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=120, do_sample=False)
+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
+
+| | |
+|---|---|
+| architecture | Gemma-3 layout: 12 layers × 96d (10 sliding-window 512 + 2 global), 2 query heads / 1 KV head of 32, GeGLU 160, tied embeddings, QK-norm |
+| parameters | 1,172,832 |
+| vocabulary | 4,096 byte-level BPE, single digits, Qwen2-style pre-tokenizer (identical tokens in llama.cpp) |
+| training | 5 minutes from random init, 608 steps, 40M tokens at 2,048 context; a second, focused phase for the last third |
+| optimiser | Muon on 2-D hidden matrices, AdamW on embeddings and norms; per-conversation attention masking |
+| attention check | before the run, the trainer's attention is checked against the reference implementation (loss and gradients identical) |
+| hardware | Kaggle, 2 × NVIDIA T4 |
+
+## Files
+
+```
+model.safetensors / config.json            the model (transformers)
+tokenizer.json / tokenizer_config.json     tokenizer + chat template
+loom-swift-micro-2-f16.gguf                       full precision GGUF (2.5 MB)
+loom-swift-micro-2-q8_0.gguf / -q4_k_m.gguf       phone builds (1.4 MB / 1.2 MB)
+template / params / Modelfile              Ollama
+harness.py                                 runnable harness — search, calculator, date; stdlib only
+ATTRIBUTION.md                             required credits for the training data
+```
+
+## License
+
+Model: MIT. Training data keeps its original licences — see ATTRIBUTION.md.

config.json

@@ -0,0 +1,56 @@
+{
+  "_sliding_window_pattern": 6,
+  "architectures": [
+    "Gemma3ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_logit_softcapping": null,
+  "bos_token_id": null,
+  "dtype": "float32",
+  "eos_token_id": 0,
+  "final_logit_softcapping": null,
+  "head_dim": 32,
+  "hidden_activation": "gelu_pytorch_tanh",
+  "hidden_size": 96,
+  "initializer_range": 0.02,
+  "intermediate_size": 160,
+  "layer_types": [
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 2048,
+  "model_type": "gemma3_text",
+  "num_attention_heads": 2,
+  "num_hidden_layers": 12,
+  "num_key_value_heads": 1,
+  "pad_token_id": 1,
+  "query_pre_attn_scalar": 32,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "full_attention": {
+      "rope_theta": 1000000.0,
+      "rope_type": "default"
+    },
+    "sliding_attention": {
+      "rope_theta": 10000.0,
+      "rope_type": "default"
+    }
+  },
+  "sliding_window": 512,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.16.1",
+  "use_bidirectional_attention": false,
+  "use_cache": true,
+  "vocab_size": 4096
+}

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": 0,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "pad_token_id": 1,
+  "transformers_version": "5.16.1",
+  "use_cache": false
+}

harness.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""Loom Swift 2 harness — search, calculator and date for Loom Swift Mini 2 / Micro 2.
+
+The model never searches or calculates. It decides a tool is needed and writes the call:
+
+    <lookup>france</lookup>          -> this script searches Wikipedia and hands back <result>
+    <tool>calc 482 + 539</tool>      -> this script runs the calculator and hands back <output>
+    <tool>date +20d</tool>           -> this script reads your clock and hands back <output>
+    (calc errors — malformed, unsafe, divide by zero — come back as "error"; a long search result is cut to fit the 2,048-token context)
+
+This script does the rest: searches Wikipedia, finds the ONE sentence most likely to
+hold the answer, hands it back as a <result>, and lets the model answer from it.
+
+    python3 harness.py "what's the capital of france"
+    python3 harness.py                          # interactive
+    python3 harness.py --no-tools "who are you"
+    python3 harness.py --show "who wrote hamlet"   # print what was searched and read
+
+How it finds the answer, and why each step exists (all measured on live questions):
+  * searches the model's query AND the subject it can see in your question —
+    "whats the capital of france" searched as-is returns "Capital city" and "Das Kapital"
+  * prefers the real article over lists, films, albums and disambiguation pages
+  * reads the article's intro first, and further only when the intro has no answer of
+    the right kind (a height with a unit, a year, a number, a name)
+  * strips brackets and pronunciation guides, so real text looks like training text
+  * hands back ONE sentence. A 340-character window found the answer more often but the
+    model misread it four times in five; one sentence doubled the final score (15% -> 30%)
+
+Swap search() for anything you like — the contract is text in, one sentence out.
+Wikipedia needs no API key. Stdlib only.
+"""
+from __future__ import annotations
+
+import argparse, ast, datetime, json, operator, re, ssl, sys, time, urllib.error, urllib.parse, urllib.request
+
+try:                                    # macOS system Python often lacks a CA bundle
+    import certifi
+    SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+except Exception:
+    SSL_CTX = ssl.create_default_context()
+
+# ------------------------------------------------------------------ calculator + date (stdlib; identical to the functions the model was trained against)
+_OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.Pow: operator.pow, ast.USub: operator.neg, ast.Mod: operator.mod}
+def calc_eval(expr: str) -> str:
+    def ev(n):
+        if isinstance(n, ast.Expression): return ev(n.body)
+        if isinstance(n, ast.Constant) and isinstance(n.value, (int, float)): return n.value
+        if isinstance(n, ast.BinOp) and type(n.op) in _OPS:
+            if isinstance(n.op, ast.Pow) and abs(ev(n.right)) > 12: raise ValueError("power too large")
+            return _OPS[type(n.op)](ev(n.left), ev(n.right))
+        if isinstance(n, ast.UnaryOp) and type(n.op) in _OPS: return _OPS[type(n.op)](ev(n.operand))
+        raise ValueError(expr)
+    v = ev(ast.parse(expr.strip(), mode="eval")); return str(int(v)) if float(v).is_integer() else f"{v:.6g}"
+
+def safe_calc(expr: str) -> str:
+    """Any failure — malformed, unsafe, divide by zero, too large — is the word 'error', never a crash and never a made-up number."""
+    try: return calc_eval(expr)
+    except Exception: return "error"
+
+def today() -> datetime.date: return datetime.date.today()
+
+def date_eval(cmd: str, day: datetime.date) -> str:
+    """cmd: 'today' | '+Nd' | '-Nd' | 'YYYY-MM-DD to YYYY-MM-DD' -> '2026-11-14 (Saturday)' or '45 days'."""
+    cmd = cmd.strip()
+    if cmd == "today": d = day
+    elif m := re.fullmatch(r"([+-])(\d+)d", cmd): d = day + datetime.timedelta(days=int(m[2]) * (1 if m[1] == "+" else -1))
+    elif m := re.fullmatch(r"(\d{4}-\d{2}-\d{2}) to (\d{4}-\d{2}-\d{2})", cmd):
+        a, b = datetime.date.fromisoformat(m[1]), datetime.date.fromisoformat(m[2]); return f"{abs((b - a).days)} days"
+    else: raise ValueError(cmd)
+    return f"{d.isoformat()} ({d.strftime('%A')})"
+
+def safe_date(cmd: str) -> str:
+    try: return date_eval(cmd, today())
+    except Exception: return "error"
+
+TOOL = re.compile(r"<tool>\s*(calc|date)\s+(.*?)</tool>", re.S)
+
+# ------------------------------------------------------------------ context cap
+MAX_RESULT_TOKENS = 1200                 # the model reads up to ~1,500 tokens of result; 2,048 minus the question, the reply and a margin
+
+def fit_result(text: str, tok_budget: int = MAX_RESULT_TOKENS) -> tuple:
+    """Cut a retrieved passage at a sentence boundary so it fits the context (~3.3 characters per token). Returns (text, truncated).
+    No marker is added to the text: the model was never trained on one, and an unseen marker would be read as content."""
+    cap = int(tok_budget * 3.3)
+    if len(text) <= cap: return text, False
+    out = ""
+    for s in re.split(r"(?<=[.!?]) +", text):
+        if len(out) + len(s) + 1 > cap: break
+        out = (out + " " + s).strip()
+    return (out or text[:cap]), True
+
+OLLAMA = "http://localhost:11434/api/generate"
+MODEL = "hf.co/textilelabs/Loom-Swift-Micro-2"
+API = "https://en.wikipedia.org/w/api.php?"
+# Wikipedia returns 403 without a descriptive User-Agent.
+UA = {"User-Agent": "LoomHarness/3.0 (Textile Labs; https://huggingface.co/textilelabs)"}
+LOOKUP = re.compile(r"<lookup>(.*?)</lookup>", re.S)
+_cache: dict = {}
+
+# ------------------------------------------------------------------- the model
+def loom(prompt: str, n: int = 64) -> str:
+    body = json.dumps({"model": MODEL, "prompt": prompt, "raw": True, "stream": False,
+                       "options": {"temperature": 0, "num_predict": max(n, 160), "repeat_penalty": 1.0, "num_ctx": 2048,
+                                   "stop": ["<|eot|>", "<user>", "<result>", "<output>"]}}).encode()
+    req = urllib.request.Request(OLLAMA, data=body, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return json.load(r)["response"].strip()
+
+# ------------------------------------------------------------------ wikipedia
+def _get(params: dict) -> dict:
+    key = json.dumps(params, sort_keys=True)
+    if key in _cache:
+        return _cache[key]
+    for attempt in range(3):
+        try:
+            with urllib.request.urlopen(urllib.request.Request(
+                    API + urllib.parse.urlencode(params), headers=UA),
+                    context=SSL_CTX, timeout=20) as r:
+                _cache[key] = json.load(r)
+                return _cache[key]
+        except urllib.error.HTTPError as e:
+            if e.code in (429, 502, 503, 504):
+                time.sleep(3 * (attempt + 1)); continue
+            raise
+    raise RuntimeError("Wikipedia busy or rate-limited — try again")
+
+def search(q: str, n: int = 3) -> list:
+    return [h["title"] for h in _get({"action": "query", "list": "search", "srsearch": q,
+                                      "format": "json", "srlimit": n})["query"]["search"]]
+
+def _extract(title: str, intro: bool) -> str:
+    p = {"action": "query", "prop": "extracts", "explaintext": 1, "titles": title,
+         "format": "json", "redirects": 1}
+    if intro:
+        p["exintro"] = 1
+    return next(iter(_get(p)["query"]["pages"].values())).get("extract", "") or ""
+
+# ------------------------------------------------------------------ the finder
+SENT = re.compile(r"(?<=[.!?])\s+(?=[A-Z0-9])")
+PAREN = re.compile(r"\s*\([^()]*\)")
+HEADING = re.compile(r"^\s*=+[^=]+=+\s*$", re.M)
+STOP = set(("what whats who whos whom whose when where which why how is are was were be the a an "
+            "of in on to for does did do by from with as at and or that this it its there tell me "
+            "please can you many much").split())
+ATTR = set(("capital city height tall high elevation population largest biggest smallest longest "
+            "shortest tallest highest deepest first last symbol chemical language languages spoken "
+            "legs year date end ended sink sank invented inventor discovered discovery developed "
+            "wrote written author painted painter president founded born died age old size area "
+            "distance speed").split())
+JUNK = re.compile(r"^(lists? of|outline of|index of|timeline of)\b|\((film|album|song|band|"
+                  r"novel|play|tv series|musical|opera|video game|book|composition|poem)\)|"
+                  r"\bdisambiguation\b", re.I)
+
+def keywords(t: str) -> list:
+    return [w for w in re.findall(r"[^\W_]+", t.lower()) if w not in STOP]
+
+def subject(question: str) -> str:
+    kw = keywords(question)
+    return " ".join(k for k in kw if k not in ATTR) or " ".join(kw)
+
+def clean(t: str) -> str:
+    prev = None
+    while prev != t:
+        prev, t = t, PAREN.sub("", t)
+    return re.sub(r"\s+", " ", t.replace(" ,", ",")).strip()
+
+def _hard(q: str, s: str) -> float:
+    """The answer is of the right KIND: a height with a unit, a year, a number, a name."""
+    b = 0.0
+    if re.search(r"\b(how tall|how high|height|elevation)\b", q):
+        b += 2.0 if re.search(r"\d[\d,.]*\s*(m|metres|meters|ft|feet|km)\b", s) else 0
+    if re.search(r"\b(when|what year|which year|what date)\b", q):
+        b += 2.0 if re.search(r"\b(1\d{3}|20\d{2})\b", s) else 0
+    if re.search(r"\b(how many|how much|population|number of)\b", q):
+        b += 1.5 if re.search(r"\d", s) else 0
+    if re.search(r"\bwho\b", q):
+        b += 1.5 if re.search(r"\b[A-Z][a-z]+ [A-Z][a-z]+", s) else 0
+    if re.search(r"\bsymbol\b", q):
+        b += 2.0 if re.search(r"\bsymbol\b", s, re.I) else 0
+    if re.search(r"\bcapital\b", q):
+        b += 2.0 if re.search(r"\bcapital\b", s, re.I) else 0
+    return b
+
+def _kind(q: str, s: str) -> float:
+    b, sl = _hard(q, s), s.lower()
+    if re.search(r"\b(how tall|how high|height|elevation)\b", q):
+        b += 1.5 if re.search(r"\b(summit|elevation|height|above sea level|highest|stands)\b", sl) else -0.5
+    if re.search(r"\b(end|ended|finish|finished)\b", q):
+        b += 1.5 if re.search(r"\b(ended|end of|surrender|surrendered|concluded|finished)\b", sl) else -0.5
+    if re.search(r"\bpopulation\b", q):
+        b += 2.0 if re.search(r"\d{1,3}(,\d{3})+|\d+(\.\d+)?\s*(million|billion)", s) else -1.0
+    if re.search(r"\b(invent|invented|inventor|discovered|wrote|painted|composed|founded)\b", q):
+        b += 1.0 if re.search(r"\b[A-Z][a-z]+ (?:[A-Z][a-z]+ )?[A-Z][a-z]+\b", s) else 0.0
+    return b
+
+def find(query: str, question: str) -> tuple:
+    """One sentence most likely to hold the answer, and the article it came from."""
+    q = question.lower()
+    subj = subject(question)
+    pool = {}
+    for tq in dict.fromkeys(x for x in (query.strip(), subj, " ".join(keywords(question))) if x):
+        for rank, t in enumerate(search(tq, 3)):
+            tl = t.lower()
+            s = (4.0 if tl in (subj, query.strip().lower()) else 2.0 if subj and tl.startswith(subj) else 0.0)
+            s += -4.0 if JUNK.search(t) else 0.0
+            pool[t] = max(pool.get(t, -1e9), s - 0.3 * rank)
+    qk = list(dict.fromkeys(keywords(question) + keywords(query)))
+    top = sorted(pool.items(), key=lambda x: -x[1])[:3]
+    typed = bool(re.search(r"\b(how tall|how high|height|elevation|when|what year|which year|"
+                           r"how many|how much|population|who|symbol|capital)\b", q))
+    best = (-1e9, "", "")
+    for intro in (True, False):
+        found_kind = False
+        for title, ps in top:
+            raw = _extract(title, intro)
+            if re.search(r"\b(may|can) refer to\b", raw[:400]):
+                continue
+            body = clean(HEADING.sub(" ", raw))
+            sents = [s.strip() for s in SENT.split(body) if 20 < len(s.strip()) < 600]
+            for i, s in enumerate(sents[: 14 if intro else 90]):
+                sc = ps + sum(1.0 for k in qk if k in s.lower()) + _kind(q, s) + (0.5 if i < 3 else 0.0)
+                if sc > best[0]:
+                    best = (sc, s, title)
+                    found_kind = _hard(q, s) > 0
+        if best[1] and (not typed or found_kind):
+            break                       # the intro held an answer of the right kind
+    return best[1], best[2]
+
+# ------------------------------------------------------------------ the loop
+def ask(message: str, tools: bool = True, show: bool = False) -> str:
+    convo = f"<tools:{'on' if tools else 'off'}>\n<user>\n{message.strip()}\n<|eot|>\n<loom>\n"
+    first = loom(convo)
+    t = TOOL.search(first)
+    if t:                                                            # calculator / date: run it, hand back the output
+        kind, arg = t.group(1), t.group(2).strip(); out = safe_calc(arg) if kind == "calc" else safe_date(arg)
+        if show: print(f"    [{kind}: {arg!r} -> {out}]")
+        return loom(convo + first + f"<|eot|>\n<output>\n{out}\n<|eot|>\n<loom>\n", n=64)
+    m = LOOKUP.search(first)
+    if not m:
+        return first
+    query = m.group(1).strip()
+    try:
+        result, source = find(query, message)
+    except Exception as e:
+        # Never feed an error in as if it were a result — the model will answer from it.
+        return f"[harness] lookup failed for {query!r}: {e}"
+    if not result:
+        return f"[harness] nothing found for {query!r}"
+    result, cut = fit_result(result)
+    if show:
+        print(f"    [searched: {query!r}]\n    [read from {source}: {result[:150]}]" + ("\n    [harness] result shortened to fit the context" if cut else ""))
+    return loom(convo + first + f"<|eot|>\n<result>\n{result}\n<|eot|>\n<loom>\n", n=64)
+
+def main() -> int:
+    global MODEL
+    ap = argparse.ArgumentParser(description="Loom Swift 2 harness")
+    ap.add_argument("message", nargs="*")
+    ap.add_argument("--no-tools", action="store_true", help="chat only, no lookups")
+    ap.add_argument("--show", action="store_true", help="print the query and the sentence read")
+    ap.add_argument("--model", default=MODEL)
+    a = ap.parse_args()
+    MODEL = a.model
+    if a.message:
+        print(ask(" ".join(a.message), not a.no_tools, a.show)); return 0
+    print(f"Loom Swift harness — {MODEL} (tools {'off' if a.no_tools else 'on'}, ctrl-c to quit)\n")
+    while True:
+        try:
+            msg = input("you  > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print(); return 0
+        if msg:
+            print(f"loom > {ask(msg, not a.no_tools, a.show)}\n")
+
+if __name__ == "__main__":
+    sys.exit(main())

loom-swift-micro-2-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1521a5fee2bb983315afa454c202d08dfab077776b64d3129180056880dc6123
+size 2493984

loom-swift-micro-2-q4_k_m.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53a92b7471f80ac99f79b9192df478dffd6b1de4c42e87b84cb6cc87a49d243c
+size 1150752

loom-swift-micro-2-q8_0.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:582de9965742c6b78002cd64c7991c07f9f801fbfb99c80bbf180fccb6e6f4cb
+size 1399584

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5428f86cab43f08e8b45e2c6ddeb6876f1ebe8eda93f764295151d4ba905b76f
+size 4708104

params

@@ -0,0 +1,8 @@
+{
+  "stop": ["<|eot|>", "<user>", "<result>", "<output>"],
+  "temperature": 0.7,
+  "top_k": 40,
+  "repeat_penalty": 1.0,
+  "num_predict": 200,
+  "num_ctx": 2048
+}

special_tokens_map.json

@@ -0,0 +1,22 @@
+{
+ "eos_token": "<|eot|>",
+ "pad_token": "<|pad|>",
+ "additional_special_tokens": [
+  "<tools:off>",
+  "<tools:on>",
+  "<user>",
+  "<loom>",
+  "<think>",
+  "</think>",
+  "<recall>",
+  "</recall>",
+  "<memory>",
+  "<lookup>",
+  "</lookup>",
+  "<result>",
+  "<tool>",
+  "</tool>",
+  "<output>",
+  "<doc>"
+ ]
+}

template

@@ -0,0 +1,5 @@
+<tools:off>
+<user>
+{{ .Prompt }}
+<|eot|>
+<loom>

tokenizer_config.json

@@ -0,0 +1,11 @@
+{
+ "tokenizer_class": "PreTrainedTokenizerFast",
+ "add_bos_token": false,
+ "add_eos_token": false,
+ "bos_token": null,
+ "eos_token": "<|eot|>",
+ "pad_token": "<|pad|>",
+ "unk_token": null,
+ "model_max_length": 131072,
+ "clean_up_tokenization_spaces": false
+}