Help Us Improve Fabric 1.5

Tried the model? We'd love to hear what you think.

🚀 Share Your Feedback

Your feedback helps us improve Fabric models and future releases.

Fabric 1.5 — 0.7B Instruct

Overview

Fabric 1.5 is a lightweight, high-capability language model developed by Fabric AI. It is built upon the Fabric1.5-0.7B-Base pretrained checkpoint and fine-tuned for instruction following. It introduces a novel chunked memory architecture and demonstrates that a 0.7B parameter model can achieve meaningful performance on reasoning, knowledge, and instruction-following tasks.

Model Details

• Type: Causal Language Model
• Parameters: 742M (0.7B)
• Hidden Dimension: 1,536
• Vocabulary Size: 65,536
• Layers: 24 (16 LocalBlock + 8 FabricMemoryBlock)
• Attention: GQA (24 query heads, 6 KV heads), RoPE (theta=1M)
• Context Length: 32,768 tokens native
• Precision: FP16
• License: Fabric AI Open License v1.0

Architecture

Fabric 1.5 employs a Chunked Fabric Memory architecture — every 3rd block splits attention into two parallel branches:

• Local causal window: exact attention over the last 2,048 tokens
• Chunked memory: learned summaries (4 per 512-token chunk) of earlier completed chunks

A per-token scalar gate blends the outputs, giving the model 256 summary vectors of long-range memory at full 32K context without quadratic memory growth.

Benchmark Results

Evaluated on an NVIDIA A100-SXM4-40GB using lm-eval harness with FP16 weights.

Comparison vs Qwen3.5-0.8B

Fabric 1.5 performs within 0.74% of Qwen3.5-0.8B on MMLU despite being 12% smaller (0.7B vs 0.8B) and having no vision encoder.

Quickstart

Serve with Hugging Face Transformers

Fabric 1.5 can be served through the Hugging Face transformers serve CLI using an OpenAI-compatible API.

Install

python3 -m venv .venv
source .venv/bin/activate

python -m pip install --upgrade pip
python -m pip install --upgrade "transformers[serving]" openai

Fabric 1.5 uses custom Transformers code, so --trust-remote-code is required.

Custom architecture compatibility patch

Current versions of transformers serve may try to load FabricForCausalLM directly from the installed Transformers package instead of loading it from the model repository. Run this patch once inside the active virtual environment:

python - <<'PY'
from pathlib import Path
import shutil

import transformers.cli.serving.model_manager as model_manager

path = Path(model_manager.__file__)
backup = path.with_suffix(".py.bak")

old = """        architecture = getattr(transformers, config.architectures[0])
        return architecture.from_pretrained(model_id, **model_kwargs)"""

new = """        from transformers import AutoModelForCausalLM

        return AutoModelForCausalLM.from_pretrained(
            model_id,
            config=config,
            **model_kwargs,
        )"""

source = path.read_text()

if old not in source:
    raise SystemExit(
        f"Expected code was not found in:\n{path}\n"
        "Your Transformers version may already contain a fix."
    )

if not backup.exists():
    shutil.copy2(path, backup)

path.write_text(source.replace(old, new))

print(f"Patched: {path}")
print(f"Backup:  {backup}")
PY

macOS with Apple Silicon

transformers serve FabricAI/Fabric1.5-0.7B-Instruct \
  --trust-remote-code \
  --device mps \
  --dtype float16 \
  --attn-implementation eager \
  --host 0.0.0.0 \
  --port 8000

NVIDIA GPU

For NVIDIA GPUs with BF16 support:

transformers serve FabricAI/Fabric1.5-0.7B-Instruct \
  --trust-remote-code \
  --device cuda \
  --dtype bfloat16 \
  --attn-implementation eager \
  --host 0.0.0.0 \
  --port 8000

For NVIDIA GPUs that do not support BF16, use FP16:

transformers serve FabricAI/Fabric1.5-0.7B-Instruct \
  --trust-remote-code \
  --device cuda \
  --dtype float16 \
  --attn-implementation eager \
  --host 0.0.0.0 \
  --port 8000

Stream a chat response

Install jq if it is not already available. On macOS:

brew install jq

Then send an OpenAI-compatible streaming request:

curl -sN http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "FabricAI/Fabric1.5-0.7B-Instruct",
    "messages": [
      {
        "role": "system",
        "content": "You are Fabric, a helpful AI assistant."
      },
      {
        "role": "user",
        "content": "List and go into detail on the key tasks you can help with in a healthcare clinic setting. Provide a thorough, dedicated paragraph of around 100 words for each example."
      }
    ],
    "max_tokens": 1024,
    "stream": true,
    "generation_config": "{\"do_sample\":false,\"repetition_penalty\":1.1}"
  }' \
  | sed -u -n 's/^data: //p' \
  | jq --unbuffered -j 'select(.choices) | .choices[0].delta.content // empty'

printf '\n'

The server exposes an OpenAI-compatible API at http://localhost:8000/v1.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "FabricAI/Fabric1.5-0.7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    torch_dtype=torch.float16,
    device_map="auto",
)

# Updated messages matching the curl setup
messages = [
    {
        "role": "system",
        "content": "You are Fabric, a helpful AI assistant."
    },
    {
        "role": "user",
        "content": "First introduce yourself. Then, list and go into detail on the key tasks you can help with in a healthcare clinic setting. Provide a thorough, dedicated paragraph of around 100 words for each example."
    }
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=1024,
        do_sample=False,
        repetition_penalty=1.1,
        use_cache=True,
    )

response = tokenizer.decode(output_ids[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()
print(response)

Chat Template

<|bos|><|system|>
You are Fabric, a large language model developed by Fabric AI.<|end|>
<|user|>
Hello!<|end|>
<|assistant|>
Hi! How can I help you?<|end|>

Special tokens: <bos>, <pad>, <|end|>, <|system|>, <|user|>, <|assistant|>

Sampling Parameters

Training Data & Process

Pre-training (18B tokens, 1× NVIDIA DGX H100 8-GPU):

• Optimizer: AdamW (β1=0.9, β2=0.95, ε=1e-8)
• Learning rate: 3e-4 with cosine decay to 3e-5, 180M token warmup
• Weight decay: 0.1
• Gradient clipping: 1.0
• Precision: FP16
• Distributed: NCCL, 8 ranks, 4 sequences per GPU

Post-training (SFT):

1. Identity tuning — system prompt alignment and persona training
2. General SFT — diverse instruction-following datasets

Hardware Notes

Fabric 1.5 was trained on a single NVIDIA DGX H100 node with 8× H100 80GB GPUs. The model runs efficiently on:

The chunked memory architecture ensures memory scales linearly with context, not quadratically.

License

Fabric AI Open License v1.0 — a permissive, attribution-required license. See LICENSE for full terms.

Key requirements:

• You may use, modify, and distribute the model freely
• You must retain attribution to Fabric AI when redistributing
• Modified files must carry notices of your changes
• No warranty or liability provisions

Citation

@misc{fabric1.5,
    title  = {{Fabric 1.5}: A Causal Language Model with Chunked Fabric Memory},
    author = {Fabric AI},
    year   = 2026,
}