Upload 17 files

.gitattributes

@@ -33,3 +33,6 @@ 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.jpg filter=lfs diff=lfs merge=lfs -text
+logo.jpg filter=lfs diff=lfs merge=lfs -text
+loom-tapestry-2-f16.gguf filter=lfs diff=lfs merge=lfs -text

ATTRIBUTION.md

@@ -0,0 +1,37 @@
+# Training data attribution
+
+Loom Spark 2 was trained on several openly licensed corpora. Some of these licences
+require attribution; this file satisfies that requirement and must be kept with any
+redistribution.
+
+## SQuAD 2.0 — CC BY-SA 4.0
+Rajpurkar, Jia & Liang. "Know What You Don't Know: Unanswerable Questions for SQuAD."
+https://rajpurkar.github.io/SQuAD-explorer/
+Used for grounded reading, and — via its unanswerable questions — for teaching the model
+to say when a result does not contain the answer.
+
+## MASSIVE — CC BY 4.0
+Amazon. https://github.com/alexa/massive
+Derived from SLURP, also CC BY 4.0. Used for tool-decision training.
+
+## CLINC150 — CC BY 3.0
+Larson et al. "An Evaluation Dataset for Intent Classification and Out-of-Scope
+Prediction." https://github.com/clinc/oos-eval
+Used for tool-decision training.
+
+## databricks-dolly-15k — CC BY-SA 3.0
+Databricks. https://huggingface.co/datasets/databricks/databricks-dolly-15k
+Used for instruction following.
+
+## OpenAssistant OASST1 — Apache 2.0
+LAION / OpenAssistant. https://huggingface.co/datasets/OpenAssistant/oasst1
+Used for multi-turn dialogue structure. Only English conversations with short assistant
+replies were kept.
+
+## Persona curriculum — Textile Labs
+Identity, limits, warmth and brevity were written for Loom and are not derived from any
+public dataset.
+
+Only English portions were used. No source text was altered except for truncation of
+passages to a realistic tool-result length, and surface augmentation (casing, punctuation,
+filler) applied to user turns in training copies only.

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,15 @@
+FROM ./loom-tapestry-2-f16.gguf
+TEMPLATE """<tools:off>
+<user>
+{{ .Prompt }}
+<|eot|>
+<loom>
+"""
+PARAMETER stop "<|eot|>"
+PARAMETER stop "<user>"
+PARAMETER stop "<result>"
+PARAMETER temperature 0.7
+PARAMETER top_k 40
+PARAMETER repeat_penalty 1.15
+PARAMETER repeat_last_n 64
+PARAMETER num_predict 96

README.md

@@ -1,3 +1,241 @@
 ---
 license: mit
+language: en
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- tiny-model
+- llama
+- from-scratch
+- conversational
+- tool-use
+- agent-harness
+- retrieval-augmented
+- attribution
+- calibrated-honesty
+- humble-ai
+- philosophy-of-mind
+- small-language-model
+- cpu-trained
+- muon
+- gguf
+- text-generation-inference
+widget:
+- text: "<tools:off>\n<user>\nwho are you\n<|eot|>\n<loom>\n"
+  example_title: "Identity"
+- text: "<tools:off>\n<user>\nwhat is my sisters name\n<|eot|>\n<loom>\n"
+  example_title: "Limits"
+- text: "<tools:on>\n<user>\nwhat is the capital of peru\n<|eot|>\n<loom>\n"
+  example_title: "Lookup"
 ---
+
+<div align="center">
+<img src="banner.jpg" alt="Loom Tapestry 2" width="520">
+</div>
+
+# Loom Tapestry 2
+
+<img src="logo.jpg" alt="" width="20" height="20" style="border-radius:4px;vertical-align:middle;margin-right:6px;"> **22.8M parameters · 20 layers · 768 context · Textile Labs**
+
+The first model in the **Tapestry** tier. Loom tiers run **Flash → Spark → Weave → Tapestry**.
+
+Trained from scratch on a 2013 desktop CPU — randomly initialised weights, nothing
+fine-tuned from a pretrained base.
+
+**It looks things up, and it tells you when it did.**
+
+```
+who are you              →  Loom Tapestry 2, a small model by Textile Labs.
+what is my sisters name  →  I don't know that about you.
+
+what is the capital of peru
+  →  <lookup>what is the capital of peru</lookup>
+  ←  Lima is the capital and largest city of Peru…
+  →  Lima is the capital and largest city of Peru. I had to look that up.
+how many people live there
+  →  9.7 million.          ← same result, no second lookup
+```
+
+## Why "I looked that up" matters
+
+Most small models make you guess which of their answers to trust. Tapestry has three
+honest registers, and you can tell them apart **by reading**:
+
+| situation | what it does |
+|---|---|
+| answered from a retrieved `<result>` | **says it looked it up** |
+| answered from training | answers plainly |
+| cannot be known | *"I don't know that about you."* |
+
+It never claims a lookup it didn't make — **16/16** on that check below. A false
+attribution would be worse than none, so that is the one number held to 100%.
+
+## Measured
+
+Full acceptance battery, hand-written prompts held out of the training generator,
+scored on **content** rather than shape. Every failure is listed rather than summarised.
+
+| | score | |
+|---|---:|---|
+| no false attribution | **16/16** | never claims a lookup it didn't make |
+| no `<lookup>` leak with tools off | **28/28** | |
+| self-terminates without a Modelfile | **12/12** | |
+| answers from a supplied `<result>` | **5/5** | |
+| identity — names Tapestry | **11/12** | |
+| attribution present after a real lookup | **4/5** | |
+| identity under CAPS / typos / "?" | **10/12** | |
+| 5-turn conversation stays on thread | **4/5** | |
+| admits an unknowable | **4/8** | |
+| follow-up answered from the same result | **2/5** | |
+| says the result doesn't contain it | **1/5** | first Loom to score above zero |
+| tool decision with tools **on** | **10/20** | 10/10 correct when a lookup *is* needed; **0/10** when it is not — see below |
+| **overall** | **107/133 · 80.5%** | |
+
+### Against the previous generation
+
+Identical corpus family, same evaluation method.
+
+| | params | val loss | val accuracy |
+|---|---:|---:|---:|
+| Loom Spark 2 | 19.9M | 2.692 | 0.536 |
+| Loom Weave 2 Flash | 19.9M | 2.254 | 0.580 |
+| **Loom Tapestry 2** | **22.8M** | **1.963** | **0.622** |
+
+13% lower loss and +4.2 accuracy points over the previous best.
+
+## Read this before you use it
+
+**Keep tools OFF for conversation.** The persona was trained entirely under `tools:off`.
+With tools **on**, identity and personal questions get turned into a lookup — measured
+**0/10** on that case. The shipped Ollama template defaults to `tools:off`; switch to
+`tools:on` only for the retrieval loop.
+
+**Validate what it tells you from a result.** It answers from a `<result>` whether or not
+the answer is actually in there — "says the result doesn't contain it" is 1/5. Treat the
+retrieved text as the trustworthy part and the model's summary of it as unreliable.
+Extraction picks the wrong span roughly a third of the time.
+
+**It is a lookup assistant, not a chat companion.** At 22.8M parameters it does not
+improvise, explain in its own words, or hold a free-ranging conversation. What it does
+reliably is decide a lookup is needed, write the query, read the answer back, and say
+where the answer came from.
+
+**It has almost no world knowledge.** With tools off it declines factual questions. That is
+the intended behaviour, not a fault.
+
+## Two modes
+
+**`<tools:off>` (default)** — conversational. Identity, limits, warmth, brevity.
+
+**`<tools:on>`** — emits `<lookup>query</lookup>` and stops. Your harness runs the lookup
+and continues with a `<result>` block:
+
+```
+<tools:on>
+<user>
+what is the capital of peru
+<|eot|>
+<loom>
+<lookup>what is the capital of peru</lookup><|eot|>
+<result>
+Lima is the capital and largest city of Peru.
+<|eot|>
+<loom>
+```
+
+## Usage — the harness
+
+`harness.py` in this repo runs the lookup and feeds the result back. Wikipedia is used
+because it is free and needs no key — swap the `search()` function for anything else; the
+contract is text in, text out.
+
+```bash
+python3 harness.py "who wrote dracula"      # with lookups
+python3 harness.py                          # interactive
+python3 harness.py --no-tools "who are you" # chat only
+```
+
+Three things any harness for this model needs:
+
+- **Never feed a failed lookup back as a `<result>`.** It will earnestly answer from the
+  error text. Fail loudly instead — `harness.py` does.
+- Wikipedia returns **403** without a descriptive `User-Agent`.
+- macOS system Python often needs **certifi** for TLS.
+
+## Usage — Ollama
+
+```bash
+ollama run hf.co/textilelabs/Loom-Tapestry-2 "who are you"
+```
+
+The `template` and `params` files in this repo are read automatically. `params` sets a
+repetition penalty — without one, greedy decoding can loop on a phrase. To build locally:
+`ollama create loom-tapestry-2 -f Modelfile`.
+
+## Usage — transformers
+
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+tok = AutoTokenizer.from_pretrained("textilelabs/Loom-Tapestry-2")
+model = AutoModelForCausalLM.from_pretrained("textilelabs/Loom-Tapestry-2").eval()
+eot = tok.convert_tokens_to_ids("<|eot|>")
+
+def ask(message, tools=False):
+    p = f"<tools:{'on' if tools else 'off'}>\n<user>\n{message}\n<|eot|>\n<loom>\n"
+    ids = tok(p, return_tensors="pt", add_special_tokens=False).input_ids
+    with torch.no_grad():
+        out = model.generate(ids, max_new_tokens=64, do_sample=False, eos_token_id=eot,
+                             pad_token_id=tok.convert_tokens_to_ids("<|pad|>"))[0]
+    return tok.decode(out[ids.shape[1]:], skip_special_tokens=True).strip()
+
+ask("who are you")   # -> 'Loom Tapestry 2, a small model by Textile Labs.'
+```
+
+Prompt format is exact: `<tools:off>\n<user>\n{message}\n<|eot|>\n<loom>\n`.
+No trailing space after `<loom>`.
+
+## How it was built
+
+| | |
+|---|---|
+| architecture | Llama — 20 layers × 320d, GQA, SwiGLU, RoPE, tied embeddings |
+| context | 768 |
+| vocabulary | 4,096 custom BPE |
+| optimiser | **Muon** on all 140 hidden matrices, AdamW on embeddings and norms |
+| schedule | warmup → stable → decay (WSD) |
+| corpus | 130,741 conversations · 17.8M tokens · **56% multi-turn** |
+| training | 2,058 steps from random initialisation |
+
+Depth was chosen over width deliberately: an earlier ladder study on this family found
+that narrowing the hidden size cost about 3 points while removing a layer cost ten.
+
+## Files
+
+```
+config.json / model.safetensors           the model
+tokenizer.json / tokenizer_config.json    custom BPE tokenizer, 4,096 tokens
+loom-tapestry-2-f16.gguf                  44MB, for Ollama / llama.cpp
+harness.py                                runnable harness — runs lookups, feeds results back
+template / params                         read automatically by `ollama run hf.co/...`
+Modelfile                                 for building locally
+ATTRIBUTION.md                            required credits for the training corpora
+```
+
+## Training data
+
+Openly licensed corpora of real human text, plus a persona curriculum written for Loom.
+See `ATTRIBUTION.md` — several of these licences require credit.
+
+| slice | source |
+|---|---|
+| grounded reading, and "the result doesn't say" | **SQuAD 2.0** (CC BY-SA 4.0) |
+| when to reach for a tool | **MASSIVE** (CC BY 4.0) · **CLINC150** (CC BY 3.0) |
+| instruction following | **databricks-dolly-15k** (CC BY-SA 3.0) |
+| multi-turn dialogue structure | **OpenAssistant OASST1** (Apache 2.0) |
+| identity, limits, warmth, attribution | Textile Labs — written for Loom |
+
+## License
+
+Model: MIT. Training data retains its original licences and attribution.

UPLOAD-STEPS.txt

@@ -0,0 +1,47 @@
+LOOM TAPESTRY 2 — UPLOAD STEPS
+==============================
+
+1. Add your two images to this folder FIRST, named exactly:
+       banner.jpg
+       logo.jpg
+   (prompts are in TAPESTRY-2-ARTWORK-PROMPTS.md in the project folder.
+    The name must be .jpg — a .jpeg mismatch broke the images on an earlier release.)
+
+2. On huggingface.co, create a NEW model repo:
+       textilelabs/Loom-Tapestry-2
+   Owner: textilelabs · Public · License: MIT
+
+3. Files and versions -> Add file -> Upload files.
+   Drag in ALL the CONTENTS of this folder (not the folder itself).
+   Do NOT upload UPLOAD-STEPS.txt — it is for you, not the repo.
+
+4. Commit. That is it — no settings to change.
+   The tags, widget examples and licence all come from the top of README.md.
+
+5. Verify (takes a minute):
+       ollama run hf.co/textilelabs/Loom-Tapestry-2 "who are you"
+   Expected: "Loom Tapestry 2, a small model by Textile Labs." or similar.
+   If Ollama says it cannot find a template, the template/params files did not
+   upload — re-add just those two.
+
+6. Optional: add it to your "Loom-Spark" collection so it sits with the family.
+
+
+WHAT IS IN HERE (14 files + your 2 images = 16)
+-----------------------------------------------
+  README.md                      the model card (tags/widgets are in its header)
+  config.json                    model architecture
+  model.safetensors              the weights, 87 MB
+  generation_config.json
+  tokenizer.json                 custom 4,096-token BPE
+  tokenizer_config.json
+  special_tokens_map.json
+  loom-tapestry-2-f16.gguf       44 MB, for Ollama / llama.cpp
+  template                       Ollama reads this automatically (defaults tools:off)
+  params                         Ollama reads this automatically
+  Modelfile                      only needed for `ollama create` locally
+  harness.py                     runnable harness — does the lookups
+  ATTRIBUTION.md                 licence credits, required by the corpora
+  LICENSE                        MIT
+  banner.jpg                     <- you add
+  logo.jpg                       <- you add

config.json

@@ -0,0 +1,32 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": null,
+  "dtype": "float32",
+  "eos_token_id": 0,
+  "head_dim": 64,
+  "hidden_act": "silu",
+  "hidden_size": 320,
+  "initializer_range": 0.02,
+  "intermediate_size": 864,
+  "max_position_embeddings": 768,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 5,
+  "num_hidden_layers": 20,
+  "num_key_value_heads": 1,
+  "pad_token_id": 1,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_parameters": {
+    "rope_theta": 10000.0,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.15.1",
+  "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.15.1",
+  "use_cache": true
+}

harness.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Loom harness — runs the searches for Loom Spark 2.
+
+The model never searches. It emits `<lookup>query</lookup>` and stops. This script
+is the other half of the contract: it runs the lookup, feeds a `<result>` block
+back, and lets the model answer from it.
+
+    user question
+        -> Loom (tools on)  ->  <lookup>who wrote Dracula</lookup>
+        -> harness runs Wikipedia
+        -> <result>...</result>
+        -> Loom              ->  Bram Stoker.
+
+Wikipedia is used because it is free and needs no API key. Swap `search()` for
+anything you like — the contract is just "text in, text out".
+
+Usage:
+    python3 harness.py "who wrote Dracula"
+    python3 harness.py                      # interactive
+    python3 harness.py --no-tools "who are you"
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import ssl
+import urllib.parse
+import urllib.request
+
+# macOS system Python often ships without a usable CA bundle, so Wikipedia's TLS
+# fails with CERTIFICATE_VERIFY_FAILED. Use certifi's bundle when it's available.
+try:
+    import certifi
+    SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+except Exception:
+    SSL_CTX = ssl.create_default_context()
+
+OLLAMA = "http://localhost:11434/api/generate"
+MODEL = "hf.co/textilelabs/Loom-Tapestry-2"
+LOOKUP = re.compile(r"<lookup>(.*?)</lookup>", re.S)
+# Wikipedia returns 403 to requests without a descriptive User-Agent — their API
+# policy requires one that identifies the client.
+UA = {"User-Agent": "LoomHarness/1.0 (Textile Labs; loom harness demo)"}
+
+
+def loom(prompt: str, n: int = 64) -> str:
+    """One raw generation. raw=True so our exact prompt format reaches the model."""
+    body = json.dumps({
+        "model": MODEL, "prompt": prompt, "raw": True, "stream": False,
+        "options": {"temperature": 0, "num_predict": n,
+                    "stop": ["<|eot|>", "<user>", "<result>"]},
+    }).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()
+
+
+def search(query: str, sentences: int = 3) -> str:
+    """Wikipedia lookup. Returns a short passage, or '' if nothing is found."""
+    api = "https://en.wikipedia.org/w/api.php?" + urllib.parse.urlencode({
+        "action": "query", "format": "json", "list": "search",
+        "srsearch": query, "srlimit": 1})
+    try:
+        with urllib.request.urlopen(urllib.request.Request(api, headers=UA),
+                                    timeout=20, context=SSL_CTX) as r:
+            hits = json.load(r)["query"]["search"]
+        if not hits:
+            return ""
+        title = hits[0]["title"]
+        summary = ("https://en.wikipedia.org/api/rest_v1/page/summary/"
+                   + urllib.parse.quote(title, safe=""))
+        with urllib.request.urlopen(urllib.request.Request(summary, headers=UA),
+                                    timeout=20, context=SSL_CTX) as r:
+            extract = json.load(r).get("extract", "")
+    except Exception as e:
+        return f"(search failed: {e})"
+    parts = re.split(r"(?<=[.!?])\s+", extract)
+    return " ".join(parts[:sentences]).strip()
+
+
+def ask(message: str, tools: bool = True, verbose: bool = True) -> str:
+    mode = "on" if tools else "off"
+    convo = f"<tools:{mode}>\n<user>\n{message.strip()}\n<|eot|>\n<loom>\n"
+    first = loom(convo)
+
+    m = LOOKUP.search(first)
+    if not m:
+        return first                      # answered directly, no tool wanted
+
+    query = m.group(1).strip()
+    if verbose:
+        print(f"    [loom wants: {query!r}]")
+    result = search(query)
+    if not result or result.startswith("(search failed"):
+        # Never feed an error string in as if it were a result — the model will try
+        # to answer from it. Fail loudly instead.
+        return f"[harness] lookup failed for {query!r}: {result or 'no results'}"
+    if verbose:
+        print(f"    [result: {result[:100]}...]")
+
+    convo += f"{first}<|eot|>\n<result>\n{result}\n<|eot|>\n<loom>\n"
+    return loom(convo, n=48)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("message", nargs="*")
+    ap.add_argument("--no-tools", action="store_true", help="chat only, no lookups")
+    ap.add_argument("--quiet", action="store_true")
+    ap.add_argument("--model", default=MODEL)
+    args = ap.parse_args()
+    globals()["MODEL"] = args.model
+
+    if args.message:
+        print(ask(" ".join(args.message), not args.no_tools, not args.quiet))
+        return
+    print(f"Loom harness — {MODEL}   (tools {'off' if args.no_tools else 'on'}, "
+          f"ctrl-c to quit)\n")
+    while True:
+        try:
+            msg = input("you  > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+        if msg:
+            print(f"loom > {ask(msg, not args.no_tools, not args.quiet)}\n")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

loom-tapestry-2-f16.gguf

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

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65cd9fc9fda0065735620158e3587a655d65e65f1abf965114b8295ff23bb20e
+size 91331168

params

@@ -0,0 +1,8 @@
+{
+  "stop": ["<|eot|>", "<user>", "<result>"],
+  "temperature": 0.7,
+  "top_k": 40,
+  "repeat_penalty": 1.15,
+  "repeat_last_n": 64,
+  "num_predict": 96
+}

special_tokens_map.json

@@ -0,0 +1,13 @@
+{
+  "eos_token": "<|eot|>",
+  "pad_token": "<|pad|>",
+  "additional_special_tokens": [
+    "<tools:on>",
+    "<tools:off>",
+    "<user>",
+    "<loom>",
+    "<result>",
+    "<lookup>",
+    "</lookup>"
+  ]
+}

template

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

tokenizer_config.json

@@ -0,0 +1,16 @@
+{
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "model_max_length": 768,
+  "eos_token": "<|eot|>",
+  "pad_token": "<|pad|>",
+  "additional_special_tokens": [
+    "<tools:on>",
+    "<tools:off>",
+    "<user>",
+    "<loom>",
+    "<result>",
+    "<lookup>",
+    "</lookup>"
+  ],
+  "clean_up_tokenization_spaces": false
+}