Pin plain NVFP4 build, source, and bounded validation plan

README.md

@@ -0,0 +1,13 @@
+---
+license: apache-2.0
+base_model: Agnes-AI/Agnes-3.0-Flash
+base_model_relation: quantized
+pipeline_tag: image-text-to-text
+tags:
+- nvfp4
+- modelopt
+- quantized
+---
+# Agnes-3.0-Flash Preview — plain NVFP4
+
+Private build in progress. The pinned source is the 33B Preview checkpoint with 262144 context. Native evaluation and public release are pending.

reproducibility/bootstrap_build.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+mkdir -p /workspace/agnes/code
+python -m pip install --break-system-packages --no-cache-dir uv
+uv venv --system-site-packages /workspace/agnes/venv
+export PATH="/workspace/agnes/venv/bin:$PATH"
+uv pip install --python /workspace/agnes/venv/bin/python \
+  'torch==2.13.0' 'transformers==5.14.0' 'accelerate==1.12.0' \
+  'huggingface_hub==1.18.0' 'pillow>=12' 'sentencepiece>=0.2' 'einops' \
+  'nvidia-modelopt @ https://github.com/NVIDIA/Model-Optimizer/archive/5cae3940402f1ced98069a666b0bec72ec8b33b5.tar.gz'
+python - <<'PY'
+import os
+from huggingface_hub import hf_hub_download
+hf_hub_download('ProCreations/Agnes-3.0-Flash-NVFP4','reproducibility/build.py',
+    revision=os.environ['AGNES_CODE_REVISION'],local_dir='/workspace/agnes/code')
+PY
+python -u /workspace/agnes/code/reproducibility/build.py

reproducibility/build.py

@@ -0,0 +1,208 @@
+"""Plain data-free NVFP4; deterministic source-supported FFN folding."""
+import collections
+import copy
+import gc
+import hashlib
+import importlib.metadata
+import json
+import os
+import re
+import shutil
+import time
+from pathlib import Path
+
+import torch
+from huggingface_hub import HfApi, snapshot_download
+from safetensors import safe_open
+from safetensors.torch import save_file
+from transformers import AutoModelForImageTextToText
+import modelopt.torch.quantization as mtq
+from modelopt.torch.quantization.nn import TensorQuantizer
+from modelopt.torch.export import export_hf_checkpoint
+
+SOURCE = 'Agnes-AI/Agnes-3.0-Flash'
+REV = '24f712ce59379b54c4a141d2708c35daf5ff613b'
+TARGET = 'ProCreations/Agnes-3.0-Flash-NVFP4'
+ROOT = Path('/workspace/agnes')
+OUTPUT = ROOT/'export'
+API = HfApi()
+SELECT = re.compile(r'^model\.language_model\.layers\.\d+\.(?:mlp\.(?:gate_proj|up_proj|down_proj)|global_attn\.(?:q_proj|k_proj|v_proj|o_proj))\.weight$')
+REPORT = dict(source=SOURCE, source_revision=REV, target=TARGET,
+    status='building', code_revision=os.environ['AGNES_CODE_REVISION'],
+    modelopt_revision='5cae3940402f1ced98069a666b0bec72ec8b33b5',
+    quantization=dict(method='plain NVFP4 max', training=False, calibration_examples=0,
+        calibration_tokens=0, calibration_forward_calls=0, activation_global_scale=1.0,
+        block_size=16, activation_block_scales='dynamic E4M3', kv_cache_quantized=False),
+    folding=dict(main_width=17408, parallel_width=2048, folded_width=19456,
+        gate_up_dimension=0, down_dimension=1, layers=72,
+        reason='Match the upstream SGLang BF16 loader before quantization'),
+    evaluation=dict(status='pending'))
+
+def record():
+    (ROOT/'quality_report.json').write_text(json.dumps(REPORT, indent=2)+'\n')
+    API.upload_file(repo_id=TARGET, path_or_fileobj=str(ROOT/'quality_report.json'),
+        path_in_repo='quality_report.json', commit_message='Record plain NVFP4 build checks')
+
+def selected(name):
+    return bool(SELECT.fullmatch(name))
+
+def main():
+    assert API.model_info(TARGET).private
+    assert not any(n.endswith('.safetensors') for n in API.list_repo_files(TARGET))
+    ROOT.mkdir(parents=True, exist_ok=True)
+    torch.set_num_threads(8)
+    torch.manual_seed(20260912)
+    REPORT['versions'] = {p:importlib.metadata.version(p) for p in ['torch','transformers','nvidia-modelopt','accelerate']}
+    REPORT['hardware'] = [torch.cuda.get_device_name(0)]
+    record()
+    source = Path(snapshot_download(SOURCE, revision=REV, max_workers=8))
+    src_index = json.loads((source/'model.safetensors.index.json').read_text())
+    src_map = src_index['weight_map']
+    model = AutoModelForImageTextToText.from_pretrained(source, trust_remote_code=True,
+        dtype=torch.bfloat16, device_map={'':0}, attn_implementation='sdpa').eval()
+    assert all(p.device.type == 'cuda' for p in model.parameters())
+    assert len(model.model.language_model.layers) == 72
+    with torch.no_grad():
+        for layer in model.model.language_model.layers:
+            mlp = layer.mlp
+            assert mlp.parallel_ffn is not None
+            for name in ['gate_proj','up_proj','down_proj']:
+                original, branch = getattr(mlp,name), getattr(mlp.parallel_ffn,name)
+                dim = 1 if name == 'down_proj' else 0
+                merged = torch.cat([original.weight,branch.weight], dim=dim)
+                # Check both slices before discarding the separate branches.
+                a,b = merged.split([original.weight.shape[dim],branch.weight.shape[dim]],dim=dim)
+                assert torch.equal(a,original.weight) and torch.equal(b,branch.weight)
+                replacement = torch.nn.Linear(merged.shape[1],merged.shape[0],bias=False,
+                    device=merged.device,dtype=merged.dtype)
+                replacement.weight = torch.nn.Parameter(merged,requires_grad=False)
+                setattr(mlp,name,replacement)
+            mlp.parallel_ffn = None
+    text = model.config.text_config
+    text.agnes_original_intermediate_size = 17408
+    text.agnes_original_parallel_ffn_intermediate_size = 2048
+    text.intermediate_size = 19456
+    text.parallel_ffn_intermediate_size = 0
+    gc.collect(); torch.cuda.empty_cache()
+    preset = copy.deepcopy(mtq.NVFP4_DEFAULT_CFG)
+    weight = next(x['cfg'] for x in preset['quant_cfg'] if x.get('quantizer_name')=='*weight_quantizer')
+    activation = next(x['cfg'] for x in preset['quant_cfg'] if x.get('quantizer_name')=='*input_quantizer')
+    activation['constant_amax'] = 2688.0
+    rules = [dict(quantizer_name='*',enable=False)]
+    targets = [name for name,module in model.named_modules()
+               if isinstance(module,torch.nn.Linear) and selected(name+'.weight')]
+    assert len(targets) == 288, len(targets)
+    for name in targets:
+        rules += [dict(quantizer_name=name+'.weight_quantizer',cfg=weight),
+                  dict(quantizer_name=name+'.input_quantizer',cfg=activation)]
+    cfg = dict(quant_cfg=rules,algorithm=dict(method='max',layerwise=dict(enable=False),
+        skip_forward_without_activation_calib=True))
+    REPORT['quantization']['configuration'] = cfg
+    def forbid(*args):
+        REPORT['quantization']['calibration_forward_calls'] += 1
+        raise RuntimeError('Data-free quantization may not execute calibration forwards')
+    hook = model.register_forward_pre_hook(forbid)
+    started = time.monotonic()
+    with torch.inference_mode():
+        mtq.quantize(model,cfg,forward_loop=None)
+        enabled = [(name,m) for name,m in model.named_modules()
+                   if isinstance(m,TensorQuantizer) and m.is_enabled]
+        assert len(enabled) == 576, len(enabled)
+        assert all(name.rsplit('.',1)[0] in targets for name,m in enabled)
+        assert all(getattr(m,'_amax',None) is not None for name,m in enabled if name.endswith('weight_quantizer'))
+        REPORT['quantization']['weight_statistics_seconds'] = time.monotonic()-started
+        hook.remove()
+        REPORT['export_graph_inspection'] = dict(dummy_forward_calls=0,input_tokens=0,quantizers_disabled=True)
+        def inspect_probe(module,args):
+            assert not any(isinstance(m,TensorQuantizer) and (m.is_enabled or m._if_calib) for m in module.modules())
+            assert args[0].shape == (1,2) and torch.equal(args[0],torch.ones_like(args[0]))
+            REPORT['export_graph_inspection']['dummy_forward_calls'] += 1
+            REPORT['export_graph_inspection']['input_tokens'] += args[0].numel()
+        hook = model.register_forward_pre_hook(inspect_probe)
+        export_hf_checkpoint(model,dtype=torch.bfloat16,export_dir=OUTPUT,max_shard_size='5GB')
+        hook.remove()
+    del model,enabled
+    gc.collect(); torch.cuda.empty_cache()
+    # The upstream Transformers class ignores MTP: retain every original MTP
+    # tensor separately, without advertising untested speculative decoding.
+    dst_index = json.loads((OUTPUT/'model.safetensors.index.json').read_text())
+    mtp = {}
+    for name,filename in src_map.items():
+        if name.startswith('mtp.'):
+            with safe_open(source/filename,framework='pt',device='cpu') as f:
+                mtp[name] = f.get_tensor(name).clone()
+    assert mtp and not any(name in dst_index['weight_map'] for name in mtp)
+    save_file(mtp,str(OUTPUT/'model-mtp.safetensors'),metadata={'format':'pt'})
+    dst_index['weight_map'].update({name:'model-mtp.safetensors' for name in mtp})
+    dst_index['metadata']['total_size'] += sum(t.numel()*t.element_size() for t in mtp.values())
+    (OUTPUT/'model.safetensors.index.json').write_text(json.dumps(dst_index,indent=2)+'\n')
+    for file in source.rglob('*'):
+        rel=file.relative_to(source)
+        if file.is_file() and '.cache' not in rel.parts and not file.name.endswith('.safetensors') and file.name not in ['config.json','model.safetensors.index.json','README.md','.gitattributes']:
+            (OUTPUT/rel).parent.mkdir(parents=True,exist_ok=True)
+            shutil.copy2(file,OUTPUT/rel)
+    # The upstream loader otherwise skips renaming when the branch width is 0.
+    # This checkpoint has already folded its branches before quantization.
+    for file in OUTPUT.glob('sglang_patch/*/sglang/srt/models/qwen3_5.py'):
+        contents=file.read_text()
+        before='    if width <= 0:\n        yield from weights\n        return\n'
+        after='    if width <= 0:\n        for name, weight in weights:\n            yield name.replace(".delta_attn.", ".linear_attn.").replace(".global_attn.", ".self_attn."), weight\n        return\n'
+        assert contents.count(before)==1
+        file.write_text(contents.replace(before,after))
+    # Both Transformers names and translated serving names must be excluded.
+    for filename in ['config.json','hf_quant_config.json']:
+        file=OUTPUT/filename
+        obj=json.loads(file.read_text())
+        quant=obj['quantization_config'] if filename=='config.json' else obj['quantization']
+        excludes=list(quant.get('exclude_modules',[]))
+        excludes += ['lm_head','model.visual*','mtp*']
+        for i in range(72):
+            excludes += [f'model.language_model.layers.{i}.delta_attn*',
+                         f'model.language_model.layers.{i}.linear_attn*']
+        quant['exclude_modules']=sorted(set(excludes))
+        file.write_text(json.dumps(obj,indent=2)+'\n')
+    preserved=0; preserved_count=0
+    for filename in sorted(set(src_map.values())):
+        with safe_open(source/filename,framework='pt',device='cpu') as sf:
+            for name in sf.keys():
+                if selected(name) or '.mlp.parallel_ffn.' in name: continue
+                assert name in dst_index['weight_map'],name
+                with safe_open(OUTPUT/dst_index['weight_map'][name],framework='pt',device='cpu') as df:
+                    a,b=sf.get_tensor(name),df.get_tensor(name)
+                    assert a.dtype==b.dtype and torch.equal(a,b),name
+                    preserved += a.numel()*a.element_size(); preserved_count+=1
+    counts=collections.Counter(); packed=0; inputs=0
+    for filename in sorted(set(dst_index['weight_map'].values())):
+        with safe_open(OUTPUT/filename,framework='pt',device='cpu') as f:
+            for name in f.keys():
+                tensor=f.get_tensor(name)
+                counts[str(tensor.dtype)]+=tensor.numel()*tensor.element_size()
+                if selected(name):
+                    assert tensor.dtype==torch.uint8,name
+                    packed+=1
+                if 'scale' in name:
+                    assert torch.isfinite(tensor.float()).all() and (tensor.float()>0).all(),name
+                if name.endswith('input_scale'):
+                    assert torch.equal(tensor,torch.ones_like(tensor)),name
+                    inputs+=1
+    assert packed==len(targets)==288 and inputs==288,(packed,inputs)
+    assert REPORT['quantization']['calibration_forward_calls']==0
+    REPORT['export']=dict(source_tensor_bytes=src_index['metadata']['total_size'],
+        exported_weight_bytes=sum((OUTPUT/f).stat().st_size for f in set(dst_index['weight_map'].values())),
+        tensor_bytes_by_dtype=dict(counts),packed_linear_weights=packed,
+        bf16_preserved_bytes=preserved,bf16_preserved_tensors=preserved_count,
+        all_unquantized_tensors_bitwise_equal=True,mtp_tensors_preserved=len(mtp),
+        activation_global_scales_exactly_one=inputs)
+    REPORT['status']='packed_export_verified_pending_native_evaluation'
+    record()
+    shutil.copy2(ROOT/'quality_report.json',OUTPUT/'quality_report.json')
+    API.upload_folder(repo_id=TARGET,folder_path=OUTPUT,
+        commit_message='Upload verified plain NVFP4 Agnes Preview checkpoint')
+    print('AGNES_BUILD_COMPLETE '+json.dumps(REPORT['export']),flush=True)
+
+if __name__=='__main__':
+    try: main()
+    except Exception:
+        REPORT['status']='build_failed'
+        record()
+        raise

reproducibility/dispatch_build.py

@@ -0,0 +1,52 @@
+"""One data-free build; hard timeout and a separate bounded Agnes ledger."""
+import json
+from pathlib import Path
+from huggingface_hub import HfApi, CommitOperationAdd, get_token
+
+ROOT=Path(__file__).resolve().parent
+api=HfApi()
+repo='ProCreations/Agnes-3.0-Flash-NVFP4'
+assert api.whoami()['name']=='ProCreations'
+ledger=ROOT/'jobs.jsonl'
+assert not ledger.exists(),'Inspect previous attempts before dispatching again'
+api.create_repo(repo_id=repo,private=True,exist_ok=True)
+assert api.model_info(repo).private
+assert not any(n.endswith('.safetensors') for n in api.list_repo_files(repo))
+plan=dict(source='Agnes-AI/Agnes-3.0-Flash',source_revision='24f712ce59379b54c4a141d2708c35daf5ff613b',
+    target=repo,method='plain data-free NVFP4',training=False,calibration_examples=0,
+    quantized='All decoder MLP and global attention linear weights; branches folded as in upstream SGLang',
+    preserved='Recurrent attention, vision, embeddings, output head, norms, MTP',
+    agnes_compute_ceiling_usd=40,prior_nex_compute_upper_bound_usd=98.303050825,
+    combined_user_cap_usd=200,publication='Public after native validation')
+(ROOT/'plan.json').write_text(json.dumps(plan,indent=2)+'\n')
+readme='''---
+license: apache-2.0
+base_model: Agnes-AI/Agnes-3.0-Flash
+base_model_relation: quantized
+pipeline_tag: image-text-to-text
+tags:
+- nvfp4
+- modelopt
+- quantized
+---
+# Agnes-3.0-Flash Preview — plain NVFP4
+
+Private build in progress. The pinned source is the 33B Preview checkpoint with 262144 context. Native evaluation and public release are pending.
+'''
+(ROOT/'README.pending.md').write_text(readme)
+names=['build.py','bootstrap_build.sh','dispatch_build.py','plan.json','source_meta.json','runtime_image.json']
+commit=api.create_commit(repo_id=repo,operations=[CommitOperationAdd(path_in_repo='reproducibility/'+n,path_or_fileobj=str(ROOT/n)) for n in names]+[
+    CommitOperationAdd(path_in_repo='README.md',path_or_fileobj=str(ROOT/'README.pending.md'))],
+    commit_message='Pin plain NVFP4 build, source, and bounded validation plan')
+rate=next(h.unit_cost_usd*60 for h in api.list_jobs_hardware() if h.name=='h200')
+job=api.run_job(image='pytorch/pytorch:2.13.0-cuda13.0-cudnn9-devel',flavor='h200',timeout=5400,
+    command=['bash','-c',(ROOT/'bootstrap_build.sh').read_text()],
+    env={'AGNES_CODE_REVISION':commit.oid,'HF_HOME':'/workspace/agnes/hf-cache',
+         'PYTHONUNBUFFERED':'1','TOKENIZERS_PARALLELISM':'false','OMP_NUM_THREADS':'8',
+         'HF_HUB_DOWNLOAD_TIMEOUT':'180','TQDM_MININTERVAL':'30',
+         'PYTORCH_CUDA_ALLOC_CONF':'expandable_segments:True'},
+    secrets={'HF_TOKEN':get_token()},labels={'project':'agnes-flash-nvfp4','phase':'plain-build'})
+row=dict(job_id=job.id,url=job.url,phase='plain-build',flavor='h200',rate_usd_hour=rate,
+         timeout_hours=1.5,maximum_cost_usd=rate*1.5,code_revision=commit.oid)
+ledger.write_text(json.dumps(row)+'\n')
+print(json.dumps(row))

reproducibility/plan.json

@@ -0,0 +1,14 @@
+{
+  "source": "Agnes-AI/Agnes-3.0-Flash",
+  "source_revision": "24f712ce59379b54c4a141d2708c35daf5ff613b",
+  "target": "ProCreations/Agnes-3.0-Flash-NVFP4",
+  "method": "plain data-free NVFP4",
+  "training": false,
+  "calibration_examples": 0,
+  "quantized": "All decoder MLP and global attention linear weights; branches folded as in upstream SGLang",
+  "preserved": "Recurrent attention, vision, embeddings, output head, norms, MTP",
+  "agnes_compute_ceiling_usd": 40,
+  "prior_nex_compute_upper_bound_usd": 98.303050825,
+  "combined_user_cap_usd": 200,
+  "publication": "Public after native validation"
+}

reproducibility/runtime_image.json

@@ -0,0 +1,55 @@
+{
+  "image": "lmsysorg/sglang",
+  "tag": "nightly-dev-20260908-20ca564b",
+  "digest": "sha256:9a352a35c973a2357372e85f3bcb5388b6b3c46c1329165987260f3b089647dc",
+  "manifest": {
+    "schemaVersion": 2,
+    "mediaType": "application/vnd.oci.image.index.v1+json",
+    "manifests": [
+      {
+        "mediaType": "application/vnd.oci.image.manifest.v1+json",
+        "digest": "sha256:2d53500cb72184020c59fe16aab3512d53b1aa8ee6195bfb2aaf5855d58099df",
+        "size": 13687,
+        "platform": {
+          "architecture": "amd64",
+          "os": "linux"
+        }
+      },
+      {
+        "mediaType": "application/vnd.oci.image.manifest.v1+json",
+        "digest": "sha256:b6792a80cd34d743b2e3be7f088dfb701328a900f64e8008b16279b616f6db46",
+        "size": 838,
+        "annotations": {
+          "vnd.docker.reference.digest": "sha256:2d53500cb72184020c59fe16aab3512d53b1aa8ee6195bfb2aaf5855d58099df",
+          "vnd.docker.reference.type": "attestation-manifest"
+        },
+        "platform": {
+          "architecture": "unknown",
+          "os": "unknown"
+        }
+      },
+      {
+        "mediaType": "application/vnd.oci.image.manifest.v1+json",
+        "digest": "sha256:c5697af9d2b89629b8d392509de6085a2c16b492b76acc975660417d86f27491",
+        "size": 13673,
+        "platform": {
+          "architecture": "arm64",
+          "os": "linux"
+        }
+      },
+      {
+        "mediaType": "application/vnd.oci.image.manifest.v1+json",
+        "digest": "sha256:b1b088a5e7a06a4685d684ec7e109e159ddb722fd89dc476e4c0987c585dae7e",
+        "size": 838,
+        "annotations": {
+          "vnd.docker.reference.digest": "sha256:c5697af9d2b89629b8d392509de6085a2c16b492b76acc975660417d86f27491",
+          "vnd.docker.reference.type": "attestation-manifest"
+        },
+        "platform": {
+          "architecture": "unknown",
+          "os": "unknown"
+        }
+      }
+    ]
+  }
+}

reproducibility/source_meta.json

@@ -0,0 +1,279 @@
+{
+  "repo": "Agnes-AI/Agnes-3.0-Flash",
+  "revision": "24f712ce59379b54c4a141d2708c35daf5ff613b",
+  "private": false,
+  "gated": false,
+  "card": {
+    "language": [
+      "en",
+      "zh"
+    ],
+    "library_name": "transformers",
+    "license": "apache-2.0",
+    "pipeline_tag": "image-text-to-text",
+    "tags": [
+      "agnes-ai",
+      "reasoning",
+      "multimodal",
+      "long-context",
+      "hybrid-attention"
+    ]
+  },
+  "files": [
+    {
+      "name": ".gitattributes",
+      "size": 1519,
+      "sha256": null
+    },
+    {
+      "name": "LICENSE",
+      "size": 11357,
+      "sha256": null
+    },
+    {
+      "name": "README.md",
+      "size": 16314,
+      "sha256": null
+    },
+    {
+      "name": "README_zh.md",
+      "size": 14714,
+      "sha256": null
+    },
+    {
+      "name": "assets/agnes_benchmarks.svg",
+      "size": 12421,
+      "sha256": null
+    },
+    {
+      "name": "assets/agnes_logo.svg",
+      "size": 2435,
+      "sha256": null
+    },
+    {
+      "name": "chat_template.jinja",
+      "size": 8952,
+      "sha256": null
+    },
+    {
+      "name": "config.json",
+      "size": 4505,
+      "sha256": null
+    },
+    {
+      "name": "configuration_agnes.py",
+      "size": 7516,
+      "sha256": null
+    },
+    {
+      "name": "generation_config.json",
+      "size": 202,
+      "sha256": null
+    },
+    {
+      "name": "image_processing_agnes.py",
+      "size": 8700,
+      "sha256": null
+    },
+    {
+      "name": "merges.txt",
+      "size": 3353259,
+      "sha256": null
+    },
+    {
+      "name": "model-00001-of-00019.safetensors",
+      "size": 3966730528,
+      "sha256": "5697cc0f8b4223adab6e8fb6043727752c728e485a3621b693381073409e3070"
+    },
+    {
+      "name": "model-00002-of-00019.safetensors",
+      "size": 3043080320,
+      "sha256": "e3d8adc00d4f6568b257ccdbcfdedde894024eb2a10abd125426fe8440fc563a"
+    },
+    {
+      "name": "model-00003-of-00019.safetensors",
+      "size": 2542796952,
+      "sha256": "2e1bf62cbcd406eaa64b60d10353e1f0ef4039d0976e56f05cabe953454f9968"
+    },
+    {
+      "name": "model-00004-of-00019.safetensors",
+      "size": 3988973120,
+      "sha256": "2962bc38c2b69709d6df78cffe9692ab4e761d47ba2f2c0e61c808484a2df825"
+    },
+    {
+      "name": "model-00005-of-00019.safetensors",
+      "size": 2099339848,
+      "sha256": "ecb1d015bca88250dbc9e167479c5e740de21b5a70fc38cc84b6c3388db9d3a9"
+    },
+    {
+      "name": "model-00006-of-00019.safetensors",
+      "size": 3979553664,
+      "sha256": "ae9c2e979d10655fded3bbdbfddfb2f72b3d1ac5195c9e214756f694196fd523"
+    },
+    {
+      "name": "model-00007-of-00019.safetensors",
+      "size": 2108759344,
+      "sha256": "dfdb74b2182b870b602127a64e3b9995f138bfe707168b7339c759623996e2d7"
+    },
+    {
+      "name": "model-00008-of-00019.safetensors",
+      "size": 3979553664,
+      "sha256": "24db669382d366c90d6c9fd2ce3cfceee836c3ec8a8a3ae62313ce8f3cd55862"
+    },
+    {
+      "name": "model-00009-of-00019.safetensors",
+      "size": 2108759344,
+      "sha256": "fe9de765012eb1c7bd2dd30f5b2b7579b5eef4de67805023b2d86c2bea8d2511"
+    },
+    {
+      "name": "model-00010-of-00019.safetensors",
+      "size": 3979553664,
+      "sha256": "a1819ace7b218bdad22a194ed9f09e4d436ba8ff522bf1e09b070d6d2bb8781a"
+    },
+    {
+      "name": "model-00011-of-00019.safetensors",
+      "size": 2108759344,
+      "sha256": "4a7b4caaedf55e0b4d4bad1524b0f433b5e86ce4a7ab13950c3749dc10b56f5f"
+    },
+    {
+      "name": "model-00012-of-00019.safetensors",
+      "size": 3979553664,
+      "sha256": "1f937940e0dcd5dc28ab4117fc0437c53e10328b5b5ff52b126bba01da208d7d"
+    },
+    {
+      "name": "model-00013-of-00019.safetensors",
+      "size": 2108759344,
+      "sha256": "ee54d2d219596d6d8900aaac24a4afd59028b883d57d5eba77ceb8d207c56cb3"
+    },
+    {
+      "name": "model-00014-of-00019.safetensors",
+      "size": 3979553664,
+      "sha256": "064a0cfd148b1ca7188c83a40a5b30ac5b26e4f3a3982e50948945cfa6872cae"
+    },
+    {
+      "name": "model-00015-of-00019.safetensors",
+      "size": 2108759344,
+      "sha256": "d395947e2ef2274f151e1b83e8357befa9f40f0bca296d99d1aa69abb703cf51"
+    },
+    {
+      "name": "model-00016-of-00019.safetensors",
+      "size": 3979564008,
+      "sha256": "4eda4a1568a1a05fc762e7a3a2072c9d11cb860cdd763ac1720aef39f6a24751"
+    },
+    {
+      "name": "model-00017-of-00019.safetensors",
+      "size": 2108759344,
+      "sha256": "6cdc6d3b849808dfec6f0b7d11a09b74c0c91ba8df852891741e9eb63d33ab9f"
+    },
+    {
+      "name": "model-00018-of-00019.safetensors",
+      "size": 3392197360,
+      "sha256": "a408f74e0801216c76f34f404e487b7f72177fc34efab5d0f14edf7e7630345f"
+    },
+    {
+      "name": "model-00019-of-00019.safetensors",
+      "size": 6088313008,
+      "sha256": "48a75e0f87ae40e40ff7190e53576355ca4eea028a64882e302893287ab7b49f"
+    },
+    {
+      "name": "model-parallel-ffn.safetensors",
+      "size": 4529878968,
+      "sha256": "9ea1ead9b6ea1ebae0d791145e43c727cd5bd7cc8dee19d4c9d95c0eb1ff4f1c"
+    },
+    {
+      "name": "model.safetensors.index.json",
+      "size": 145141,
+      "sha256": null
+    },
+    {
+      "name": "modeling_agnes.py",
+      "size": 70576,
+      "sha256": null
+    },
+    {
+      "name": "preprocessor_config.json",
+      "size": 476,
+      "sha256": null
+    },
+    {
+      "name": "processing_agnes.py",
+      "size": 5849,
+      "sha256": null
+    },
+    {
+      "name": "serve.sh",
+      "size": 1448,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/README.md",
+      "size": 2645,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/agnes_sglang_config.py",
+      "size": 3174,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/apply_patch.py",
+      "size": 4832,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/nightly-dev-20260908-20ca564b/sglang/srt/configs/agnes.py",
+      "size": 3174,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/nightly-dev-20260908-20ca564b/sglang/srt/models/qwen3_5.py",
+      "size": 110213,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/nightly-dev-20260908-20ca564b/sglang/srt/utils/hf_transformers/common.py",
+      "size": 25576,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/v0.5.19/sglang/srt/configs/agnes.py",
+      "size": 3174,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/v0.5.19/sglang/srt/models/qwen3_5.py",
+      "size": 109665,
+      "sha256": null
+    },
+    {
+      "name": "sglang_patch/v0.5.19/sglang/srt/utils/hf_transformers/common.py",
+      "size": 23485,
+      "sha256": null
+    },
+    {
+      "name": "tokenizer.json",
+      "size": 9835269,
+      "sha256": null
+    },
+    {
+      "name": "tokenizer_config.json",
+      "size": 18884,
+      "sha256": null
+    },
+    {
+      "name": "video_preprocessor_config.json",
+      "size": 460,
+      "sha256": null
+    },
+    {
+      "name": "video_processing_agnes.py",
+      "size": 8832,
+      "sha256": null
+    },
+    {
+      "name": "vocab.json",
+      "size": 6722759,
+      "sha256": null
+    }
+  ]
+}