diff --git a/build.zig b/build.zig
index edebcb739c..962d2e36c4 100644
--- a/build.zig
+++ b/build.zig
@@ -93,6 +93,7 @@ pub fn build(b: *std.Build) void {
         @import("zig/build/step5_host.zig").steps(b, step5_mods.metal, step5_mods.engine, step5_mods.lanes);
     }
     @import("zig/build/h3_host.zig").tests(b, target, test_step);
+    @import("zig/build/lfm3_host.zig").steps(b, test_step);
     @import("zig/build/digest.zig").steps(b, test_step, draft_ids, build_options);
     @import("zig/build/flashnext_budget.zig").steps(b, test_step);
     @import("zig/build/flashnext_batch_host.zig").tests(b, test_step);
diff --git a/docs/recipes/lfm3-native.md b/docs/recipes/lfm3-native.md
new file mode 100644
index 0000000000..7833381748
--- /dev/null
+++ b/docs/recipes/lfm3-native.md
@@ -0,0 +1,72 @@
+# LFM3 native Metal bring-up
+
+Tracking issue: [#1491](https://github.com/ashhart/TensorFold/issues/1491).
+
+This branch adds host checks for LFM3 checkpoint configuration and text tensor layouts.
+It does not register a serving engine. Text generation and image input are not implemented or qualified here.
+
+## Inspect a checkpoint
+
+Use Python 3.11 or newer. The inspector uses the standard library. It resolves a full Hugging Face commit,
+reads the config and index, and requests only the safetensors headers. It refuses a server that returns a
+complete weight file instead of the requested byte range.
+
+```sh
+python3 tools/lfm3/inspect_checkpoint.py LiquidAI/LFM3-1.7B-MLX-4bit --output text4.json
+python3 tools/lfm3/inspect_checkpoint.py LiquidAI/LFM3-VL-2B-MLX-4bit --output vl4.json
+```
+
+Replace `4bit` with `6bit` or `8bit` to inspect those exports. Pass `--revision COMMIT` to repeat a pinned inspection.
+Use `--local-dir MODEL_DIR` instead of a repository name to inspect files already on disk.
+
+## Check the native text layout
+
+Use the Zig version in `.zig-version`.
+
+```sh
+zig build test-lfm3-host tf-lfm3-check
+./zig-out/bin/tf-lfm3-check text4.json
+./zig-out/bin/tf-lfm3-check vl4.json
+python3 -m unittest discover -s tools/lfm3 -p 'test_*.py' -v
+```
+
+The native checker reads the saved metadata, validates shard header geometry, and checks the LFM3 text decoder's
+required names, dtypes, shapes, and byte counts. It performs no projection, GPU allocation, or model inference.
+For VL, it checks the text decoder only. A passing result does not validate vision weights or image processing.
+
+The config reader preserves full-attention versus sliding-attention layers, distinct rotary settings, sandwich norms,
+and each module's affine width and group size. Unsupported geometry and conflicting quantization declarations fail.
+
+## Checkpoint details
+
+All six inspected MLX exports store the decoder under `language_model.model.*`, including the text-only model.
+Each decoder has 594 tensors. Convolution kernels are BF16 with shape `[2048, 7, 1]`.
+
+Text 4/6/8-bit and VL 6/8-bit use affine groups of 64. VL 4-bit uses groups of 32 and an 8-bit embedding override.
+The 138 additional VL vision/projector tensors are BF16 in all three exports. Global quantization metadata must not
+cause these dense tensors to be treated as packed affine weights.
+
+The header inspections used these revisions:
+
+- Text 4-bit: `d0ca73dcfa70ce18733754a492cdc1fb0123262d`.
+- Text 6-bit: `26be898c36b545d625d84ac0761c6c3eb664aef3`.
+- Text 8-bit: `ee7667f3cfccb2a41725f91820531823fcabc6b7`.
+- VL 4-bit: `c823fade98e35a3d6942ad4d38b1ea15f675cd12`.
+- VL 6-bit: `6d71bfae121abedc75f6d531fc7f6ceb4f5e3501`.
+- VL 8-bit: `83336d5be3874a2bdd3297bde77b2114dbd3a816`.
+
+## Next gate
+
+Implement the text operators against an independent reference before advertising generation.
+Check the 7-tap convolution, per-head attention gate, sandwich normalization, sliding window, and partial-RoPE formula.
+Then exercise actual 1.7B 4-bit weights through the shared lane engine, followed by 6/8-bit checkpoints.
+The VL encoder and projector need their own native Metal operators and reference checks after text bring-up.
+
+Agree model-fidelity and performance acceptance criteria on the tracking issue before claiming release readiness.
+
+## Weight licence and checked hardware
+
+The official text and VL MLX exports retain the [LFM Open License v1.0](https://huggingface.co/LiquidAI/LFM3-1.7B-MLX-4bit/blob/main/LICENSE).
+The VL export carries its own [copy of that licence](https://huggingface.co/LiquidAI/LFM3-VL-2B-MLX-4bit/blob/main/LICENSE).
+TensorFold code remains Apache-2.0; admission does not change the weights’ licence.
+This slice validates metadata on the host and does not register inference or qualify a GPU.
diff --git a/tools/lfm3/inspect_checkpoint.py b/tools/lfm3/inspect_checkpoint.py
new file mode 100644
index 0000000000..2fec63457d
--- /dev/null
+++ b/tools/lfm3/inspect_checkpoint.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""Inspect pinned Hugging Face configs and safetensors headers without downloading tensor data."""
+
+import argparse
+import collections
+import json
+import math
+import os
+import re
+import struct
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path, PurePosixPath
+
+MAX_JSON = 16 * 1024 * 1024
+MAX_HEADER = 16 * 1024 * 1024
+
+
+class InspectionError(Exception):
+    pass
+
+
+def safe_name(name):
+    path = PurePosixPath(name)
+    if not name or path.is_absolute() or '..' in path.parts or '\\' in name:
+        raise InspectionError(f'Unsafe checkpoint file name: {name!r}')
+    return name
+
+
+def read_json_bytes(data, description):
+    try:
+        return json.loads(data)
+    except (ValueError, UnicodeError) as exc:
+        raise InspectionError(f'Invalid JSON in {description}: {exc}') from exc
+
+
+class Remote:
+    def __init__(self, repository, revision):
+        if not re.fullmatch(r'[\w.-]+/[\w.-]+', repository):
+            raise InspectionError('Repository must have owner/name form')
+        api = 'https://huggingface.co/api/models/' + repository + '/revision/'
+        metadata = self.json_url(api + urllib.parse.quote(revision, safe=''))
+        self.revision = metadata.get('sha', '')
+        if not re.fullmatch(r'[0-9a-f]{40}', self.revision):
+            raise InspectionError('Hugging Face did not resolve a full commit revision')
+        self.repository = repository
+        self.files = {entry['rfilename'] for entry in metadata.get('siblings', [])}
+        self.base = f'https://huggingface.co/{repository}/resolve/{self.revision}/'
+
+    @staticmethod
+    def fetch(url, limit, byte_range=None, with_total=False):
+        headers = {'User-Agent': 'TensorFold-checkpoint-inspector', 'Accept-Encoding': 'identity'}
+        if byte_range is not None:
+            start, end = byte_range
+            headers['Range'] = f'bytes={start}-{end}'
+        try:
+            with urllib.request.urlopen(urllib.request.Request(url, headers=headers), timeout=60) as response:
+                if byte_range is not None:
+                    match = re.fullmatch(r'bytes (\d+)-(\d+)/(\d+)', response.headers.get('Content-Range', ''))
+                    if response.status != 206 or not match:
+                        raise InspectionError('Server refused an exact HTTP byte range; refusing tensor download')
+                    first, last, total = map(int, match.groups())
+                    if (first, last) != byte_range or total <= last:
+                        raise InspectionError('Server returned an unexpected byte range')
+                    if response.headers.get('Content-Encoding', 'identity') != 'identity':
+                        raise InspectionError('Compressed range response is not supported')
+                length = response.headers.get('Content-Length')
+                if length is not None and int(length) > limit:
+                    raise InspectionError(f'Response exceeds {limit}-byte body limit')
+                data = response.read(limit + 1)
+                if len(data) > limit:
+                    raise InspectionError(f'Response exceeds {limit}-byte body limit')
+                if byte_range is not None and len(data) != byte_range[1] - byte_range[0] + 1:
+                    raise InspectionError('Truncated byte-range response')
+                return (data, total) if with_total else data
+        except (urllib.error.URLError, TimeoutError, OSError, ValueError) as exc:
+            raise InspectionError(f'Cannot fetch {url}: {exc}') from exc
+
+    @classmethod
+    def json_url(cls, url):
+        return read_json_bytes(cls.fetch(url, MAX_JSON), url)
+
+    def json(self, name):
+        return self.json_url(self.base + urllib.parse.quote(safe_name(name), safe='/'))
+
+    def header(self, name):
+        url = self.base + urllib.parse.quote(safe_name(name), safe='/')
+        prefix, total = self.fetch(url, 8, (0, 7), with_total=True)
+        size = header_size(prefix)
+        if total < 8 + size:
+            raise InspectionError('Safetensors header extends beyond shard size')
+        data, second_total = self.fetch(url, size, (8, 7 + size), with_total=True)
+        if total != second_total:
+            raise InspectionError('Shard size changed between header requests')
+        return read_json_bytes(data, name), total - 8 - size
+
+
+class Local:
+    def __init__(self, directory):
+        self.directory = Path(directory).resolve()
+        self.repository = str(self.directory)
+        self.revision = None
+        self.files = {str(path.relative_to(self.directory)) for path in self.directory.rglob('*.safetensors')}
+        if (self.directory / 'model.safetensors.index.json').is_file():
+            self.files.add('model.safetensors.index.json')
+
+    def path(self, name):
+        path = (self.directory / safe_name(name)).resolve()
+        if not path.is_relative_to(self.directory):
+            raise InspectionError('Checkpoint file escapes local directory')
+        return path
+
+    def json(self, name):
+        with self.path(name).open('rb') as stream:
+            data = stream.read(MAX_JSON + 1)
+        if len(data) > MAX_JSON:
+            raise InspectionError('Local JSON exceeds body limit')
+        return read_json_bytes(data, name)
+
+    def header(self, name):
+        with self.path(name).open('rb') as stream:
+            size = header_size(stream.read(8))
+            data = stream.read(size)
+            total = os.fstat(stream.fileno()).st_size
+        if len(data) != size:
+            raise InspectionError('Truncated local safetensors header')
+        return read_json_bytes(data, name), total - 8 - size
+
+
+def header_size(prefix):
+    if len(prefix) != 8:
+        raise InspectionError('Truncated safetensors size prefix')
+    size = struct.unpack('<Q', prefix)[0]
+    if not 2 <= size <= MAX_HEADER:
+        raise InspectionError(f'Invalid or excessive safetensors header size: {size}')
+    return size
+
+
+def validate_tensor(name, tensor, data_length):
+    widths = {
+        'BOOL': 1, 'U8': 1, 'I8': 1, 'F8_E4M3': 1, 'F8_E5M2': 1,
+        'U16': 2, 'I16': 2, 'F16': 2, 'BF16': 2,
+        'U32': 4, 'I32': 4, 'F32': 4, 'U64': 8, 'I64': 8, 'F64': 8,
+    }
+    if not isinstance(tensor, dict) or not all(k in tensor for k in ('dtype', 'shape', 'data_offsets')):
+        raise InspectionError(f'Invalid tensor descriptor: {name}')
+    shape, offsets = tensor['shape'], tensor['data_offsets']
+    if not isinstance(shape, list) or any(type(d) is not int or d < 0 for d in shape):
+        raise InspectionError(f'Invalid tensor shape: {name}')
+    if not isinstance(offsets, list) or len(offsets) != 2 or any(type(d) is not int for d in offsets):
+        raise InspectionError(f'Invalid tensor offsets: {name}')
+    start, end = offsets
+    if not 0 <= start <= end <= data_length:
+        raise InspectionError(f'Tensor offsets exceed shard data bounds: {name}')
+    dtype = tensor['dtype']
+    if not isinstance(dtype, str) or dtype not in widths:
+        raise InspectionError(f'Unsupported safetensors dtype: {name}')
+    if math.prod(shape) * widths[dtype] != end - start:
+        raise InspectionError(f'Tensor shape/dtype byte count disagrees with offsets: {name}')
+
+
+def inspect(source):
+    config = source.json('config.json')
+    index = None
+    if 'model.safetensors.index.json' in source.files:
+        index = source.json('model.safetensors.index.json')
+        shard_names = sorted(set(index['weight_map'].values()))
+    else:
+        shard_names = sorted(name for name in source.files if name.endswith('.safetensors'))
+    if not shard_names:
+        raise InspectionError('No safetensors files found')
+    tensors = {}
+    shard_data_lengths = {}
+    for shard in shard_names:
+        header, data_length = source.header(shard)
+        shard_data_lengths[shard] = data_length
+        ranges = []
+        for name, tensor in header.items():
+            if name == '__metadata__':
+                continue
+            if name in tensors:
+                raise InspectionError(f'Duplicate tensor: {name}')
+            validate_tensor(name, tensor, data_length)
+            start, end = tensor['data_offsets']
+            if start != end:
+                ranges.append((start, end, name))
+            tensors[name] = dict(tensor, shard=shard)
+        previous_end = 0
+        for start, end, name in sorted(ranges):
+            if start < previous_end:
+                raise InspectionError(f'Overlapping tensor data: {name}')
+            previous_end = end
+    if index is not None:
+        if set(index['weight_map']) != set(tensors):
+            raise InspectionError('Tensor index and shard headers disagree')
+        if any(index['weight_map'][name] != tensor['shard'] for name, tensor in tensors.items()):
+            raise InspectionError('Tensor index points to the wrong shard')
+    return {
+        'repository': source.repository,
+        'revision': source.revision,
+        'config': config,
+        'tensor_count': len(tensors),
+        'dtype_counts': dict(collections.Counter(t['dtype'] for t in tensors.values())),
+        'quantized_module_count': sum(name.endswith('.scales') for name in tensors),
+        'shards': shard_names,
+        'shard_data_lengths': shard_data_lengths,
+        'tensors': tensors,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('repository', nargs='?', help='Hugging Face owner/name')
+    parser.add_argument('--revision', default='main')
+    parser.add_argument('--local-dir', type=Path)
+    parser.add_argument('--output', type=Path, help='Write complete verified metadata as JSON')
+    args = parser.parse_args()
+    if bool(args.repository) == bool(args.local_dir):
+        parser.error('Choose exactly one repository or --local-dir')
+    try:
+        source = Local(args.local_dir) if args.local_dir else Remote(args.repository, args.revision)
+        result = inspect(source)
+        if args.output:
+            args.output.write_text(json.dumps(result, indent=2) + '\n')
+        summary = {key: value for key, value in result.items() if key not in ('tensors', 'config')}
+        summary['quantization'] = result['config'].get('quantization', result['config'].get('quantization_config'))
+        print(json.dumps(summary, indent=2))
+    except (InspectionError, OSError, KeyError, TypeError) as exc:
+        print(f'Checkpoint inspection failed: {exc}', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/tools/lfm3/test_inspect_checkpoint.py b/tools/lfm3/test_inspect_checkpoint.py
new file mode 100644
index 0000000000..d647542ade
--- /dev/null
+++ b/tools/lfm3/test_inspect_checkpoint.py
@@ -0,0 +1,142 @@
+"""Host checks for bounded checkpoint metadata inspection."""
+
+import io
+import json
+import struct
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+import inspect_checkpoint as inspector
+
+
+class Response(io.BytesIO):
+    def __init__(self, body, status, headers):
+        super().__init__(body)
+        self.status = status
+        self.headers = headers
+        self.read_calls = 0
+
+    def read(self, size=-1):
+        self.read_calls += 1
+        return super().read(size)
+
+
+class InspectorTests(unittest.TestCase):
+    def test_refuses_full_weight_response_before_reading(self):
+        response = Response(b'weight data', 200, {})
+        with patch.object(inspector.urllib.request, 'urlopen', return_value=response):
+            with self.assertRaisesRegex(inspector.InspectionError, 'refused'):
+                inspector.Remote.fetch('https://example.org/model', 8, (0, 7))
+        self.assertEqual(response.read_calls, 0)
+
+    def test_rejects_wrong_range(self):
+        response = Response(b'12345678', 206, {'Content-Range': 'bytes 8-15/100'})
+        with patch.object(inspector.urllib.request, 'urlopen', return_value=response):
+            with self.assertRaisesRegex(inspector.InspectionError, 'unexpected'):
+                inspector.Remote.fetch('https://example.org/model', 8, (0, 7))
+
+    def test_rejects_truncated_range(self):
+        response = Response(b'123', 206, {'Content-Range': 'bytes 0-7/100'})
+        with patch.object(inspector.urllib.request, 'urlopen', return_value=response):
+            with self.assertRaisesRegex(inspector.InspectionError, 'Truncated'):
+                inspector.Remote.fetch('https://example.org/model', 8, (0, 7))
+
+    def test_accepts_exact_range(self):
+        response = Response(b'12345678', 206, {'Content-Range': 'bytes 0-7/100', 'Content-Length': '8'})
+        with patch.object(inspector.urllib.request, 'urlopen', return_value=response):
+            self.assertEqual(inspector.Remote.fetch('https://example.org/model', 8, (0, 7)), b'12345678')
+
+    def test_caps_non_range_metadata(self):
+        response = Response(b'123456789', 200, {})
+        with patch.object(inspector.urllib.request, 'urlopen', return_value=response):
+            with self.assertRaisesRegex(inspector.InspectionError, 'body limit'):
+                inspector.Remote.fetch('https://example.org/config', 8)
+
+    def test_rejects_oversize_header_and_unsafe_names(self):
+        with self.assertRaises(inspector.InspectionError):
+            inspector.header_size(struct.pack('<Q', inspector.MAX_HEADER + 1))
+        for name in ('../model', '/model', 'sub/../../model', 'sub\\model'):
+            with self.subTest(name=name), self.assertRaises(inspector.InspectionError):
+                inspector.safe_name(name)
+
+    def test_truncated_local_tensor_data(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / 'config.json').write_text('{}')
+            header = json.dumps({'weight': {
+                'dtype': 'BF16', 'shape': [2], 'data_offsets': [0, 4],
+            }}).encode()
+            (root / 'model.safetensors').write_bytes(struct.pack('<Q', len(header)) + header + b'12')
+            with self.assertRaisesRegex(inspector.InspectionError, 'bounds'):
+                inspector.inspect(inspector.Local(root))
+
+    def remote_with_header(self, header, payload_length, second_total_delta=0):
+        data = json.dumps(header).encode()
+        total = 8 + len(data) + payload_length
+        responses = [
+            Response(struct.pack('<Q', len(data)), 206, {'Content-Range': f'bytes 0-7/{total}'}),
+            Response(data, 206, {'Content-Range': f'bytes 8-{7 + len(data)}/{total + second_total_delta}'}),
+        ]
+        remote = inspector.Remote.__new__(inspector.Remote)
+        remote.base = 'https://example.org/'
+        remote.repository = 'owner/model'
+        remote.revision = 'a' * 40
+        remote.files = {'model.safetensors'}
+        remote.json = lambda name: {}
+        return remote, responses
+
+    def test_remote_tensor_offsets_exceed_real_file(self):
+        remote, responses = self.remote_with_header({
+            'weight': {'dtype': 'BF16', 'shape': [2], 'data_offsets': [0, 4]},
+        }, 2)
+        with patch.object(inspector.urllib.request, 'urlopen', side_effect=responses):
+            with self.assertRaisesRegex(inspector.InspectionError, 'bounds'):
+                inspector.inspect(remote)
+
+    def test_remote_total_must_stay_constant(self):
+        remote, responses = self.remote_with_header({}, 4, second_total_delta=1)
+        with patch.object(inspector.urllib.request, 'urlopen', side_effect=responses):
+            with self.assertRaisesRegex(inspector.InspectionError, 'size changed'):
+                remote.header('model.safetensors')
+
+    def test_validates_descriptor_shapes_and_offsets(self):
+        bad = [
+            {'dtype': 'BF16', 'shape': [-1], 'data_offsets': [0, 2]},
+            {'dtype': 'BF16', 'shape': [True], 'data_offsets': [0, 2]},
+            {'dtype': 'BF16', 'shape': [2], 'data_offsets': [0]},
+            {'dtype': 'BF16', 'shape': [2], 'data_offsets': [0, 2]},
+            {'dtype': 'unsupported', 'shape': [2], 'data_offsets': [0, 4]},
+        ]
+        for descriptor in bad:
+            with self.subTest(descriptor=descriptor), self.assertRaises(inspector.InspectionError):
+                inspector.validate_tensor('weight', descriptor, 4)
+
+    def test_rejects_overlapping_tensor_data(self):
+        tensor = {'dtype': 'BF16', 'shape': [2], 'data_offsets': [0, 4]}
+        remote, responses = self.remote_with_header({'a': tensor, 'b': tensor}, 4)
+        with patch.object(inspector.urllib.request, 'urlopen', side_effect=responses):
+            with self.assertRaisesRegex(inspector.InspectionError, 'Overlapping'):
+                inspector.inspect(remote)
+
+    def test_local_checkpoint_and_index_cross_check(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / 'config.json').write_text('{"model_type":"lfm3"}')
+            tensor = {'dtype': 'BF16', 'shape': [2], 'data_offsets': [0, 4]}
+            header = json.dumps({'layer.weight': tensor}).encode()
+            (root / 'model.safetensors').write_bytes(struct.pack('<Q', len(header)) + header + b'1234')
+            result = inspector.inspect(inspector.Local(root))
+            self.assertEqual(result['tensor_count'], 1)
+            self.assertEqual(result['shard_data_lengths'], {'model.safetensors': 4})
+            self.assertEqual(result['dtype_counts'], {'BF16': 1})
+            (root / 'model.safetensors.index.json').write_text(json.dumps({
+                'weight_map': {'wrong.weight': 'model.safetensors'},
+            }))
+            with self.assertRaisesRegex(inspector.InspectionError, 'disagree'):
+                inspector.inspect(inspector.Local(root))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/zig/build/lfm3_host.zig b/zig/build/lfm3_host.zig
new file mode 100644
index 0000000000..2f8cfd59b5
--- /dev/null
+++ b/zig/build/lfm3_host.zig
@@ -0,0 +1,37 @@
+//! LFM3 checkpoint admission checks without Metal compilation or model execution.
+const std = @import("std");
+
+pub fn steps(b: *std.Build, all: *std.Build.Step) void {
+    const st = b.createModule(.{
+        .root_source_file = b.path("zig/src/core/safetensors.zig"),
+        .target = b.graph.host,
+        .link_libc = true,
+    });
+    const checks = b.step("test-lfm3-host", "LFM3 text and VL checkpoint config and tensor admission without a GPU");
+    for ([_][]const u8{ "config_test", "weights" }) |part| {
+        const root = b.createModule(.{
+            .root_source_file = b.path(b.fmt("zig/src/families/lfm3/{s}.zig", .{part})),
+            .target = b.graph.host,
+            .link_libc = true,
+        });
+        root.addImport("safetensors", st);
+        const run = b.addRunArtifact(b.addTest(.{ .root_module = root }));
+        checks.dependOn(&run.step);
+    }
+    all.dependOn(checks);
+    const family = b.createModule(.{
+        .root_source_file = b.path("zig/src/families/lfm3/lfm3.zig"),
+        .target = b.graph.host,
+        .link_libc = true,
+        .imports = &.{.{ .name = "safetensors", .module = st }},
+    });
+    const tool = b.addExecutable(.{ .name = "tf-lfm3-check", .root_module = b.createModule(.{
+        .root_source_file = b.path("zig/lfm3_check.zig"),
+        .target = b.graph.host,
+        .link_libc = true,
+        .imports = &.{ .{ .name = "lfm3", .module = family }, .{ .name = "safetensors", .module = st } },
+    }) });
+    b.installArtifact(tool);
+    b.step("tf-lfm3-check", "Validate saved LFM3 tensor-header metadata without model data or a GPU")
+        .dependOn(&b.addInstallArtifact(tool, .{}).step);
+}
diff --git a/zig/lfm3_check.zig b/zig/lfm3_check.zig
new file mode 100644
index 0000000000..577d4910c7
--- /dev/null
+++ b/zig/lfm3_check.zig
@@ -0,0 +1,55 @@
+//! Check saved header metadata from tools/lfm3/inspect_checkpoint.py without loading model data or running a GPU.
+const std = @import("std");
+const lfm3 = @import("lfm3");
+const st = @import("safetensors");
+
+pub fn main(init: std.process.Init) !void {
+    const a = init.arena.allocator();
+    const args = try init.minimal.args.toSlice(a);
+    if (args.len != 2) {
+        std.debug.print("usage: tf-lfm3-check CHECKPOINT_METADATA.json\n", .{});
+        return error.ExpectedMetadata;
+    }
+    const bytes = try std.Io.Dir.cwd().readFileAlloc(init.io, args[1], a, .limited(32 << 20));
+    const value = try std.json.parseFromSliceLeaky(std.json.Value, a, bytes, .{});
+    if (value != .object) return error.BadMetadata;
+    const root = value.object;
+    const cfg_bytes = try std.json.Stringify.valueAlloc(a, root.get("config") orelse return error.BadMetadata, .{});
+    var cfg = try lfm3.config.parse(a, cfg_bytes);
+    defer cfg.deinit();
+    const tensors = root.get("tensors") orelse return error.BadMetadata;
+    const shards = root.get("shards") orelse return error.BadMetadata;
+    const lengths = root.get("shard_data_lengths") orelse return error.BadMetadata;
+    if (tensors != .object or shards != .array or shards.array.items.len == 0 or lengths != .object)
+        return error.BadMetadata;
+    var header: st.Header = .empty;
+    for (shards.array.items) |shard| {
+        if (shard != .string) return error.BadMetadata;
+        var selected: std.json.ObjectMap = .empty;
+        const length = lengths.object.get(shard.string) orelse return error.BadMetadata;
+        if (length != .integer or length.integer < 0) return error.BadMetadata;
+        const data_len = std.math.cast(usize, length.integer) orelse return error.BadMetadata;
+        var it = tensors.object.iterator();
+        while (it.next()) |item| {
+            const tensor = item.value_ptr.*;
+            if (tensor != .object) return error.BadMetadata;
+            const file = tensor.object.get("shard") orelse return error.BadMetadata;
+            if (file != .string) return error.BadMetadata;
+            if (!std.mem.eql(u8, file.string, shard.string)) continue;
+            try selected.put(a, item.key_ptr.*, tensor);
+        }
+        if (selected.count() == 0) return error.BadMetadata;
+        const text = try std.json.Stringify.valueAlloc(a, std.json.Value{ .object = selected }, .{});
+        const parsed = try st.parseHeader(a, text, data_len);
+        for (parsed.keys(), parsed.values()) |key, entry| {
+            if (header.contains(key)) return error.DuplicateTensor;
+            try header.put(a, key, entry);
+        }
+    }
+    if (header.count() != tensors.object.count()) return error.BadMetadata;
+    const manifest = try lfm3.weights.validate(a, &cfg, &header);
+    std.debug.print("LFM3 text admission passed: {s}, {d} text tensors, {d} stored bytes; ", .{
+        @tagName(cfg.kind), manifest.tensors, manifest.bytes,
+    });
+    std.debug.print("{d} other tensors not qualified; GPU inference not tested\n", .{header.count() - manifest.tensors});
+}
diff --git a/zig/src/families/lfm3/config.zig b/zig/src/families/lfm3/config.zig
new file mode 100644
index 0000000000..84ac2ae5b5
--- /dev/null
+++ b/zig/src/families/lfm3/config.zig
@@ -0,0 +1,277 @@
+//! Admission for LFM3-1.7B and LFM3-VL-2B MLX checkpoints; this parser does not advertise an engine.
+const std = @import("std");
+
+pub const hidden = 2048;
+pub const vocab = 128000;
+pub const layers = 24;
+pub const intermediate = 7680;
+pub const conv_taps = 7;
+pub const query_heads = 16;
+pub const kv_heads = 4;
+pub const head_dim = 128;
+pub const sliding_window = 256;
+pub const eps: f32 = 1e-5;
+pub const Kind = enum { text, vision_language };
+pub const LayerType = enum { conv, full_attention, sliding_attention };
+pub const Rotary = struct { theta: f32, partial: f32 };
+pub const schedule: [layers]LayerType = .{
+    .conv,              .conv, .full_attention,    .conv, .sliding_attention, .conv,
+    .full_attention,    .conv, .sliding_attention, .conv, .full_attention,    .conv,
+    .sliding_attention, .conv, .full_attention,    .conv, .sliding_attention, .conv,
+    .full_attention,    .conv, .sliding_attention, .conv, .full_attention,    .conv,
+};
+
+pub const Width = struct { bits: u8, group: u16 };
+pub const Quant = struct {
+    global: Width,
+    modules: std.StringHashMapUnmanaged(Width) = .empty,
+
+    pub fn width(self: *const Quant, key: []const u8) Width {
+        return self.modules.get(canonical(key)) orelse self.global;
+    }
+};
+
+fn canonical(key: []const u8) []const u8 {
+    var k = key;
+    if (std.mem.endsWith(u8, k, ".weight")) k = k[0 .. k.len - 7];
+    for ([_][]const u8{ "model.language_model.", "language_model.", "text_model.", "model." }) |prefix| {
+        if (std.mem.startsWith(u8, k, prefix)) k = k[prefix.len..];
+    }
+    return k;
+}
+
+fn projection(key: []const u8) bool {
+    const k = canonical(key);
+    if (std.mem.eql(u8, k, "embed_tokens")) return true;
+    if (!std.mem.startsWith(u8, k, "layers.")) return false;
+    const tail = k[7..];
+    const dot = std.mem.indexOfScalar(u8, tail, '.') orelse return false;
+    if (dot == 0 or (dot > 1 and tail[0] == '0')) return false;
+    for (tail[0..dot]) |digit| if (digit < '0' or digit > '9') return false;
+    const index = std.fmt.parseInt(usize, tail[0..dot], 10) catch return false;
+    if (index >= layers) return false;
+    const name = tail[dot + 1 ..];
+    const mixer = schedule[index];
+    const names: []const []const u8 = if (mixer == .conv)
+        &.{ "conv.in_proj", "conv.out_proj", "feed_forward.w1", "feed_forward.w2", "feed_forward.w3" }
+    else
+        &.{ "self_attn.q_proj", "self_attn.k_proj", "self_attn.v_proj", "self_attn.o_proj", "self_attn.gate_proj", "feed_forward.w1", "feed_forward.w2", "feed_forward.w3" };
+    for (names) |name_| if (std.mem.eql(u8, name, name_)) return true;
+    return false;
+}
+
+fn quantWidth(o: std.json.ObjectMap) !Width {
+    const bits = try integer(o, "bits");
+    const group = try integer(o, "group_size");
+    if (o.get("mode")) |mode| {
+        if (mode != .string or !std.mem.eql(u8, mode.string, "affine")) return error.UnsupportedLfm3Quantization;
+    }
+    const w: Width = .{
+        .bits = std.math.cast(u8, bits) orelse return error.UnsupportedLfm3Quantization,
+        .group = std.math.cast(u16, group) orelse return error.UnsupportedLfm3Quantization,
+    };
+    try width(w);
+    return w;
+}
+
+pub const Config = struct {
+    arena: std.heap.ArenaAllocator,
+    kind: Kind,
+    context: usize,
+    layer_types: [layers]LayerType = schedule,
+    full_rotary: Rotary = .{ .theta = 1e6, .partial = 0.5 },
+    sliding_rotary: Rotary = .{ .theta = 1e4, .partial = 1 },
+    quant: Quant,
+
+    pub fn deinit(self: *Config) void {
+        self.arena.deinit();
+        self.* = undefined;
+    }
+
+    pub fn width(self: *const Config, key: []const u8) !Width {
+        return self.quant.width(key);
+    }
+
+    pub fn read(gpa: std.mem.Allocator, io: std.Io, dir: []const u8) !Config {
+        const path = try std.fs.path.join(gpa, &.{ dir, "config.json" });
+        defer gpa.free(path);
+        const bytes = try std.Io.Dir.cwd().readFileAlloc(io, path, gpa, .limited(1 << 22));
+        defer gpa.free(bytes);
+        return parse(gpa, bytes);
+    }
+};
+
+const Object = std.json.ObjectMap;
+
+fn object(v: std.json.Value) !Object {
+    return if (v == .object) v.object else error.BadLfm3Config;
+}
+
+fn field(o: Object, key: []const u8) !std.json.Value {
+    return o.get(key) orelse error.BadLfm3Config;
+}
+
+fn integer(o: Object, key: []const u8) !usize {
+    const v = try field(o, key);
+    if (v != .integer or v.integer < 1) return error.BadLfm3Config;
+    return std.math.cast(usize, v.integer) orelse error.BadLfm3Config;
+}
+
+fn string(o: Object, key: []const u8, expected: []const u8) !void {
+    const v = try field(o, key);
+    if (v != .string or !std.mem.eql(u8, v.string, expected)) return error.UnsupportedLfm3Config;
+}
+
+fn boolean(o: Object, key: []const u8, expected: bool) !void {
+    const v = try field(o, key);
+    if (v != .bool or v.bool != expected) return error.UnsupportedLfm3Config;
+}
+
+fn number(o: Object, key: []const u8, expected: f64) !void {
+    const v = try field(o, key);
+    const actual: f64 = switch (v) {
+        .integer => |i| @floatFromInt(i),
+        .float => |f| f,
+        else => return error.BadLfm3Config,
+    };
+    if (actual != expected) return error.UnsupportedLfm3Config;
+}
+
+fn geometry(o: Object, dims: anytype) !void {
+    inline for (dims) |d| if (try integer(o, d[0]) != d[1]) return error.UnsupportedLfm3Geometry;
+}
+
+fn layerTypes(o: Object, expected: []const LayerType) !void {
+    const v = try field(o, "layer_types");
+    if (v != .array or v.array.items.len != expected.len) return error.UnsupportedLfm3LayerSchedule;
+    for (v.array.items, expected) |actual, wanted| {
+        if (actual != .string or !std.mem.eql(u8, actual.string, @tagName(wanted)))
+            return error.UnsupportedLfm3LayerSchedule;
+    }
+}
+
+fn text(o: Object, kind: Kind) !usize {
+    try string(o, "model_type", "lfm3");
+    try geometry(o, .{
+        .{ "hidden_size", hidden },             .{ "vocab_size", vocab },       .{ "num_hidden_layers", layers },
+        .{ "intermediate_size", intermediate }, .{ "conv_L_cache", conv_taps }, .{ "num_attention_heads", query_heads },
+        .{ "num_key_value_heads", kv_heads },   .{ "head_dim", head_dim },      .{ "sliding_window", sliding_window },
+    });
+    try boolean(o, "conv_bias", false);
+    try boolean(o, "tie_word_embeddings", true);
+    try boolean(o, "use_sandwich_norm", true);
+    try string(o, "dtype", "bfloat16");
+    try number(o, "norm_eps", 1e-5);
+    try layerTypes(o, &schedule);
+    const rope = try object(try field(o, "rope_parameters"));
+    if (rope.count() != 2) return error.UnsupportedLfm3Rotary;
+    const full = try object(try field(rope, "full_attention"));
+    const sliding = try object(try field(rope, "sliding_attention"));
+    try rotary(full, 1e6, 0.5);
+    try rotary(sliding, 1e4, 1);
+    const context = try integer(o, "max_position_embeddings");
+    if (context != @as(usize, if (kind == .text) 262144 else 128000)) return error.UnsupportedLfm3Context;
+    return context;
+}
+
+fn rotary(o: Object, theta: f64, partial: f64) !void {
+    try string(o, "rope_type", "default");
+    try number(o, "rope_theta", theta);
+    if (o.contains("partial_rotary_factor")) try number(o, "partial_rotary_factor", partial) else if (partial != 1)
+        return error.UnsupportedLfm3Rotary;
+    var it = o.iterator();
+    while (it.next()) |e| {
+        const k = e.key_ptr.*;
+        if (!std.mem.eql(u8, k, "rope_type") and !std.mem.eql(u8, k, "rope_theta") and
+            !std.mem.eql(u8, k, "partial_rotary_factor")) return error.UnsupportedLfm3Rotary;
+    }
+}
+
+fn vision(root: Object) !void {
+    try boolean(root, "tie_word_embeddings", true);
+    try boolean(root, "projector_bias", true);
+    try string(root, "projector_hidden_act", "gelu");
+    try number(root, "projector_layer_norm_eps", 1e-6);
+    try geometry(root, .{
+        .{ "downsample_factor", 2 },   .{ "projector_hidden_size", 4096 },   .{ "image_token_id", 125030 },
+        .{ "video_token_id", 125029 }, .{ "vision_start_token_id", 125009 }, .{ "vision_end_token_id", 125010 },
+    });
+    const o = try object(try field(root, "vision_config"));
+    try string(o, "model_type", "lfm3_vl_vision");
+    try string(o, "dtype", "bfloat16");
+    try number(o, "norm_eps", 1e-5);
+    try geometry(o, .{
+        .{ "hidden_size", 1024 },       .{ "intermediate_size", 2560 }, .{ "num_hidden_layers", 14 },
+        .{ "num_attention_heads", 16 }, .{ "num_key_value_heads", 8 },  .{ "in_channels", 3 },
+        .{ "conv_kernel_size", 3 },     .{ "patch_size", 16 },          .{ "spatial_merge_size", 2 },
+        .{ "temporal_patch_size", 2 },
+    });
+    try layerTypes(o, &.{ .conv, .conv, .full_attention, .conv, .full_attention, .conv, .full_attention, .conv, .full_attention, .conv, .full_attention, .conv, .full_attention, .conv });
+    const rope = try object(try field(o, "rope_parameters"));
+    try string(rope, "rope_type", "axial");
+    try number(rope, "rope_theta", 1e6);
+    if (rope.count() != 2) return error.UnsupportedLfm3Rotary;
+}
+
+fn quantization(a: std.mem.Allocator, value: std.json.Value) !Quant {
+    const o = try object(value);
+    var it = o.iterator();
+    while (it.next()) |e| {
+        const key = e.key_ptr.*;
+        if (std.mem.eql(u8, key, "bits") or std.mem.eql(u8, key, "group_size") or std.mem.eql(u8, key, "mode")) continue;
+        if (e.value_ptr.* != .object) return error.UnsupportedLfm3Quantization;
+        const entry = e.value_ptr.object;
+        if (entry.count() < 2 or entry.count() > 3) return error.UnsupportedLfm3Quantization;
+        var fields = entry.iterator();
+        while (fields.next()) |f| {
+            const k = f.key_ptr.*;
+            if (!std.mem.eql(u8, k, "bits") and !std.mem.eql(u8, k, "group_size") and !std.mem.eql(u8, k, "mode"))
+                return error.UnsupportedLfm3Quantization;
+        }
+        if (!projection(key)) return error.UnsupportedLfm3Quantization;
+    }
+    var q: Quant = .{ .global = try quantWidth(o) };
+    it = o.iterator();
+    while (it.next()) |e| {
+        if (e.value_ptr.* != .object) continue;
+        const w = try quantWidth(e.value_ptr.object);
+        const slot = try q.modules.getOrPut(a, canonical(e.key_ptr.*));
+        if (slot.found_existing and !std.meta.eql(slot.value_ptr.*, w)) return error.UnsupportedLfm3Quantization;
+        slot.value_ptr.* = w;
+    }
+    return q;
+}
+
+fn width(w: Width) !void {
+    if ((w.bits != 4 and w.bits != 6 and w.bits != 8) or (w.group != 32 and w.group != 64))
+        return error.UnsupportedLfm3Quantization;
+}
+
+fn equalQuant(a: Quant, b: Quant) bool {
+    if (!std.meta.eql(a.global, b.global) or a.modules.count() != b.modules.count()) return false;
+    var it = a.modules.iterator();
+    while (it.next()) |e| {
+        const other = b.modules.get(e.key_ptr.*) orelse return false;
+        if (!std.meta.eql(e.value_ptr.*, other)) return false;
+    }
+    return true;
+}
+
+pub fn parse(gpa: std.mem.Allocator, bytes: []const u8) !Config {
+    var arena = std.heap.ArenaAllocator.init(gpa);
+    errdefer arena.deinit();
+    const a = arena.allocator();
+    const root = try object(try std.json.parseFromSliceLeaky(std.json.Value, a, bytes, .{ .allocate = .alloc_always }));
+    const tag = try field(root, "model_type");
+    if (tag != .string) return error.BadLfm3Config;
+    const kind: Kind = if (std.mem.eql(u8, tag.string, "lfm3")) .text else if (std.mem.eql(u8, tag.string, "lfm3_vl")) .vision_language else return error.UnsupportedLfm3Config;
+    const language = if (kind == .text) root else try object(try field(root, "text_config"));
+    const context = try text(language, kind);
+    if (kind == .vision_language) try vision(root);
+    const q = try quantization(a, root.get("quantization") orelse root.get("quantization_config") orelse
+        return error.UnsupportedLfm3Quantization);
+    if (root.get("quantization_config")) |other| {
+        if (!equalQuant(q, try quantization(a, other))) return error.UnsupportedLfm3Quantization;
+    }
+    return .{ .arena = arena, .kind = kind, .context = context, .quant = q };
+}
diff --git a/zig/src/families/lfm3/config_test.zig b/zig/src/families/lfm3/config_test.zig
new file mode 100644
index 0000000000..f1a1df00ce
--- /dev/null
+++ b/zig/src/families/lfm3/config_test.zig
@@ -0,0 +1,304 @@
+//! Checkpoint-derived config fixtures and refusal cases for the first LFM3 admission slice.
+const std = @import("std");
+const c = @import("config.zig");
+
+test "text and VL preserve their distinct context and actual mixed embedding width" {
+    var t = try c.parse(std.testing.allocator, text);
+    defer t.deinit();
+    var v = try c.parse(std.testing.allocator, vl);
+    defer v.deinit();
+    try std.testing.expectEqual(c.Kind.text, t.kind);
+    try std.testing.expectEqual(c.Kind.vision_language, v.kind);
+    try std.testing.expectEqual(@as(usize, 262144), t.context);
+    try std.testing.expectEqual(@as(usize, 128000), v.context);
+    try std.testing.expectEqual(c.Width{ .bits = 4, .group = 64 }, try t.width("model.embed_tokens"));
+    try std.testing.expectEqual(c.Width{ .bits = 8, .group = 32 }, try v.width("model.embed_tokens.weight"));
+    try std.testing.expectEqual(c.Width{ .bits = 4, .group = 32 }, try v.width("layers.0.conv.in_proj"));
+    try std.testing.expectEqual(c.LayerType.sliding_attention, t.layer_types[4]);
+    try std.testing.expectEqual(@as(f32, 0.5), t.full_rotary.partial);
+    try std.testing.expectEqual(@as(f32, 1), t.sliding_rotary.partial);
+}
+
+test "6 and 8 bit affine variants use the same config parser" {
+    inline for (.{ "6", "8" }) |bits| {
+        const replacement = "\"bits\": " ++ bits;
+        const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, text, "\"bits\": 4", replacement);
+        defer std.testing.allocator.free(bytes);
+        var config = try c.parse(std.testing.allocator, bytes);
+        defer config.deinit();
+        try std.testing.expectEqual(try std.fmt.parseInt(u8, bits, 10), config.quant.global.bits);
+    }
+}
+
+test "attention output and gate projections honor module widths and reject out_proj" {
+    inline for (.{ "o_proj", "gate_proj" }) |name| {
+        const replacement = "\"language_model.model.layers.2.self_attn." ++ name ++ "\": {";
+        const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, vl, "\"language_model.model.embed_tokens\": {", replacement);
+        defer std.testing.allocator.free(bytes);
+        var config = try c.parse(std.testing.allocator, bytes);
+        defer config.deinit();
+        try std.testing.expectEqual(c.Width{ .bits = 8, .group = 32 }, try config.width("model.layers.2.self_attn." ++ name));
+        try std.testing.expectEqual(c.Width{ .bits = 4, .group = 32 }, try config.width("model.layers.6.self_attn." ++ name));
+    }
+    const bad = try std.mem.replaceOwned(u8, std.testing.allocator, vl, "\"language_model.model.embed_tokens\": {", "\"language_model.model.layers.2.self_attn.out_proj\": {");
+    defer std.testing.allocator.free(bad);
+    try std.testing.expectError(error.UnsupportedLfm3Quantization, c.parse(std.testing.allocator, bad));
+}
+
+test "layer override indices must use canonical decimal spelling" {
+    inline for (.{ "02", "+2", "00", "-2", "" }) |index| {
+        const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, vl, "\"language_model.model.embed_tokens\": {", "\"language_model.model.layers." ++ index ++ ".self_attn.gate_proj\": {");
+        defer std.testing.allocator.free(bytes);
+        try std.testing.expectError(error.UnsupportedLfm3Quantization, c.parse(std.testing.allocator, bytes));
+    }
+    const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, vl, "\"language_model.model.embed_tokens\": {", "\"language_model.model.layers.0.conv.in_proj\": {");
+    defer std.testing.allocator.free(bytes);
+    var config = try c.parse(std.testing.allocator, bytes);
+    defer config.deinit();
+    try std.testing.expectEqual(c.Width{ .bits = 8, .group = 32 }, try config.width("layers.0.conv.in_proj"));
+}
+
+test "geometry, mixer schedule, rotary, sandwich and unsupported quantization fail admission" {
+    const cases = .{
+        .{ "\"hidden_size\": 2048", "\"hidden_size\": 1024", error.UnsupportedLfm3Geometry },
+        .{ "\"conv_L_cache\": 7", "\"conv_L_cache\": 3", error.UnsupportedLfm3Geometry },
+        .{ "\"sliding_attention\",", "\"full_attention\",", error.UnsupportedLfm3LayerSchedule },
+        .{ "\"partial_rotary_factor\": 0.5", "\"partial_rotary_factor\": 1.0", error.UnsupportedLfm3Config },
+        .{ "\"use_sandwich_norm\": true", "\"use_sandwich_norm\": false", error.UnsupportedLfm3Config },
+        .{ "\"bits\": 4", "\"bits\": 5", error.UnsupportedLfm3Quantization },
+        .{ "\"group_size\": 64", "\"group_size\": 128", error.UnsupportedLfm3Quantization },
+        .{ "\"max_position_embeddings\": 262144", "\"max_position_embeddings\": 128000", error.UnsupportedLfm3Context },
+    };
+    inline for (cases) |case| {
+        const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, text, case[0], case[1]);
+        defer std.testing.allocator.free(bytes);
+        try std.testing.expectError(case[2], c.parse(std.testing.allocator, bytes));
+    }
+}
+
+test "quantization declarations must agree and reject malformed or unknown overrides" {
+    const mismatch = try std.mem.replaceOwned(u8, std.testing.allocator, vl, "\"quantization_config\": {\n    \"group_size\": 32", "\"quantization_config\": {\n    \"group_size\": 64");
+    defer std.testing.allocator.free(mismatch);
+    try std.testing.expectError(error.UnsupportedLfm3Quantization, c.parse(std.testing.allocator, mismatch));
+    const cases = .{
+        .{ "\"language_model.model.embed_tokens\": {", "\"unknown_module\": {" },
+        .{ "\"language_model.model.embed_tokens\": {", "\"language_model.model.layers.99.conv.in_proj\": {" },
+        .{ "\"mode\": \"affine\"", "\"mode\": \"mxfp4\"" },
+    };
+    inline for (cases) |case| {
+        const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, vl, case[0], case[1]);
+        defer std.testing.allocator.free(bytes);
+        const result = c.parse(std.testing.allocator, bytes);
+        if (result) |value| {
+            var config = value;
+            config.deinit();
+            return error.TestExpectedError;
+        } else |_| {}
+    }
+}
+
+test "VL projector and vision geometry are not silently accepted as the known model" {
+    const bytes = try std.mem.replaceOwned(u8, std.testing.allocator, vl, "\"patch_size\": 16", "\"patch_size\": 14");
+    defer std.testing.allocator.free(bytes);
+    try std.testing.expectError(error.UnsupportedLfm3Geometry, c.parse(std.testing.allocator, bytes));
+}
+
+test "malformed JSON fails without retaining allocations" {
+    try std.testing.expectError(error.UnexpectedEndOfInput, c.parse(std.testing.allocator, "{"));
+}
+
+pub const text =
+    \\{
+    \\  "model_type": "lfm3",
+    \\  "conv_L_cache": 7,
+    \\  "conv_bias": false,
+    \\  "dtype": "bfloat16",
+    \\  "head_dim": 128,
+    \\  "hidden_size": 2048,
+    \\  "intermediate_size": 7680,
+    \\  "layer_types": [
+    \\    "conv",
+    \\    "conv",
+    \\    "full_attention",
+    \\    "conv",
+    \\    "sliding_attention",
+    \\    "conv",
+    \\    "full_attention",
+    \\    "conv",
+    \\    "sliding_attention",
+    \\    "conv",
+    \\    "full_attention",
+    \\    "conv",
+    \\    "sliding_attention",
+    \\    "conv",
+    \\    "full_attention",
+    \\    "conv",
+    \\    "sliding_attention",
+    \\    "conv",
+    \\    "full_attention",
+    \\    "conv",
+    \\    "sliding_attention",
+    \\    "conv",
+    \\    "full_attention",
+    \\    "conv"
+    \\  ],
+    \\  "max_position_embeddings": 262144,
+    \\  "norm_eps": 1e-05,
+    \\  "num_attention_heads": 16,
+    \\  "num_hidden_layers": 24,
+    \\  "num_key_value_heads": 4,
+    \\  "quantization": {
+    \\    "group_size": 64,
+    \\    "bits": 4,
+    \\    "mode": "affine"
+    \\  },
+    \\  "quantization_config": {
+    \\    "group_size": 64,
+    \\    "bits": 4,
+    \\    "mode": "affine"
+    \\  },
+    \\  "rope_parameters": {
+    \\    "full_attention": {
+    \\      "partial_rotary_factor": 0.5,
+    \\      "rope_theta": 1000000.0,
+    \\      "rope_type": "default"
+    \\    },
+    \\    "sliding_attention": {
+    \\      "rope_theta": 10000,
+    \\      "rope_type": "default"
+    \\    }
+    \\  },
+    \\  "sliding_window": 256,
+    \\  "tie_word_embeddings": true,
+    \\  "use_sandwich_norm": true,
+    \\  "vocab_size": 128000
+    \\}
+;
+
+pub const vl =
+    \\{
+    \\  "downsample_factor": 2,
+    \\  "dtype": "bfloat16",
+    \\  "image_token_id": 125030,
+    \\  "model_type": "lfm3_vl",
+    \\  "projector_bias": true,
+    \\  "projector_hidden_act": "gelu",
+    \\  "projector_hidden_size": 4096,
+    \\  "projector_layer_norm_eps": 1e-06,
+    \\  "text_config": {
+    \\    "conv_L_cache": 7,
+    \\    "conv_bias": false,
+    \\    "dtype": "bfloat16",
+    \\    "head_dim": 128,
+    \\    "hidden_size": 2048,
+    \\    "intermediate_size": 7680,
+    \\    "layer_types": [
+    \\      "conv",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "sliding_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "sliding_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "sliding_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "sliding_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "sliding_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv"
+    \\    ],
+    \\    "max_position_embeddings": 128000,
+    \\    "model_type": "lfm3",
+    \\    "norm_eps": 1e-05,
+    \\    "num_attention_heads": 16,
+    \\    "num_hidden_layers": 24,
+    \\    "num_key_value_heads": 4,
+    \\    "rope_parameters": {
+    \\      "full_attention": {
+    \\        "partial_rotary_factor": 0.5,
+    \\        "rope_theta": 1000000.0,
+    \\        "rope_type": "default"
+    \\      },
+    \\      "sliding_attention": {
+    \\        "rope_theta": 10000,
+    \\        "rope_type": "default"
+    \\      }
+    \\    },
+    \\    "sliding_window": 256,
+    \\    "tie_word_embeddings": true,
+    \\    "use_sandwich_norm": true,
+    \\    "vocab_size": 128000
+    \\  },
+    \\  "tie_word_embeddings": true,
+    \\  "video_token_id": 125029,
+    \\  "vision_config": {
+    \\    "conv_kernel_size": 3,
+    \\    "dtype": "bfloat16",
+    \\    "hidden_size": 1024,
+    \\    "in_channels": 3,
+    \\    "initializer_range": 0.02,
+    \\    "intermediate_size": 2560,
+    \\    "layer_types": [
+    \\      "conv",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv",
+    \\      "full_attention",
+    \\      "conv"
+    \\    ],
+    \\    "model_type": "lfm3_vl_vision",
+    \\    "norm_eps": 1e-05,
+    \\    "num_attention_heads": 16,
+    \\    "num_hidden_layers": 14,
+    \\    "num_key_value_heads": 8,
+    \\    "patch_size": 16,
+    \\    "rope_parameters": {
+    \\      "rope_theta": 1000000.0,
+    \\      "rope_type": "axial"
+    \\    },
+    \\    "spatial_merge_size": 2,
+    \\    "temporal_patch_size": 2
+    \\  },
+    \\  "vision_end_token_id": 125010,
+    \\  "vision_start_token_id": 125009,
+    \\  "quantization": {
+    \\    "group_size": 32,
+    \\    "bits": 4,
+    \\    "mode": "affine",
+    \\    "language_model.model.embed_tokens": {
+    \\      "group_size": 32,
+    \\      "bits": 8,
+    \\      "mode": "affine"
+    \\    }
+    \\  },
+    \\  "quantization_config": {
+    \\    "group_size": 32,
+    \\    "bits": 4,
+    \\    "mode": "affine",
+    \\    "language_model.model.embed_tokens": {
+    \\      "group_size": 32,
+    \\      "bits": 8,
+    \\      "mode": "affine"
+    \\    }
+    \\  }
+    \\}
+;
diff --git a/zig/src/families/lfm3/lfm3.zig b/zig/src/families/lfm3/lfm3.zig
new file mode 100644
index 0000000000..7372c2676c
--- /dev/null
+++ b/zig/src/families/lfm3/lfm3.zig
@@ -0,0 +1,3 @@
+//! Host checkpoint admission for LFM3; no runtime family is registered by this module.
+pub const config = @import("config.zig");
+pub const weights = @import("weights.zig");
diff --git a/zig/src/families/lfm3/weights.zig b/zig/src/families/lfm3/weights.zig
new file mode 100644
index 0000000000..11b3aa1f39
--- /dev/null
+++ b/zig/src/families/lfm3/weights.zig
@@ -0,0 +1,110 @@
+//! Host-only LFM3 text tensor admission; no weights are uploaded and a vision tower is not qualified here.
+const std = @import("std");
+const st = @import("safetensors");
+const c = @import("config.zig");
+const Allocator = std.mem.Allocator;
+
+pub const Namespace = enum {
+    bare,
+    wrapped,
+
+    pub fn prefix(n: Namespace) []const u8 {
+        return if (n == .bare) "model." else "language_model.model.";
+    }
+};
+
+pub const Expected = struct {
+    name: []const u8,
+    dtype: st.DType,
+    rank: u8,
+    shape: [st.max_rank]usize,
+};
+
+pub const Manifest = struct { namespace: Namespace, tensors: usize, bytes: usize };
+
+fn dense(a: Allocator, out: *std.ArrayList(Expected), name: []const u8, shape: []const usize, dtype: st.DType) !void {
+    var e: Expected = .{ .name = try a.dupe(u8, name), .dtype = dtype, .rank = @intCast(shape.len), .shape = @splat(1) };
+    @memcpy(e.shape[0..shape.len], shape);
+    try out.append(a, e);
+}
+
+fn named(a: Allocator, out: *std.ArrayList(Expected), prefix: []const u8, suffix: []const u8, shape: []const usize) !void {
+    var buf: [256]u8 = undefined;
+    try dense(a, out, try std.fmt.bufPrint(&buf, "{s}{s}", .{ prefix, suffix }), shape, .bf16);
+}
+
+fn affine(a: Allocator, out: *std.ArrayList(Expected), cfg: *const c.Config, prefix: []const u8, suffix: []const u8, n: usize, k: usize) !void {
+    var buf: [256]u8 = undefined;
+    const module = try std.fmt.bufPrint(&buf, "{s}{s}", .{ prefix, suffix });
+    const q = try cfg.width(module);
+    if (k % q.group != 0 or k * q.bits % 32 != 0) return error.UnsupportedQuantization;
+    var name: [272]u8 = undefined;
+    try dense(a, out, try std.fmt.bufPrint(&name, "{s}.weight", .{module}), &.{ n, k * q.bits / 32 }, .u32);
+    try dense(a, out, try std.fmt.bufPrint(&name, "{s}.scales", .{module}), &.{ n, k / q.group }, .bf16);
+    try dense(a, out, try std.fmt.bufPrint(&name, "{s}.biases", .{module}), &.{ n, k / q.group }, .bf16);
+}
+
+/// Expected metadata for one text decoder; allocate the returned names and list in a caller-owned arena.
+pub fn schema(a: Allocator, cfg: *const c.Config, namespace: Namespace) ![]Expected {
+    var out: std.ArrayList(Expected) = .empty;
+    const prefix = namespace.prefix();
+    try affine(a, &out, cfg, prefix, "embed_tokens", c.vocab, c.hidden);
+    try named(a, &out, prefix, "embedding_norm.weight", &.{c.hidden});
+    for (cfg.layer_types, 0..) |kind, i| {
+        var buf: [128]u8 = undefined;
+        const p = try std.fmt.bufPrint(&buf, "{s}layers.{d}.", .{ prefix, i });
+        for ([_][]const u8{ "operator_norm.weight", "ffn_norm.weight", "post_operator_norm.weight", "post_ffn_norm.weight" }) |n|
+            try named(a, &out, p, n, &.{c.hidden});
+        try affine(a, &out, cfg, p, "feed_forward.w1", c.intermediate, c.hidden);
+        try affine(a, &out, cfg, p, "feed_forward.w3", c.intermediate, c.hidden);
+        try affine(a, &out, cfg, p, "feed_forward.w2", c.hidden, c.intermediate);
+        if (kind == .conv) {
+            try affine(a, &out, cfg, p, "conv.in_proj", 3 * c.hidden, c.hidden);
+            try affine(a, &out, cfg, p, "conv.out_proj", c.hidden, c.hidden);
+            try named(a, &out, p, "conv.conv.weight", &.{ c.hidden, c.conv_taps, 1 });
+        } else {
+            try affine(a, &out, cfg, p, "self_attn.q_proj", c.query_heads * c.head_dim, c.hidden);
+            try affine(a, &out, cfg, p, "self_attn.k_proj", c.kv_heads * c.head_dim, c.hidden);
+            try affine(a, &out, cfg, p, "self_attn.v_proj", c.kv_heads * c.head_dim, c.hidden);
+            try affine(a, &out, cfg, p, "self_attn.o_proj", c.hidden, c.query_heads * c.head_dim);
+            try affine(a, &out, cfg, p, "self_attn.gate_proj", c.query_heads, c.hidden);
+            try named(a, &out, p, "self_attn.q_norm.weight", &.{c.head_dim});
+            try named(a, &out, p, "self_attn.k_norm.weight", &.{c.head_dim});
+        }
+    }
+    return out.toOwnedSlice(a);
+}
+
+/// Validate a merged safetensors header; the shared parser must have checked shard byte ranges first.
+pub fn validate(a: Allocator, cfg: *const c.Config, header: *const st.Header) !Manifest {
+    const bare = header.contains("model.embed_tokens.weight");
+    const wrapped = header.contains("language_model.model.embed_tokens.weight");
+    if (bare and wrapped) return error.MixedNamespaces;
+    if (!bare and !wrapped) return error.MissingTensor;
+    const namespace: Namespace = if (bare) .bare else .wrapped;
+    var arena = std.heap.ArenaAllocator.init(a);
+    defer arena.deinit();
+    const expected = try schema(arena.allocator(), cfg, namespace);
+    var names: std.StringHashMapUnmanaged(void) = .empty;
+    var bytes: usize = 0;
+    for (expected) |e| {
+        const actual = header.get(e.name) orelse return error.MissingTensor;
+        if (actual.dtype != e.dtype) return error.TensorDType;
+        if (actual.rank != e.rank or !std.mem.eql(usize, actual.shape[0..actual.rank], e.shape[0..e.rank])) return error.TensorShape;
+        var size: usize = e.dtype.size();
+        for (e.shape[0..e.rank]) |dim| size = std.math.mul(usize, size, dim) catch return error.TensorBytes;
+        if (actual.end < actual.begin or actual.end - actual.begin != size) return error.TensorBytes;
+        bytes = std.math.add(usize, bytes, size) catch return error.TensorBytes;
+        try names.put(arena.allocator(), e.name, {});
+    }
+    for (header.keys()) |name| {
+        if (std.mem.startsWith(u8, name, "model.") or std.mem.startsWith(u8, name, "language_model.")) {
+            if (!names.contains(name)) return error.UnexpectedTensor;
+        }
+    }
+    return .{ .namespace = namespace, .tensors = expected.len, .bytes = bytes };
+}
+
+test {
+    _ = @import("weights_test.zig");
+}
diff --git a/zig/src/families/lfm3/weights_test.zig b/zig/src/families/lfm3/weights_test.zig
new file mode 100644
index 0000000000..5f7ee96629
--- /dev/null
+++ b/zig/src/families/lfm3/weights_test.zig
@@ -0,0 +1,103 @@
+//! Metadata fixtures exercise admission without allocating tensor payloads or a GPU device.
+const std = @import("std");
+const w = @import("weights.zig");
+const c = @import("config.zig");
+const st = @import("safetensors");
+
+fn config(bits: u8, group: u16) c.Config {
+    return .{ .arena = std.heap.ArenaAllocator.init(std.testing.allocator), .kind = .text, .context = 262144, .quant = .{ .global = .{ .bits = bits, .group = group } } };
+}
+
+fn header(a: std.mem.Allocator, cfg: *const c.Config, namespace: w.Namespace) !st.Header {
+    var h: st.Header = .empty;
+    var offset: usize = 0;
+    for (try w.schema(a, cfg, namespace)) |e| {
+        var bytes: usize = e.dtype.size();
+        for (e.shape[0..e.rank]) |d| bytes *= d;
+        try h.put(a, e.name, .{ .dtype = e.dtype, .rank = e.rank, .shape = e.shape, .begin = offset, .end = offset + bytes });
+        offset += bytes;
+    }
+    return h;
+}
+
+test "official text4 tensor count and bytes; both namespaces and every target bit width" {
+    for ([_]u8{ 4, 6, 8 }) |bits| for ([_]w.Namespace{ .bare, .wrapped }) |namespace| {
+        var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+        defer arena.deinit();
+        var cfg = config(bits, 64);
+        defer cfg.deinit();
+        const h = try header(arena.allocator(), &cfg, namespace);
+        const m = try w.validate(std.testing.allocator, &cfg, &h);
+        try std.testing.expectEqual(@as(usize, 594), m.tensors);
+        try std.testing.expectEqual(namespace, m.namespace);
+        if (bits == 4) try std.testing.expectEqual(@as(usize, 973008384), m.bytes);
+    };
+}
+
+test "VL text uses mixed8 embedding with group32 without admitting its image tower" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const a = arena.allocator();
+    var cfg = config(4, 32);
+    defer cfg.deinit();
+    cfg.kind = .vision_language;
+    try cfg.quant.modules.put(cfg.arena.allocator(), "embed_tokens", .{ .bits = 8, .group = 32 });
+    var h = try header(a, &cfg, .wrapped);
+    const embed = h.get("language_model.model.embed_tokens.weight").?;
+    try std.testing.expectEqual(@as(usize, 512), embed.shape[1]);
+    const gate = h.get("language_model.model.layers.2.self_attn.gate_proj.scales").?;
+    try std.testing.expectEqualSlices(usize, &.{ 16, 64 }, gate.shape[0..2]);
+    try h.put(a, "vision_tower.unqualified.weight", .{ .dtype = .bf16, .rank = 1, .shape = .{ 1, 1, 1, 1, 1 }, .begin = 0, .end = 2 });
+    const m = try w.validate(std.testing.allocator, &cfg, &h);
+    try std.testing.expectEqual(@as(usize, 594), m.tensors);
+    try std.testing.expectEqual(@as(usize, 1212106240), m.bytes);
+}
+
+test "missing head gate, wrong packed width and malformed convolution are rejected" {
+    const keys = [_][]const u8{
+        "language_model.model.layers.2.self_attn.gate_proj.weight",
+        "language_model.model.layers.0.conv.in_proj.weight",
+        "language_model.model.layers.0.conv.conv.weight",
+        "language_model.model.layers.0.post_operator_norm.weight",
+    };
+    for (keys, 0..) |key, i| {
+        var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+        defer arena.deinit();
+        var cfg = config(4, 64);
+        defer cfg.deinit();
+        var h = try header(arena.allocator(), &cfg, .wrapped);
+        if (i == 0) {
+            _ = h.swapRemove(key);
+            try std.testing.expectError(error.MissingTensor, w.validate(std.testing.allocator, &cfg, &h));
+        } else {
+            h.getPtr(key).?.shape[if (i == 3) 0 else 1] += 1;
+            try std.testing.expectError(error.TensorShape, w.validate(std.testing.allocator, &cfg, &h));
+        }
+    }
+}
+
+test "bad dtype, byte range, namespace and unexpected text tensors are rejected" {
+    for (0..4) |mode| {
+        var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+        defer arena.deinit();
+        var cfg = config(4, 64);
+        defer cfg.deinit();
+        var h = try header(arena.allocator(), &cfg, .wrapped);
+        const key = "language_model.model.embed_tokens.weight";
+        switch (mode) {
+            0 => h.getPtr(key).?.dtype = .bf16,
+            1 => h.getPtr(key).?.end -= 1,
+            2 => try h.put(arena.allocator(), "model.embed_tokens.weight", h.get(key).?),
+            3 => try h.put(arena.allocator(), "language_model.lm_head.weight", h.get(key).?),
+            else => unreachable,
+        }
+        const err = switch (mode) {
+            0 => error.TensorDType,
+            1 => error.TensorBytes,
+            2 => error.MixedNamespaces,
+            3 => error.UnexpectedTensor,
+            else => unreachable,
+        };
+        try std.testing.expectError(err, w.validate(std.testing.allocator, &cfg, &h));
+    }
+}