open-weights-explorer / index.html
ai-systems's picture
Upload 2 files
eb57048 verified
Raw History Blame Contribute Delete
36.6 kB
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta name="description" content="Open Weights Explorer: an interactive guide to open-weight AI models, model weights, licenses, quantization, fine-tuning, inference, deployment, evaluation, security and AI sovereignty." />
<meta name="keywords" content="open weights, open-weight models, model weights, open source AI, quantization, fine-tuning, LoRA, inference, GGUF, Safetensors, model licenses, AI sovereignty, self-hosted AI" />
<title>Open Weights Explorer</title>
<style>
:root{
--bg:#f7f9fc;
--panel:#ffffff;
--text:#101828;
--muted:#667085;
--line:#e4e7ec;
--blue:#2563eb;
--indigo:#4f46e5;
--soft:#eef4ff;
--shadow:0 18px 45px rgba(16,24,40,.08);
--radius:22px;
}
*{box-sizing:border-box}
html{scroll-behavior:smooth}
body{
margin:0;
font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
color:var(--text);
background:
radial-gradient(circle at 15% 5%, rgba(37,99,235,.08), transparent 28%),
radial-gradient(circle at 85% 10%, rgba(79,70,229,.08), transparent 24%),
var(--bg);
}
a{color:inherit}
.wrap{max-width:1220px;margin:0 auto;padding:0 24px}
.hero{padding:72px 0 38px}
.badge{
display:inline-flex;align-items:center;gap:8px;
padding:8px 12px;border:1px solid #c7d7fe;border-radius:999px;
background:#f5f8ff;color:#344054;font-size:13px;font-weight:700;
}
.dot{width:8px;height:8px;border-radius:50%;background:linear-gradient(135deg,var(--blue),var(--indigo))}
h1{font-size:clamp(42px,7vw,78px);line-height:.98;letter-spacing:-.055em;margin:22px 0 18px}
.gradient{
background:linear-gradient(90deg,var(--blue),var(--indigo));
-webkit-background-clip:text;background-clip:text;color:transparent;
}
.lead{font-size:20px;line-height:1.7;color:#475467;max-width:850px}
.hero-grid{display:grid;grid-template-columns:1.25fr .75fr;gap:28px;align-items:stretch;margin-top:34px}
.hero-card,.panel,.topic-card,.compare-card,.path-card,.gloss-card{
background:rgba(255,255,255,.93);border:1px solid var(--line);border-radius:var(--radius);box-shadow:var(--shadow)
}
.hero-card{padding:28px}
.hero-card h3{margin:0 0 10px;font-size:17px}
.hero-card p{margin:0;color:var(--muted);line-height:1.6}
.stack{
display:flex;flex-wrap:wrap;gap:9px;margin-top:18px
}
.pill{
border:1px solid #d0d5dd;background:#fff;border-radius:999px;padding:8px 11px;font-size:13px;color:#344054
}
.quick{
display:grid;grid-template-columns:repeat(2,1fr);gap:12px
}
.quick div{
padding:18px;border-radius:17px;background:linear-gradient(145deg,#f8fbff,#f5f3ff);border:1px solid #e0e7ff
}
.quick strong{font-size:22px;display:block;margin-bottom:4px}
.quick span{font-size:12px;color:var(--muted)}
nav.sticky{
position:sticky;top:0;z-index:20;background:rgba(247,249,252,.86);backdrop-filter:blur(16px);border-top:1px solid rgba(228,231,236,.7);border-bottom:1px solid rgba(228,231,236,.9)
}
.nav-inner{display:flex;gap:8px;overflow:auto;padding:11px 24px;max-width:1220px;margin:auto}
.nav-inner a{white-space:nowrap;text-decoration:none;font-size:13px;font-weight:700;padding:8px 11px;border-radius:999px}
.nav-inner a:hover{background:#fff}
section{padding:55px 0}
.section-title{display:flex;justify-content:space-between;gap:20px;align-items:end;margin-bottom:22px}
.section-title h2{font-size:34px;letter-spacing:-.035em;margin:0}
.section-title p{margin:0;color:var(--muted);max-width:630px;line-height:1.6}
.panel{padding:26px}
.definition{
display:grid;grid-template-columns:1fr 1fr;gap:22px
}
.quote{
padding:23px;border-radius:18px;background:linear-gradient(135deg,#eff6ff,#eef2ff);
border:1px solid #c7d7fe;font-size:18px;line-height:1.65;font-weight:700
}
.small{font-size:14px;line-height:1.7;color:var(--muted)}
.compare-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:18px}
.compare-card{padding:22px}
.compare-card h3{margin:0 0 9px}
.compare-card p{color:var(--muted);line-height:1.6;font-size:14px}
.compare-card ul{padding-left:19px;color:#344054;line-height:1.7;font-size:14px}
.controls{display:flex;gap:12px;flex-wrap:wrap;margin-bottom:20px}
input[type="search"]{
flex:1;min-width:260px;border:1px solid #d0d5dd;border-radius:14px;padding:14px 16px;background:#fff;font-size:15px;outline:none
}
input[type="search"]:focus{border-color:#84adff;box-shadow:0 0 0 4px #eff4ff}
.filters{display:flex;gap:8px;flex-wrap:wrap}
button{
border:1px solid #d0d5dd;background:#fff;color:#344054;border-radius:999px;padding:10px 13px;font-weight:700;font-size:13px;cursor:pointer
}
button.active,button:hover{border-color:#84adff;background:#eff4ff;color:#1849a9}
.topic-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:17px}
.topic-card{padding:21px;transition:.2s transform,.2s box-shadow;cursor:pointer}
.topic-card:hover{transform:translateY(-3px);box-shadow:0 20px 50px rgba(16,24,40,.12)}
.topic-card .kicker{text-transform:uppercase;font-size:11px;letter-spacing:.12em;color:var(--blue);font-weight:800}
.topic-card h3{font-size:18px;margin:8px 0 7px}
.topic-card p{font-size:14px;line-height:1.6;color:var(--muted);margin:0}
.topic-card .tags{display:flex;flex-wrap:wrap;gap:7px;margin-top:15px}
.tag{font-size:11px;border-radius:999px;padding:5px 8px;background:#f2f4f7;color:#475467}
.path{
display:grid;grid-template-columns:repeat(6,1fr);gap:12px
}
.path-card{padding:17px;min-height:150px}
.path-card .n{font-size:11px;font-weight:800;color:var(--blue)}
.path-card h3{font-size:16px;margin:10px 0 6px}
.path-card p{font-size:12px;line-height:1.55;color:var(--muted);margin:0}
.matrix{overflow:auto}
table{width:100%;border-collapse:collapse;background:#fff;border-radius:18px;overflow:hidden}
th,td{padding:14px 15px;border-bottom:1px solid #eaecf0;text-align:left;font-size:13px;vertical-align:top}
th{background:#f9fafb;color:#344054}
td{color:#475467}
.check{font-weight:800;color:#067647}
.warn{font-weight:800;color:#b54708}
.glossary{display:grid;grid-template-columns:repeat(3,1fr);gap:14px}
.gloss-card{padding:18px}
.gloss-card strong{display:block;margin-bottom:6px}
.gloss-card span{font-size:13px;line-height:1.55;color:var(--muted)}
.footer{padding:42px 0 70px;color:#667085;font-size:13px}
.footer-grid{display:flex;justify-content:space-between;gap:18px;flex-wrap:wrap;border-top:1px solid var(--line);padding-top:24px}
.modal{
position:fixed;inset:0;background:rgba(16,24,40,.48);display:none;align-items:center;justify-content:center;padding:24px;z-index:99
}
.modal.open{display:flex}
.modal-box{background:#fff;border-radius:24px;max-width:760px;width:100%;max-height:86vh;overflow:auto;padding:28px;box-shadow:0 30px 80px rgba(16,24,40,.28)}
.modal-head{display:flex;justify-content:space-between;gap:20px}
.modal-head h3{margin:0;font-size:26px}
.close{border-radius:12px;padding:8px 11px}
.modal-body{color:#475467;line-height:1.7}
.modal-body h4{color:#101828;margin:20px 0 6px}
.modal-body ul{padding-left:20px}
.note{padding:16px 18px;border-left:4px solid var(--blue);background:#f8faff;border-radius:12px;color:#344054;margin-top:16px}
.empty{display:none;padding:35px;text-align:center;color:var(--muted)}
@media(max-width:980px){
.hero-grid,.definition{grid-template-columns:1fr}
.topic-grid,.compare-grid,.glossary{grid-template-columns:repeat(2,1fr)}
.path{grid-template-columns:repeat(3,1fr)}
}
@media(max-width:640px){
.wrap{padding:0 16px}
.hero{padding-top:46px}
.topic-grid,.compare-grid,.glossary,.quick,.path{grid-template-columns:1fr}
.section-title{display:block}
.section-title p{margin-top:10px}
h1{font-size:48px}
}
</style>
</head>
<body>
<header class="hero">
<div class="wrap">
<span class="badge"><span class="dot"></span> Open Weights · Technical Explorer</span>
<h1>Understand the <span class="gradient">open-weight AI stack.</span></h1>
<p class="lead">
A practical, vendor-neutral guide to model weights, licenses, formats, quantization, customization,
inference, deployment, evaluation, security, observability and AI sovereignty.
</p>
<div class="hero-grid">
<div class="hero-card">
<h3>What is an open-weight model?</h3>
<p>An AI model whose trained parameters are made available so users can obtain and run the model independently, subject to the release terms and license.</p>
<div class="stack">
<span class="pill">Model weights</span><span class="pill">Checkpoints</span><span class="pill">Safetensors</span>
<span class="pill">GGUF</span><span class="pill">Quantization</span><span class="pill">LoRA / PEFT</span>
<span class="pill">Self-hosting</span><span class="pill">Inference</span>
</div>
</div>
<div class="hero-card">
<div class="quick">
<div><strong>40</strong><span>technical concepts</span></div>
<div><strong>10</strong><span>exploration categories</span></div>
<div><strong>3</strong><span>openness models compared</span></div>
<div><strong>1</strong><span>production lifecycle</span></div>
</div>
</div>
</div>
</div>
</header>
<nav class="sticky">
<div class="nav-inner">
<a href="#definition">Definition</a>
<a href="#compare">Compare</a>
<a href="#explorer">Explorer</a>
<a href="#lifecycle">Lifecycle</a>
<a href="#decision">Decision Matrix</a>
<a href="#glossary">Glossary</a>
</div>
</nav>
<main>
<section id="definition">
<div class="wrap">
<div class="section-title">
<h2>Open weights, precisely defined</h2>
<p>Weight availability is one property of an AI release. It should not be confused with a claim that the complete AI system is open source.</p>
</div>
<div class="definition">
<div class="panel">
<div class="quote">Open weights means the trained numerical parameters of a model are available for users to obtain and run, subject to the model's license and release terms.</div>
</div>
<div class="panel small">
<strong>Why the distinction matters</strong><br><br>
A release can expose weights while withholding training data, training code or other components.
It may also impose model-specific restrictions. Always inspect the actual license, model card,
source repository, usage policy and available artifacts.
</div>
</div>
</div>
</section>
<section id="compare">
<div class="wrap">
<div class="section-title">
<h2>Open weights vs. open source vs. API</h2>
<p>Three concepts that are often mixed together but answer different questions.</p>
</div>
<div class="compare-grid">
<article class="compare-card">
<h3>Open-weight model</h3>
<p>The trained parameters can be obtained and independently executed.</p>
<ul>
<li>Downloadable model artifact</li>
<li>Self-hosting can be possible</li>
<li>Fine-tuning may be possible</li>
<li>Rights depend on license</li>
</ul>
</article>
<article class="compare-card">
<h3>Open-source AI</h3>
<p>A broader openness claim involving freedoms, licensing and sufficient material to study and modify the system.</p>
<ul>
<li>More than weight availability</li>
<li>Requires license analysis</li>
<li>Code/data information can matter</li>
<li>Not every open-weight model qualifies</li>
</ul>
</article>
<article class="compare-card">
<h3>Hosted API model</h3>
<p>The provider runs the model and exposes an interface instead of distributing the underlying checkpoint.</p>
<ul>
<li>No local weight artifact required</li>
<li>Provider manages infrastructure</li>
<li>Usage-based economics common</li>
<li>Less runtime control</li>
</ul>
</article>
</div>
</div>
</section>
<section id="explorer">
<div class="wrap">
<div class="section-title">
<h2>Explore the open-weight ecosystem</h2>
<p>Search by concept or filter by technical layer. Select a card for a deeper explanation and practical implications.</p>
</div>
<div class="controls">
<input id="search" type="search" placeholder="Search: quantization, licenses, GGUF, LoRA, inference..." aria-label="Search concepts" />
<div class="filters" id="filters"></div>
</div>
<div class="topic-grid" id="grid"></div>
<div class="empty" id="empty">No matching topic. Try another search term or category.</div>
</div>
</section>
<section id="lifecycle">
<div class="wrap">
<div class="section-title">
<h2>From weights to production</h2>
<p>Open weights are only the first layer. Production AI requires a chain of engineering disciplines around the model artifact.</p>
</div>
<div class="path">
<div class="path-card"><span class="n">01</span><h3>Open Weights</h3><p>Obtain, inspect and version the model artifact.</p></div>
<div class="path-card"><span class="n">02</span><h3>Customization</h3><p>Adapt behavior through prompts, RAG, adapters or fine-tuning.</p></div>
<div class="path-card"><span class="n">03</span><h3>Validation</h3><p>Test quality, safety, reliability and task fit.</p></div>
<div class="path-card"><span class="n">04</span><h3>Inference</h3><p>Serve the model efficiently on target hardware.</p></div>
<div class="path-card"><span class="n">05</span><h3>Observability</h3><p>Measure latency, utilization, errors, quality and drift.</p></div>
<div class="path-card"><span class="n">06</span><h3>Readiness</h3><p>Determine whether the complete system is ready for real-world use.</p></div>
</div>
</div>
</section>
<section id="decision">
<div class="wrap">
<div class="section-title">
<h2>Deployment decision matrix</h2>
<p>A compact way to think about when open-weight deployment may be attractive and where extra responsibility appears.</p>
</div>
<div class="panel matrix">
<table>
<thead><tr><th>Requirement</th><th>Open-weight deployment</th><th>What to verify</th></tr></thead>
<tbody>
<tr><td>Private infrastructure</td><td class="check">Strong fit</td><td>Network, logging, storage, telemetry and external dependencies</td></tr>
<tr><td>Model customization</td><td class="check">Strong fit</td><td>License, architecture support, training stack, evaluation</td></tr>
<tr><td>Offline / air-gapped use</td><td class="check">Possible</td><td>Artifact transfer, package mirrors, patching, update process</td></tr>
<tr><td>Minimal operations team</td><td class="warn">Higher burden</td><td>Managed inference may be preferable</td></tr>
<tr><td>Strict latency control</td><td class="check">Potential advantage</td><td>Benchmark exact model/runtime/hardware combination</td></tr>
<tr><td>Predictable versioning</td><td class="check">Strong fit</td><td>Pin repository revision, tokenizer, runtime and quantization</td></tr>
<tr><td>Zero maintenance</td><td class="warn">Poor fit</td><td>Self-hosting transfers operational responsibility to the user</td></tr>
</tbody>
</table>
</div>
</div>
</section>
<section id="glossary">
<div class="wrap">
<div class="section-title">
<h2>Essential glossary</h2>
<p>Core terminology for understanding open-weight AI systems.</p>
</div>
<div class="glossary" id="gloss"></div>
</div>
</section>
</main>
<footer class="footer">
<div class="wrap footer-grid">
<div><strong>Open Weights Explorer</strong><br>Vendor-neutral technical reference for open-weight AI.</div>
<div>Organization: <strong>Open Weights</strong><br>Contact: agenten@magenta.de</div>
</div>
</footer>
<div class="modal" id="modal" role="dialog" aria-modal="true" aria-labelledby="modalTitle">
<div class="modal-box">
<div class="modal-head">
<h3 id="modalTitle"></h3>
<button class="close" id="close">Close</button>
</div>
<div class="modal-body" id="modalBody"></div>
</div>
</div>
<script>
const topics = [
{cat:"Foundations",title:"Model weights",desc:"The learned numerical parameters that encode a neural network's trained state.",tags:["parameters","tensors","checkpoint"],detail:"Weights are numerical tensors adjusted during training. They are distinct from architecture code: the architecture defines the network structure, while the weights contain the learned state.",why:"Weight access is what makes independent execution, conversion, quantization and many forms of fine-tuning possible."},
{cat:"Foundations",title:"Checkpoints",desc:"Versioned snapshots of model state used for inference, training continuation or adaptation.",tags:["versioning","artifacts"],detail:"A checkpoint can contain weights plus configuration and, in training contexts, optimizer or scheduler state. Public releases often provide inference-oriented checkpoints.",why:"Production systems should pin exact revisions rather than rely on a mutable latest version."},
{cat:"Foundations",title:"Tokenizers",desc:"Components that map raw text to the token IDs processed by a model.",tags:["tokens","chat template"],detail:"Tokenizer vocabulary, special tokens, normalization and chat templates can materially change model behavior.",why:"A correct checkpoint with the wrong tokenizer can still produce poor or broken results."},
{cat:"Foundations",title:"Context window",desc:"The supported sequence length available for prompts, retrieved context and generated tokens.",tags:["context","KV cache"],detail:"Long context affects memory and latency, especially through the KV cache. Nominal context length and efficient long-context operation are not the same thing.",why:"Context length must be tested under realistic workloads rather than treated as a marketing number."},
{cat:"Formats",title:"Safetensors",desc:"A tensor storage format widely used for model distribution on Hugging Face.",tags:["format","security"],detail:"Safetensors stores tensor data without arbitrary Python object execution. It supports efficient loading and memory mapping.",why:"It reduces risks associated with unsafe pickle-style tensor serialization, although surrounding code still requires review."},
{cat:"Formats",title:"GGUF",desc:"A model format used heavily in the llama.cpp ecosystem for local and quantized inference.",tags:["llama.cpp","local AI"],detail:"GGUF can package tensors, tokenizer metadata and quantization metadata into a deployment-oriented artifact.",why:"It makes many open-weight models practical on consumer hardware and CPU/GPU hybrid environments."},
{cat:"Formats",title:"Framework checkpoints",desc:"Model files distributed in framework-specific structures for training or inference.",tags:["PyTorch","JAX"],detail:"Framework-native releases may be closest to the authoritative upstream checkpoint but can require conversion for specific runtimes.",why:"Always distinguish original publisher artifacts from third-party conversions and derivatives."},
{cat:"Formats",title:"Model metadata",desc:"Structured information describing architecture, task, license, language, base model and lineage.",tags:["model card","provenance"],detail:"Metadata is essential for discovery and reproducibility. A production registry should capture model ID, exact revision, license, architecture, base model and transformation history.",why:"Without metadata, a model file is difficult to govern safely."},
{cat:"Quantization",title:"Quantization",desc:"Reducing numerical precision to lower memory use and often improve inference efficiency.",tags:["INT8","INT4","FP8"],detail:"Quantization can be weight-only or include activations. It may be applied after training or considered during training.",why:"A model that does not fit target hardware at full precision may become deployable after quantization."},
{cat:"Quantization",title:"4-bit deployment",desc:"A common strategy for running large models with substantially reduced weight memory.",tags:["INT4","VRAM"],detail:"Approximate raw weight storage can approach 0.5 byte per parameter before metadata and runtime overhead, but real memory also includes KV cache and buffers.",why:"4-bit formats can open local deployment to smaller GPUs, but quality must be re-evaluated."},
{cat:"Quantization",title:"KV cache",desc:"Cached attention keys and values used to accelerate autoregressive generation.",tags:["memory","context"],detail:"KV-cache requirements scale with sequence length, batch size and architecture. It can become the limiting memory factor for long context or high concurrency.",why:"Planning only for weight memory underestimates real serving requirements."},
{cat:"Quantization",title:"Memory planning",desc:"Estimating weights, cache, activations, runtime buffers and concurrency before deployment.",tags:["GPU","capacity"],detail:"A model that technically loads into VRAM may not have enough memory left for useful context lengths or concurrency.",why:"Capacity planning should use real prompts, output lengths and traffic patterns."},
{cat:"Customization",title:"Fine-tuning",desc:"Additional training that changes model parameters for a target domain or behavior.",tags:["training","adaptation"],detail:"Full fine-tuning updates most or all parameters and offers maximum flexibility at high compute and memory cost.",why:"Open weights make deeper adaptation possible when the license and tooling permit it."},
{cat:"Customization",title:"LoRA",desc:"Low-Rank Adaptation trains compact matrices while keeping most base weights frozen.",tags:["PEFT","adapters"],detail:"LoRA can produce small adapter artifacts that are easier to store and switch than full model copies.",why:"It enables efficient specialization of open-weight models."},
{cat:"Customization",title:"QLoRA",desc:"Combines a quantized base model with LoRA-style adaptation.",tags:["4-bit","PEFT"],detail:"QLoRA is designed to lower fine-tuning memory requirements while preserving the ability to adapt large models.",why:"It makes model customization accessible on more modest hardware."},
{cat:"Customization",title:"RAG vs fine-tuning",desc:"Retrieval and training solve different customization problems.",tags:["RAG","knowledge"],detail:"RAG is often better for changing or private knowledge; fine-tuning is often better for behavior, style, task patterns and structured output.",why:"Production systems frequently combine both rather than treating them as alternatives."},
{cat:"Inference",title:"Inference serving",desc:"Running a trained model on new inputs through a production runtime.",tags:["serving","API"],detail:"Serving includes loading weights, scheduling requests, tokenization, forward passes, decoding, batching and streaming.",why:"Model quality alone does not determine production viability; the serving stack matters."},
{cat:"Inference",title:"Continuous batching",desc:"Dynamic batching that allows requests to enter and leave the active batch during generation.",tags:["throughput","scheduler"],detail:"Modern LLM serving engines use continuous batching to improve accelerator utilization under concurrent traffic.",why:"It can substantially increase throughput compared with naive request-by-request execution."},
{cat:"Inference",title:"TTFT",desc:"Time to First Token: latency before the first generated token reaches the user.",tags:["latency","UX"],detail:"TTFT is influenced by queueing, prompt length, prefill compute, network latency and scheduler behavior.",why:"Interactive AI products often need to optimize TTFT separately from total throughput."},
{cat:"Inference",title:"Parallelism",desc:"Techniques for distributing large models or workloads across multiple accelerators.",tags:["tensor","pipeline","expert"],detail:"Tensor, pipeline, data and expert parallelism divide different parts of serving across devices.",why:"Large or MoE models may require multi-device strategies even when active compute appears modest."},
{cat:"Deployment",title:"Self-hosting",desc:"Operating model inference on infrastructure controlled by the user or organization.",tags:["on-prem","private cloud"],detail:"Self-hosting can increase control over versions, data location and runtime selection while shifting operations to the user.",why:"It is a central practical benefit of many open-weight releases."},
{cat:"Deployment",title:"Local AI",desc:"Running models on workstations, laptops or local devices.",tags:["offline","desktop"],detail:"Local AI relies heavily on smaller models, quantization and optimized runtimes.",why:"It can improve privacy, resilience and latency for appropriate workloads."},
{cat:"Deployment",title:"Edge AI",desc:"Deploying models close to sensors, devices, robots or industrial systems.",tags:["robotics","devices"],detail:"Edge deployment may require aggressive optimization, compilation, pruning, quantization or distillation.",why:"Open weights allow developers to adapt artifacts for specialized hardware."},
{cat:"Deployment",title:"Cloud inference",desc:"Serving open-weight models using cloud GPUs or managed model infrastructure.",tags:["autoscaling","GPU"],detail:"Open weights do not imply on-premises deployment. They can be hosted by the user, a cloud provider or a managed inference provider.",why:"The defining property is access to the model artifact, not the physical location of compute."},
{cat:"Licensing",title:"Model license",desc:"The legal terms that determine how a model artifact can be used, modified and redistributed.",tags:["commercial use","rights"],detail:"Always inspect the full license and any additional acceptable-use policy. Weight availability does not equal unrestricted permission.",why:"Licensing can be more important to enterprise adoption than benchmark performance."},
{cat:"Licensing",title:"Apache 2.0",desc:"A widely used permissive open-source software license seen in some AI releases.",tags:["permissive","commercial"],detail:"Apache 2.0 generally permits use, modification and redistribution under its terms, but separate components or policies can still apply.",why:"A repository can contain artifacts under different legal conditions."},
{cat:"Licensing",title:"Community licenses",desc:"Custom model licenses that can include conditions beyond standard software licenses.",tags:["model-specific","restrictions"],detail:"Community licenses may specify commercial thresholds, redistribution requirements, acceptable-use rules or other conditions.",why:"The phrase open-weight remains useful because it does not overstate broader openness."},
{cat:"Licensing",title:"Derivative lineage",desc:"Tracking the base model and transformations behind fine-tuned, merged or quantized variants.",tags:["provenance","derivatives"],detail:"A derivative should document base checkpoint, transformation method, license, creator and evaluation.",why:"Lineage is essential for compliance, reproducibility and supply-chain security."},
{cat:"Security",title:"Supply-chain security",desc:"Protecting the path from model publisher to production artifact.",tags:["hashes","provenance"],detail:"Review repository ownership, revisions, checksums, executable code, dependencies, community conversions and containers.",why:"Model artifacts should be treated as critical software dependencies."},
{cat:"Security",title:"Remote code",desc:"Custom repository code that may execute when loading a model.",tags:["trust","sandbox"],detail:"If a model requires remote code, pin a revision, review the code, scan dependencies and isolate execution before production use.",why:"Open weights do not remove code-execution risk."},
{cat:"Security",title:"Agent permissions",desc:"Operational authority granted to a model-driven agent.",tags:["tools","least privilege"],detail:"Tool calls should be validated, authorized and constrained. Model-generated arguments are untrusted input.",why:"Agent risk is often determined more by tool permissions than model size."},
{cat:"Security",title:"Privacy controls",desc:"Protecting prompts, retrieved context, outputs and traces in self-hosted environments.",tags:["logging","retention"],detail:"Private infrastructure can still leak sensitive data through telemetry, logs, vector stores, backups or external APIs.",why:"Self-hosted does not automatically mean private by design."},
{cat:"Evaluation",title:"Task evaluation",desc:"Measuring whether a model actually performs well on target application workloads.",tags:["quality","benchmarks"],detail:"Use application-specific test sets in addition to public benchmarks. Record model revision, runtime, prompts and decoding settings.",why:"Leaderboard performance does not guarantee production quality."},
{cat:"Evaluation",title:"Regression testing",desc:"Detecting quality changes after model, runtime, prompt or data updates.",tags:["versioning","CI"],detail:"A repeatable evaluation suite can turn model updates into controlled software releases.",why:"Open-weight version control makes exact rollback and comparison easier."},
{cat:"Evaluation",title:"Safety evaluation",desc:"Testing failures such as prompt injection, data leakage or unsafe tool use.",tags:["red teaming","risk"],detail:"Safety testing should reflect the capabilities and permissions of the complete system, not just the base model.",why:"The same model can have very different risk depending on how it is integrated."},
{cat:"Evaluation",title:"Performance benchmarking",desc:"Measuring latency, throughput, memory and stability on target hardware.",tags:["TTFT","tokens/s"],detail:"Benchmark exact model, quantization, runtime, prompt lengths, output lengths and concurrency.",why:"Generic benchmark numbers are rarely enough for capacity planning."},
{cat:"Observability",title:"AI observability",desc:"Telemetry that makes model and system behavior visible in production.",tags:["metrics","traces"],detail:"Useful signals include TTFT, token throughput, GPU utilization, errors, queue depth, tool failures and quality indicators.",why:"Production AI needs both infrastructure and behavior-level monitoring."},
{cat:"Observability",title:"Drift",desc:"Changes in input distributions, documents, tools or user behavior that can reduce system quality.",tags:["quality","monitoring"],detail:"A fixed checkpoint can still become less effective as the environment around it changes.",why:"Validation must continue after deployment."},
{cat:"Observability",title:"Cost observability",desc:"Tracking resource consumption and cost per request or workload.",tags:["GPU","TCO"],detail:"Open-weight economics include accelerator time, engineering, storage, networking and operational overhead.",why:"The right comparison is total cost of ownership, not free model versus paid API."},
{cat:"Observability",title:"Privacy-aware telemetry",desc:"Designing logs and traces that avoid unnecessary storage of sensitive content.",tags:["redaction","retention"],detail:"Teams should choose whether to log full prompts, metadata, hashes or redacted summaries and define access and retention policies.",why:"Observability can become a data-governance risk if left uncontrolled."},
{cat:"Sovereignty",title:"AI sovereignty",desc:"Control over important dependencies in the AI system stack.",tags:["control","data residency"],detail:"Sovereignty can involve weights, compute, data, networking, identity, runtime and governance.",why:"Open weights contribute to sovereignty but are not sufficient by themselves."},
{cat:"Sovereignty",title:"Vendor lock-in",desc:"Dependency on a provider, runtime, cloud, GPU stack or proprietary platform.",tags:["portability","standards"],detail:"Open weights can reduce model-provider lock-in while introducing dependencies at other infrastructure layers.",why:"Portability requires deliberate architecture rather than one open artifact."},
{cat:"Sovereignty",title:"Air-gapped AI",desc:"Inference in environments without external network connectivity.",tags:["offline","secure environments"],detail:"Air-gapped deployment requires offline artifact transfer, package mirrors, scanning, patching and controlled updates.",why:"Open weights can enable disconnected operation where hosted APIs cannot."},
{cat:"Sovereignty",title:"Reproducible deployment",desc:"Pinning every important artifact needed to recreate a known system state.",tags:["revision","hash"],detail:"Track checkpoint, tokenizer, adapters, quantization, runtime, prompts and infrastructure configuration.",why:"Reproducibility is a foundation for governance and incident response."}
];
const glossary = [
["Open weights","Trained model parameters made available for users to obtain and run."],
["Open-weight model","A model distributed with accessible trained parameters under stated release terms."],
["Checkpoint","A saved model state containing weights and configuration."],
["Tensor","A multidimensional numerical array used to represent model parameters and activations."],
["Quantization","Reducing numerical precision to lower memory use and often improve deployment efficiency."],
["LoRA","Low-Rank Adaptation, a parameter-efficient fine-tuning technique."],
["PEFT","Parameter-Efficient Fine-Tuning, a family of methods that adapts only a small part of a model."],
["GGUF","A binary model format widely used for local inference in the llama.cpp ecosystem."],
["Safetensors","A tensor storage format designed for efficient and safer loading."],
["Inference","Running a trained model on new input to generate output."],
["KV cache","Cached attention state used to accelerate autoregressive generation."],
["TTFT","Time to First Token, a key interactive latency metric."],
["MoE","Mixture of Experts, an architecture that activates a subset of expert networks per token."],
["RAG","Retrieval-Augmented Generation, combining retrieval with generation."],
["Model card","Documentation describing model purpose, limitations, training, evaluation and licensing."],
["AI sovereignty","Control over critical AI dependencies such as model artifacts, infrastructure and data."]
];
const cats=["All",...new Set(topics.map(t=>t.cat))];
const filters=document.getElementById("filters");
const grid=document.getElementById("grid");
const search=document.getElementById("search");
const empty=document.getElementById("empty");
let active="All";
cats.forEach(c=>{
const b=document.createElement("button");
b.textContent=c;
if(c==="All") b.classList.add("active");
b.onclick=()=>{
active=c;
[...filters.children].forEach(x=>x.classList.remove("active"));
b.classList.add("active");
render();
};
filters.appendChild(b);
});
function render(){
const q=search.value.trim().toLowerCase();
const rows=topics.filter(t=>{
const catOk=active==="All"||t.cat===active;
const text=(t.cat+" "+t.title+" "+t.desc+" "+t.tags.join(" ")+" "+t.detail+" "+t.why).toLowerCase();
return catOk && (!q || text.includes(q));
});
grid.innerHTML="";
rows.forEach(t=>{
const card=document.createElement("article");
card.className="topic-card";
card.innerHTML=`<div class="kicker">${t.cat}</div><h3>${t.title}</h3><p>${t.desc}</p><div class="tags">${t.tags.map(x=>`<span class="tag">${x}</span>`).join("")}</div>`;
card.onclick=()=>openModal(t);
grid.appendChild(card);
});
empty.style.display=rows.length?"none":"block";
}
search.addEventListener("input",render);
function openModal(t){
document.getElementById("modalTitle").textContent=t.title;
document.getElementById("modalBody").innerHTML=`
<div class="kicker">${t.cat}</div>
<p><strong>${t.desc}</strong></p>
<h4>Technical explanation</h4><p>${t.detail}</p>
<h4>Why it matters</h4><p>${t.why}</p>
<div class="note">Open-weight availability and legal permissions are separate questions. Always inspect the authoritative license and release documentation for a specific model.</div>`;
document.getElementById("modal").classList.add("open");
}
function closeModal(){document.getElementById("modal").classList.remove("open")}
document.getElementById("close").onclick=closeModal;
document.getElementById("modal").onclick=e=>{if(e.target.id==="modal") closeModal()};
document.addEventListener("keydown",e=>{if(e.key==="Escape") closeModal()});
const gloss=document.getElementById("gloss");
glossary.forEach(([a,b])=>{
const el=document.createElement("div");
el.className="gloss-card";
el.innerHTML=`<strong>${a}</strong><span>${b}</span>`;
gloss.appendChild(el);
});
render();
</script>
</body>
</html>