Glossary

These short definitions explain terms that appear on catalog pages. Each entry says what the term means in general, how this catalog uses it, and where to see it on a real record. Where a definition depends on an outside standard or document, the entry links to it. The rules behind the catalog are on the methodology page, and What open weight and open source actually mean explains licensing in more depth. Nothing here is legal advice.

Accelerator (AI chip)

A processor built to speed up particular kinds of computation, working alongside a computer's general-purpose CPU. For AI, accelerators carry out the large matrix calculations used in training and inference; GPUs are one kind, and some companies design chips specifically for neural-network workloads.

In this catalog: accelerators appear as hardware products on the records of the companies that make them, and software records note the hardware their documentation supports under the Supported platforms checklist item (methodology).

Example: Intel lists the Intel Gaudi 3 AI accelerator, which it offers as a PCIe card, an OAM mezzanine card, and a baseboard, with PyTorch support through Intel Gaudi software.

Acceptable-use policy

A document from a model's publisher that lists uses it prohibits. A license can incorporate such a policy by reference, which makes following the policy one of the license's conditions.

In this catalog: use policies are summarized in the license notes of the release they belong to, next to the license that brings them in (methodology).

Example: EmbeddingGemma 300M is under the Gemma Terms of Use, which incorporate the Gemma Prohibited Use Policy and require anyone who redistributes the model to pass those use restrictions on.

Agent

Software in which a language model works toward a goal by choosing its own next steps, such as which tools to call, and reacting to the results until the task is done or a stopping condition is reached. Anthropic's guide Building effective agents (external site: anthropic.com) separates agents, where the model directs its own process and tool use, from workflows, where model calls and tools follow paths fixed in code.

In this catalog: agent frameworks, protocols, and agent applications are project records, gathered in the agents hub. The models an agent calls are separate records with their own licenses.

Example: goose is a general-purpose agent that runs on the user's machine as a desktop app, a command-line tool, or an API. It works with hosted and local model providers and connects to extensions through the Model Context Protocol.

Attention

A neural-network operation that builds a new representation of each position in a sequence, such as each token of a prompt, as a weighted mix of information from other positions. In Attention Is All You Need (external site: arxiv.org) (Vaswani et al., 2017), an attention function maps a query and a set of key-value pairs to a weighted sum of the values, where each weight depends on how well the query matches the corresponding key; self-attention applies this between positions of the same sequence.

In this catalog: attention designs are mentioned only as a model card or technical report describes them, usually in a release's summary.

Example: Rnj-1.5 Instruct switches most of Rnj-1's attention layers to block-local attention, which has a fixed compute and storage cost per position, and keeps a group of global attention layers in the middle. Its model card says the change eases costs that grow with sequence length.

Base model

A model as it comes out of pretraining: it has learned to continue text but has not yet been trained further to follow instructions or hold a conversation. Hugging Face's guide to chat templates (external site: huggingface.co) describes training that usually begins with pretraining on a huge corpus of text, which creates a base model that is then often fine-tuned for chat.

In this catalog: a base model and the versions trained from it are separate release records, and when a release was built on another model, its "Provenance and derivatives" section names that model (methodology).

Example: StarCoder2-15B is a base model for code. Its model card warns that it is not an instruction model, so commands such as "Write a function that computes the square root." do not work well.

Benchmark

A fixed set of tasks with a scoring method, used to compare models under the same conditions. A score that a publisher reports for its own model is a reported result: it has not necessarily been reproduced by anyone else, and it depends on the prompts and settings used.

In this catalog: benchmarks have their own project records. The catalog does not publish benchmark scores, and a model release whose card reports results without code or prompts to re-run them is marked Partial for evaluation materials (methodology).

Example: HumanEval is a set of 164 hand-written Python programming problems, each scored by running unit tests against the generated code.

Checkpoint

A saved copy of a model's state at some point in training. A training checkpoint holds the weights and usually what is needed to resume training, such as the optimizer state, as PyTorch's tutorial on saving and loading models (external site: docs.pytorch.org) describes. Publishers also use the word for any downloadable set of weights, including a quantized version prepared for deployment.

In this catalog: when a publisher releases intermediate checkpoints, the note on the release's Weights checklist item says so (methodology).

Example: For SmolLM3 3B, Hugging Face publishes intermediate checkpoints in a separate repository, one branch per checkpoint, saved every 40,000 steps during pretraining and at later stages such as long-context extension and supervised fine-tuning.

Content credentials (C2PA)

A signed, tamper-evident record of where a digital file came from and how it was made or edited, including whether AI was used, usually embedded in the file itself. It is defined in the C2PA specification (external site: spec.c2pa.org) from the Coalition for Content Provenance and Authenticity, whose explainer (external site: spec.c2pa.org) notes that a Content Credential shows whether its provenance information is well-formed, untampered, and signed by a trusted party, not whether that information is true.

In this catalog: no record is built around the specification itself; content credentials come up in explainers about labeling AI-generated content.

Example: The explainer on AI content provenance covers what content credentials record, how to inspect a file for them, invisible watermarks, and what AI detectors can and cannot do.

Context window

The maximum number of tokens (small pieces of text or other input) that a model can take into account in one request, usually counting both the prompt and the generated output.

In this catalog: context lengths appear only as the publisher documents them, with a citation.

Example: The model card for Gemma 4 31B lists a 256K-token context window.

Data center

A building or campus that houses servers, storage, and networking equipment, together with the electrical and cooling systems that keep them running. Data centers built for AI hold large clusters of accelerators connected by high-speed networks.

In this catalog: companies that build or operate data centers are organization records with roles such as Compute infrastructure or Cloud provider. Their records describe what the companies offer but give no power-capacity figures (methodology).

Example: Crusoe designs, builds, and operates data centers for AI workloads, with cooling methods that include direct liquid-to-chip cooling, and runs Crusoe Cloud, a GPU cloud platform.

Diffusion model

A generative model trained to reverse a process that gradually adds random noise to data, so that it can start from pure noise and remove it step by step to produce a new sample, such as an image. Denoising Diffusion Probabilistic Models (external site: arxiv.org) (Ho et al., 2020) describes this training and sampling procedure for images.

In this catalog: a release's summary says it uses diffusion when its documentation does, for outputs ranging from video to robot actions, and libraries for running and training diffusion models are project records.

Example: Diffusers is Hugging Face's library of pretrained diffusion models for generating images, audio, and other outputs. It combines models with interchangeable noise schedulers, which its README describes as offering different diffusion speeds and output quality.

Distillation

Training a smaller model to reproduce the outputs of a larger model, or of a group of models, so that their knowledge is carried by a model that is easier to deploy. In Distilling the Knowledge in a Neural Network (external site: arxiv.org) (Hinton et al., 2015), the small model learns from the large model's class probabilities, which the paper calls soft targets.

In this catalog: when a model card says a release was distilled from another model, the release's provenance or training-recipe note records it.

Example: The model card for Muse Glimmer 30B, from Meta Superintelligence Labs, says it was distilled from Muse Spark and built for agentic tasks on consumer hardware.

Embedding

A list of numbers (a vector) that a model produces to represent a piece of text, an image, or other data, arranged so that items with similar meaning get similar vectors. Anthropic's embeddings guide (external site: platform.claude.com) describes text embeddings as numerical representations of text that enable measuring semantic similarity, for uses such as search and recommendations.

In this catalog: embedding models are model releases with their own licenses and checklists, and their vector sizes and input limits appear only as the publisher states them.

Example: nomic-embed-text-v1.5 produces 768-dimension embeddings that can be shortened to as few as 64 dimensions. Its model card requires a task prefix at the start of each input, such as search_document for texts being indexed and search_query for questions.

Evaluation harness

Software that runs a model against one or more benchmarks in a consistent way: it formats the prompts, collects the outputs, and computes the scores, so that others can re-run the same evaluation.

In this catalog: evaluation tools are described with a checklist for code, tasks or data, scoring method, reproducibility instructions, and stated limitations, not with the model tiers (methodology).

Example: LM Evaluation Harness, maintained by EleutherAI, runs many benchmark tasks through one interface against local models or hosted model APIs.

Fine-tuning

Continuing to train an existing model on additional data so that it behaves differently, for example to follow instructions or to handle a narrower task. The result is a new set of weights, and the base model's license may still apply to it.

In this catalog: the base model is recorded as provenance. A U.S. fine-tune of a non-U.S. base model does not make the base model American (methodology).

Example: Llama 3.1 Tülu 3.1 8B is Ai2's post-trained version of Meta's Llama 3.1 8B base model, and its weights carry the Llama 3.1 Community License Agreement.

Foundation (open source)

A nonprofit organization that gives open-source projects a neutral home: it can hold their money and trademarks and provide shared services, while each project keeps its own technical governance. A large foundation can also host directed funds, programs with their own name, charter, and governing board whose money the host foundation holds and administers.

In this catalog: a directed fund has its own organization record, labeled Foundation-hosted and linked to the foundation that hosts it. Eligibility rests on the documented governing entity, never on the names or assumed nationalities of contributors (methodology).

Example: The Agentic AI Foundation is a directed fund of The Linux Foundation. Its charter (external site: raw.githubusercontent.com) has a Governing Board approve the projects it supports, leaves each project's governance to that project's own charter, and gives The Linux Foundation control over how the fund's money is held and spent.

Function calling (tool calling)

A way for a model to request an action outside itself: the application describes the available tools, the model replies with a structured request naming a tool and its inputs, and the application or the provider runs the tool and sends back the result. Anthropic's tool use documentation (external site: platform.claude.com) describes the model deciding when to call a tool based on the user's request and the tool's description.

In this catalog: when a model card documents tool or function calling, the release's "What it is useful for" section says so, and its run notes or checklist notes record any tool-call parser or chat format the card requires.

Example: The Berkeley Function Calling Leaderboard, from UC Berkeley's Gorilla project, evaluates how language models call functions. Its first version checked simple, parallel, and multiple function calls by abstract syntax tree (AST) evaluation, and later versions added multi-turn, multi-step, and agentic tasks.

Gated download

A download that requires an extra step before the files are released, such as signing in, sharing contact details, or accepting terms. On Hugging Face, a gated repository can grant access automatically once a user agrees, or it can require the publisher to approve each request by hand, as described in Hugging Face's gated models documentation (external site: huggingface.co).

In this catalog: weights that are released only after a request is approved are recorded as Partial, and the release is labeled Restricted weights rather than Open-weight (methodology).

Example: SAM 3.1 checkpoints are gated on Hugging Face, and downloads work only after an access request is accepted.

GGUF

A single-file format that stores a model's weights together with the metadata needed to load them, for inference with the GGML library and tools built on it, such as llama.cpp. Models are usually trained in another framework and then converted to GGUF, often with quantized weights. The format is specified in the GGUF documentation (external site: github.com) in the ggml repository.

In this catalog: a GGUF build is mentioned in the Weights checklist note or run notes of the release it was made from, rather than recorded as a separate release.

Example: For Rnj-1 Instruct, Essential AI publishes an official quantized GGUF build in a separate Hugging Face repository, and the model card documents running it with llama.cpp.

GPU (graphics processing unit)

A processor first built for 3D graphics that runs thousands of threads in parallel, which suits the highly parallel calculations used to train and run AI models. NVIDIA's CUDA Programming Guide (external site: docs.nvidia.com) contrasts a CPU, designed to run a sequence of operations as fast as possible, with a GPU, which trades lower single-thread performance for much greater total throughput.

In this catalog: GPUs are one kind of accelerator and appear as hardware products on the records of the companies that design them. GPU memory figures appear in run notes only as the publisher states them.

Example: AMD designs AMD Instinct GPUs for data centers and develops ROCm, an open software stack of programming models, tools, compilers, libraries, and runtimes for AI and HPC work on its GPUs.

Hallucination

Output from a generative AI model that is stated confidently but is false, or that contradicts its input or what it said earlier. NIST's Generative AI Profile (external site: nvlpubs.nist.gov) (NIST AI 600-1) calls this confabulation and explains it as a natural result of models generating outputs that approximate the statistical patterns of their training data. Why Language Models Hallucinate (external site: arxiv.org) (Kalai et al., 2025) argues that training and evaluation methods that reward guessing over admitting uncertainty help keep it going.

In this catalog: records do not report hallucination or accuracy rates, because the catalog does not publish benchmark scores; benchmarks that measure the problem have their own project records (methodology).

Example: Humanity's Last Exam asks models for an answer and a confidence from 0% to 100%, and its paper treats confidently wrong answers, measured as calibration error, as a sign of confabulation or hallucination.

High-bandwidth memory (HBM)

Computer memory built by stacking several DRAM chips vertically and connecting them through a very wide interface, packaged next to a GPU or other processor so that data reaches it quickly. Micron's HBM product page (external site: micron.com) describes a single HBM stack with a 1024-bit data interface, 16 times wider than a standard DDR5 module, and Google's Introduction to Cloud TPU (external site: docs.cloud.google.com) says on-chip HBM lets TPUs work with larger models and batch sizes.

In this catalog: memory is part of the chips and compute hub, and companies that make HBM list it among the hardware products on their organization records.

Example: Micron Technology lists HBM3E and HBM4 among its products and describes HBM as 3D-stacked DRAM for AI, high-performance computing, and other data-intensive workloads.

Hosted API

Access to a model that runs on the provider's own servers. You send inputs over the network and receive outputs, but you do not receive the weights.

In this catalog: "Hosted product/API" is a delivery label on organization pages. It is not an openness tier, and it says nothing about the organization's other releases (methodology).

Example: OpenAI lists the OpenAI API, pay-as-you-go access to its hosted models, among its products; its open-weight releases have their own separate records.

Inference

Running a trained model to produce outputs from inputs, as opposed to training it. Inference code is the software that loads the weights and performs that computation.

In this catalog: inference code is its own checklist item for each model release, separate from training code (methodology).

Example: vLLM is an inference and serving engine for large language models.

Instruction tuning

Fine-tuning a pretrained language model on many tasks written as plain-language instructions, so that it handles new tasks described the same way instead of only continuing text. Finetuned Language Models Are Zero-Shot Learners (external site: arxiv.org) (Wei et al., 2021) describes instruction tuning as finetuning language models on a collection of tasks described via instructions.

In this catalog: publishers often release a pretrained version and an instruction-tuned version of the same model, with names ending in words or suffixes such as "Instruct" or "-it". Each is a separate release record with its own evidence (methodology).

Example: Google's MedGemma model card explains that the suffix -pt marks pre-trained versions and -it marks instruction-tuned ones, and that both 27B variants, including MedGemma 27B (multimodal), are available only in instruction-tuned form.

Jailbreak

An attempt by a user to make a model produce output its developer has restricted, for example by wording a request so that the model abandons its usual refusals. NIST's taxonomy of attacks on AI systems, NIST AI 100-2 E2025 (external site: nvlpubs.nist.gov), defines a jailbreak as a direct prompting attack, carried out by the system's own user, intended to circumvent restrictions placed on model outputs.

In this catalog: jailbreak tests appear in benchmark records and in the safety results that model cards report; the catalog does not publish those scores (methodology).

Example: AILuminate, from MLCommons, includes a jailbreak benchmark for text and text-plus-image inputs, with a metric that captures how much a system's performance degrades when it is under jailbreak attack.

Knowledge cutoff

The point in time up to which a model's training data covers events, so the model may not know about anything later unless that information is given to it, for example in the prompt or through retrieval. Anthropic's Transparency Hub (external site: anthropic.com) explains a model's knowledge cutoff date as the date up to which its knowledge is most extensive and reliable, and its models overview (external site: platform.claude.com) lists a reliable knowledge cutoff and a separate training data cutoff for its current models.

In this catalog: a knowledge cutoff is recorded only when the publisher states one, usually in a release's summary or training-data note.

Example: OpenAI's model card for gpt-oss-120b states a knowledge cutoff of June 2024 for the text-only dataset the model was trained on.

Latency and throughput

Two measures of how fast a model serves requests: latency is how long one request takes, often split into the time to the first token and the time between later tokens, and throughput is how much work the whole system completes per second, such as output tokens per second across all requests. NVIDIA's guide to LLM inference metrics (external site: docs.nvidia.com) explains that as more requests run at once, total throughput rises until the hardware is saturated while the speed each user sees falls, and that tools define these metrics differently, so results should be compared only when the definitions match.

In this catalog: records mention speed measurements only as a publisher reports them, together with the hardware and settings it names.

Example: SGLang is a serving framework whose documentation says it is designed for low-latency, high-throughput inference on setups from a single GPU to large distributed clusters.

License scope

The specific materials a license covers. One release can have different licenses for its weights, code, data, and documentation, and a license file in a code repository does not by itself license weights published elsewhere under other terms.

In this catalog: each license entry records what it applies to (weights, code, data, documentation, weights and code, or all), and license filters match a license only to the component it covers (methodology).

Example: For TimesFM 3.0, the weights are under the TimesFM Non-Commercial License v1.0, while the timesfm source-code repository is under the Apache License 2.0.

Maintainer

The organization or group that currently governs a project: it reviews and accepts changes and publishes releases. The maintainer can differ from the organization that first created the project.

In this catalog: a project's eligibility rests on its documented governing or maintaining entity, never on the names or assumed nationalities of contributors (methodology).

Example: PyTorch was originally developed at Meta and has been hosted by the PyTorch Foundation, under the Linux Foundation, since September 2022.

Mixture of experts (MoE)

A model design in which some layers contain many parallel sub-networks, called experts, and a small routing network sends each token to only a few of them. Because only part of the model runs for each token, the total parameter count differs from the number of active parameters. A sparsely gated form of the design was described in Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer (external site: arxiv.org) (Shazeer et al., 2017).

In this catalog: total and active parameter counts appear only as the publisher states them, with a citation.

Example: Trinity Mini, from Arcee AI, has 26B parameters in total and 3B active; its model card lists 128 experts, 8 of them active, plus 1 shared expert.

Model card

A document published with a model that describes what it is, how it was trained and evaluated, what it is intended for, and its known limitations. The format was proposed in the paper Model Cards for Model Reporting (external site: arxiv.org) (Mitchell et al., 2018). On Hugging Face, the model card is the repository's README file, with metadata such as the license, as described in its model cards documentation (external site: huggingface.co).

In this catalog: model cards are a preferred source for technical claims, after the applicable license file (methodology).

Example: Meta publishes the model card for Llama 4 Scout as a file in its llama-models GitHub repository.

Model Context Protocol (MCP)

An open protocol that standardizes how AI applications connect to outside data sources and tools. In the MCP specification (external site: modelcontextprotocol.io), a host application uses clients to exchange JSON-RPC 2.0 messages with servers, and servers can offer resources (context and data), prompts (templated messages and workflows), and tools (functions for the AI model to execute).

In this catalog: the protocol has its own project record, and records for agents and models note MCP support where their documentation states it.

Example: The repository of the Model Context Protocol holds the specification, a schema defined in TypeScript and also published as JSON Schema, and the official documentation. Anthropic donated the protocol to the Agentic AI Foundation, under the Linux Foundation, in December 2025.

Model family

A named line of related models released over time, often in several sizes or generations.

In this catalog: a family record summarizes the line and links to its releases. It never carries a license or a tier, because those can differ from one release to the next (methodology).

Example: The Gemma family record links releases including Gemma 4 31B, which is under the Apache License 2.0, and EmbeddingGemma 300M, which is under the Gemma Terms of Use.

Model release

One specific published model, identified by its name, size, and version, with its own files and its own terms.

In this catalog: licenses, availability, checklists, and tiers attach only to releases, and a release's evidence is never inherited from another version (methodology).

Example: Olmo 3.1 32B Think is one release in Ai2's Olmo family, with its own licenses and checklist.

Multimodal model

A model that works with more than one kind of data, such as text, images, audio, or video, as input, output, or both. OpenAI's GPT-4o System Card (external site: arxiv.org), for example, describes a model that accepts any combination of text, audio, image, and video as input and generates text, audio, and image outputs, with all of them processed by the same neural network.

In this catalog: a release's summary states which kinds of input and output its publisher documents. Models that take images together with text are often called vision-language models.

Example: Molmo2-O 7B, from Ai2, is a vision-language model whose model card says it supports image, video, and multi-image understanding and grounding.

Nonprofit

An organization that is not run to make a profit for owners or shareholders. In the United States, the IRS recognizes many nonprofits as tax-exempt: section 501(c)(3) (external site: irs.gov) covers organizations run for charitable, scientific, educational, and similar purposes, and section 501(c)(6) (external site: irs.gov) covers business leagues, such as trade associations, that promote a shared business interest. In both cases, net earnings may not benefit any private shareholder or individual.

In this catalog: U.S. nonprofit or lab is one of the four eligibility bases. Nonprofit status is documented from the organization's own pages and, where available, the IRS listing of tax-exempt organizations (methodology).

Example: EleutherAI appears in the IRS exempt-organization data for the District of Columbia as EleutherAI Institute, a 501(c)(3) organization with a ruling date of November 2023.

Open source (software)

Software distributed with its source code under a license that meets the Open Source Initiative's Open Source Definition (external site: opensource.org) (version 1.9). Its criteria include free redistribution, access to the source code, permission to make derived works, and no discrimination against persons, groups, or fields of endeavor. Code that is merely readable on a public website is not open source on that basis alone.

In this catalog: each project lists its license with an SPDX identifier where one exists and a link to the license file; an identifier alone never replaces reading the terms (methodology).

Example: llama.cpp is published under the MIT License.

Open-source AI (OSI definition)

An AI system made available under terms that grant the freedoms to use, study, modify, and share it, as set out in the Open Source Initiative's Open Source AI Definition (external site: opensource.org), version 1.0. The definition requires detailed information about the training data, the complete code used to train and run the system, and the parameters, each under OSI-approved terms. It does not require every piece of training data to be downloadable.

In this catalog: USASI does not certify releases against this definition. Its highest model tier, Open system (reviewed), is an editorial label that requires a sourced review specific to the release (methodology).

Example: Olmo 3 7B publishes its weights, training scripts, and training-data mixes. The catalog labels it Open-stack, which describes published materials and is not a finding that it meets the OSI definition.

Open-stack

A USASI tier for a model release that is Open-weight and also has published inference code, training code, and a training recipe, plus at least a documented composition of its training data. It is an editorial category of rubric v0.2, not an outside standard, and it does not require the training data itself to be downloadable.

In this catalog: the tier is computed from the release's checklist. Tiers are cumulative, so every Open-stack release also counts as Open-weight; the higher tier, Open system (reviewed), also requires complete training-data information, a complete training pipeline, and a sourced review of reuse rights (methodology).

Example: Olmo 3 7B is labeled Open-stack: Ai2 publishes its weights, the OLMo-core scripts for its pretraining, mid-training, and long-context stages, a technical report with its training configuration, and links to the data mixes used at each stage.

Open weight

A model whose trained parameters can be downloaded by the public. The term describes availability: the license that comes with the weights may still limit commercial use, redistribution, or particular uses. Others use the term with stricter requirements; the OSI's explainer on open weights (external site: opensource.org), for example, describes final parameters shared under an OSI-approved license, without the training code or data.

In this catalog: the Open-weight tier requires only publicly obtainable weights. The license is recorded separately and shown next to the label, with a caveat when it is not on the rubric's list of OSI-approved licenses (methodology).

Example: gpt-oss-20b is labeled Open-weight; its weights download without a gate under the Apache License 2.0.

Parameter (parameter count)

One of the numbers inside a model that training adjusts, such as the weights and biases of a neural-network layer; a model's parameter count is the total number of them, usually written with M for millions or B for billions. PyTorch's tutorial Build the Neural Network (external site: docs.pytorch.org) describes layers whose weights and biases are optimized during training and shows how to list a model's parameters.

In this catalog: parameter counts appear only as the publisher states them. For mixture-of-experts models, total and active counts are given separately where the publisher states both (mixture of experts).

Example: Google's documentation calls EmbeddingGemma 300M a 308M-parameter model, while its Hugging Face model card calls it a 300M-parameter model and lists its size as 0.3B parameters, so the name gives a rounded figure.

Parent company and documented control

A parent company controls another organization, its subsidiary, either directly or through other subsidiaries. In the SEC's definitions in Rule 405 (external site: ecfr.gov), control means the power to direct an entity's management and policies, whether through owning voting securities, by contract, or otherwise, so it can rest on more than share ownership.

In this catalog: documented U.S. control is one of the four eligibility bases. It applies when filings or official pages show that a U.S. entity primarily controls an organization, for example a research unit wholly owned by a U.S.-headquartered company, and each such case gets a written assessment (methodology).

Example: The Google DeepMind record names no headquarters, because the official pages reviewed do not state one. It is assessed under U.S. control because Google and Alphabet document it as part of Google, and Alphabet's principal executive offices are in Mountain View, California.

Post-training

The training applied after pretraining that turns a base model into one suited to a purpose, such as a chat assistant that follows instructions. Ai2's Tülu 3 paper (external site: arxiv.org) describes post-training as refining behaviors and unlocking new skills, with methods such as supervised fine-tuning, Direct Preference Optimization, and reinforcement learning with verifiable rewards.

In this catalog: a release's checklist notes whether its published code and data cover only post-training or also pretraining; a fine-tuning script alone does not count as complete training code (methodology).

Example: Ai2 post-trained Olmo 3 7B Instruct from the Olmo 3 7B base model in three stages, supervised fine-tuning, DPO, and reinforcement learning with verifiable rewards, and its model card links the checkpoint from each stage.

Power and energy

Power is the rate at which electricity is supplied or used at a given moment, measured in watts (W): a kilowatt (kW) is 1,000 watts, a megawatt (MW) is 1,000 kW, and a gigawatt (GW) is 1,000 MW. Energy is power used over time, measured in watthours (Wh): a kilowatthour (kWh) is one kilowatt for one hour, and a megawatthour (MWh) is one megawatt for one hour. A figure in megawatts or gigawatts therefore describes capacity at a moment, not an amount of electricity used. The U.S. Energy Information Administration explains these units in Measuring electricity (external site: eia.gov).

In this catalog: power-capacity figures are not published, even when an organization's own announcements state them (methodology).

Example: Thinking Machines Lab records a March 2026 partnership with NVIDIA to deploy NVIDIA systems for its model training. The announcement, listed among the record's sources, calls the partnership gigawatt-scale in its title, which describes power capacity; the record's own text gives no capacity figure.

Preference tuning (RLHF and DPO)

Training a model on comparisons of which of two or more responses is better, so that it produces the kinds of responses people prefer. In reinforcement learning from human feedback (RLHF), as described in Training language models to follow instructions with human feedback (external site: arxiv.org) (Ouyang et al., 2022), people rank model outputs and those rankings are used to fine-tune the model with reinforcement learning; Direct Preference Optimization (external site: arxiv.org) (Rafailov et al., 2023) learns from the same kind of comparisons with a simple classification loss instead.

In this catalog: preference-tuning stages are described in the summary, provenance, or training-recipe notes of releases that document them, and the preference datasets in their training-data notes.

Example: TRL, Hugging Face's library for post-training models, provides a DPOTrainer alongside trainers for supervised fine-tuning, GRPO, and KTO.

Pretraining

The first stage of training a model, in which it learns general patterns from a very large collection of unlabeled data; a language model is usually pretrained to predict the next word from the text that comes before it. Anthropic's glossary (external site: platform.claude.com) notes that pretrained models are not inherently good at answering questions or following instructions, and that fine-tuning and RLHF are used to refine them.

In this catalog: pretraining datasets have their own project records, and a release's checklist records whether its pretraining code, recipe, and data are published, separately from later training stages (methodology).

Example: Dolma is Ai2's family of pretraining corpora drawn from web content, academic publications, code, books, and encyclopedic material, and versions of it were used to train Ai2's OLMo models.

Prompt

The input given to a generative model to get a response, such as a question, instructions, examples, or a document to work on. Writing prompts so that a model reliably gives the output you need is called prompt engineering, which OpenAI's prompting guide (external site: developers.openai.com) describes as a mix of art and science because model output is non-deterministic.

In this catalog: when a model card says a model needs a particular prompt format, chat template, or prefix to work correctly, the release's run notes usually say so.

Example: DSPy is a framework for writing language-model programs as Python modules instead of hand-written prompts, with optimizers that tune the prompts and weights of those programs.

Prompt injection

An attack in which text given to a model, typed by a user or hidden in content the model reads, overrides the instructions set by the developer or application, such as the system prompt. NIST's AI 100-2 E2025 (external site: nvlpubs.nist.gov) defines it as exploiting the concatenation of untrusted input with a prompt built by a higher-trust party, and calls it indirect when the instructions arrive through resources the system reads rather than from the user. OWASP's LLM01:2025 Prompt Injection (external site: genai.owasp.org) says it is unclear whether there are fool-proof methods of preventing it.

In this catalog: records do not rate how well any model or product resists prompt injection. The risk applies to agents and retrieval systems that read outside content; agent software is gathered in the agents hub.

Example: How models use tools explains why tool results can carry indirect prompt injection and which controls, such as least privilege and human approval for high-risk actions, limit the damage.

Quantization

Storing a model's weights, and sometimes its intermediate values, at lower numerical precision (for example 4-bit integers instead of 16-bit numbers) to reduce memory use and speed up inference, sometimes at some cost in output quality.

In this catalog: memory or hardware figures are recorded only when a publisher states them, together with the precision they assume.

Example: AWQ (Activation-aware Weight Quantization), from MIT HAN Lab, is a method and codebase for 4-bit and 3-bit weight-only quantization of language models.

Reasoning model

A language model that generates intermediate reasoning, often called thinking, before its final answer, which helps with multi-step problems at the cost of extra tokens. OpenAI's reasoning guide (external site: developers.openai.com) describes reasoning tokens that the model uses to break down the prompt and consider several approaches, and notes that they take up space in the context window even though they are not visible through the API.

In this catalog: whether a release reasons before answering, and how that mode is switched on or off, is recorded as its model card documents it.

Example: Hermes 4 70B, from Nous Research, is a hybrid reasoning model that can answer directly or deliberate first inside think tags. Its model card says reasoning mode can be switched on with a thinking flag in the chat template or with a system prompt.

Red teaming

Structured testing in which people or automated tools act as adversaries, trying to make an AI system fail, misbehave, or help with misuse. NIST's AI 100-2 E2025 (external site: nvlpubs.nist.gov) defines red teaming in the AI context as a structured testing effort, often using adversarial methods, to find flaws and vulnerabilities, including unforeseen or undesirable system behaviors and potential risks from misuse.

In this catalog: red-teaming tools and benchmarks are project records, and the catalog does not reproduce red-teaming results reported in model or system cards (methodology).

Example: The Center for AI Safety lists among its research HarmBench, a standardized evaluation framework for automated red teaming and robust refusal.

Restricted weights

A USASI tier for a model release whose weights can be obtained only by request, with approval, or by some users, for example through a gated download that the publisher reviews. Such a release is not counted as Open-weight, however much else about it is published.

In this catalog: the tier follows from the Weights checklist item: weights recorded as Partial give Restricted weights, and the license is recorded separately (methodology).

Example: For DINOv3 ViT-7B/16, Meta publishes training code and stage-by-stage configuration files, but downloading the weights from Hugging Face requires an approved access request, so the release is labeled Restricted weights.

Retrieval-augmented generation (RAG)

A technique in which a system first retrieves passages relevant to a question from a collection of documents and then gives them to a language model along with the question, so that the answer can draw on, and cite, information beyond the model's training data. The approach was described in Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (external site: arxiv.org) (Lewis et al., 2020), and NIST's AI 100-2 E2025 (external site: nvlpubs.nist.gov) glossary notes that it lets a model's knowledge be changed without retraining.

In this catalog: the parts of a RAG system, such as embedding models, vector databases, and orchestration frameworks, are separate records with their own licenses.

Example: PaperQA, from FutureHouse, is a package for retrieval-augmented question answering over PDFs, text files, Office documents, and source code that gives answers with in-text citations.

Reviewed date

The date an editor last checked a piece of evidence against its sources. It is different from the date a record was edited, the date an artifact was released, and the date the site was built.

In this catalog: each record shows a "Last reviewed" date, and individual facts, such as a license or an availability assessment, can carry their own reviewed date. An automated fetch is not a review (methodology).

Example: On gpt-oss-20b, the license entries carry their own reviewed dates, separate from the record's "Last reviewed" date.

Sampling temperature

A setting that controls how random a language model's word choices are as it generates text: lower values keep it closer to the most likely tokens, and higher values give less likely tokens more chance, for more varied output. Hugging Face's generation documentation (external site: huggingface.co) gives 1.0 as the default when a model's configuration sets no value, and Anthropic's glossary (external site: platform.claude.com) notes that on its API even a temperature of 0 does not make results fully deterministic.

In this catalog: sampling settings that a model card recommends, such as temperature, are recorded in the release's run notes.

Example: Google's model card for Gemma 4 12B Unified recommends temperature 1.0, top_p 0.95, and top_k 64; the last two are further settings that limit which tokens can be chosen.

Self-hosting / local inference

Running a model on hardware you control, such as a laptop, a workstation, or your own servers, instead of calling a provider's hosted service. It requires access to the weights and to software that can run them, and the weights' license still applies.

In this catalog: run notes on a release describe only documented ways to run it, and any memory figure is attributed to its source.

Example: Ollama is an MIT-licensed application for downloading and running open models on macOS, Windows, and Linux; the company behind it also offers cloud-hosted models.

Subsidiary

A company that is owned or controlled by another company, its parent. A research unit is a similar relationship within a single company.

In this catalog: a subsidiary or unit with its own record is also counted under "units and subsidiaries," so a parent and its subsidiary are never presented as two independent companies. Parent–subsidiary cases get a written eligibility assessment (methodology).

Example: Red Hat is documented in its record as a wholly owned subsidiary of IBM, with its own headquarters in Raleigh, North Carolina.

Synthetic data

Training data generated by a model or program rather than collected from sources such as web pages, books, or code written by people, for example text rewritten by a language model or worked solutions it writes. Microsoft's Phi-4 Technical Report (external site: arxiv.org) contrasts synthetic data with organic data such as web content or code, and describes generating it with techniques including multi-agent prompting, self-revision, and instruction reversal.

In this catalog: training-data and provenance notes say when a publisher reports using synthetic data and, where documented, which models generated it.

Example: The original release of NVIDIA's Nemotron-CC pretraining dataset has 6.3 trillion tokens: 4.4 trillion deduplicated original tokens from Common Crawl and 1.9 trillion synthetically generated ones. Its paper says the rephrased data was not checked for factual accuracy or fidelity to the original.

System card

A document in which a developer reports a model's capabilities and limitations, the safety evaluations it went through, and the decisions made about deploying it. Anthropic describes its system cards (external site: anthropic.com) as documenting capabilities, safety evaluations, and responsible deployment decisions, and OpenAI's GPT-4o System Card (external site: arxiv.org) covers the model's capabilities, limitations, and safety evaluations, including third-party assessments.

In this catalog: like a model card, a system card can be cited for what its developer states, but the catalog does not reproduce the safety or benchmark scores it reports (methodology).

Example: The explainer on safety testing and frameworks describes what a system card contains and how to read the safety claims in one.

System prompt

Instructions that a developer or application gives a model separately from the user's messages, setting its role, goals, tone, or rules. NIST's AI 100-2 E2025 (external site: nvlpubs.nist.gov) glossary describes system prompts as application-specific instructions, typically placed before other input, that may be treated as higher-trust than other input, and Anthropic's Messages API (external site: platform.claude.com) takes the system prompt as its own parameter rather than as a message.

In this catalog: when a model card recommends or requires a system prompt, the release's run notes say so.

Example: The model card for Rnj-1 Instruct recommends always adding a system prompt and warns that the model is especially inclined to write code, even for non-code tasks, when the system prompt is left out.

Token

The unit of text a language model reads and writes, which can be a whole word, part of a word, a single character, or a byte; a tokenizer splits text into tokens before the model processes it. Anthropic's glossary (external site: platform.claude.com) gives about 3.5 English characters per token as an approximate figure for its Claude models and notes that the number varies by language.

In this catalog: context windows and dataset sizes are given in tokens as the publisher counts them, and a count depends on the tokenizer used to make it.

Example: The dataset card for FineWeb describes it as more than 18.5 trillion tokens of cleaned and deduplicated English web data and states its token counts using the GPT-2 tokenizer.

Tokenizer

The component that splits input text into tokens, such as words, parts of words, or single characters, and converts them into the numeric IDs a model works with. A model is normally run with the same tokenizer it was trained with. Hugging Face's guide to tokenization algorithms (external site: huggingface.co) describes the common subword methods.

In this catalog: a tokenizer that is distributed separately from a model's weights is noted in the release's run notes or provenance.

Example: OpenELM 3B Instruct is published without tokenizer files. Apple's example script loads Meta's Llama 2 tokenizer from a separate Hugging Face repository, which is gated, and the script requires a Hugging Face access token.

TPU (tensor processing unit)

Google's custom chip for machine learning, an application-specific integrated circuit (ASIC) designed for the large matrix operations common in machine-learning algorithms. Google's Introduction to Cloud TPU (external site: docs.cloud.google.com) says TPUs have on-chip high-bandwidth memory, can be connected in groups called slices, and run code compiled by the XLA compiler.

In this catalog: TPUs are named where a model card or technical report says a model was trained on them, and software records mention TPU support where their documentation states it.

Example: Google (Alphabet) offers TPUs to Google Cloud customers alongside GPUs. Its Cloud documentation describes TPU7x as the first release in the Ironwood family, Google Cloud's seventh-generation TPU.

Transformer

A neural-network architecture built around attention layers, which let each position in a sequence draw on the others, instead of processing the sequence one step at a time. It was proposed for machine translation in Attention Is All You Need (external site: arxiv.org) (Vaswani et al., 2017), and NIST's AI 100-2 E2025 (external site: nvlpubs.nist.gov) glossary calls transformer-based generative pre-trained models the predominant architecture for large language models.

In this catalog: release summaries describe a model's architecture, such as a dense or mixture-of-experts transformer, as the publisher's documentation does.

Example: Transformer Explainer runs a GPT-2 model in the web browser, so that users can enter their own text and follow how the transformer's components work together to predict the next token.

Unknown

A status meaning that an item has not been assessed yet, or that the available evidence is not enough to decide. It never stands in for "no."

In this catalog: "Not public" is used instead when the evidence shows that something is unavailable (methodology).

Example: On Gemma 4 31B, training code is Unknown: the record notes fine-tuning code in Google DeepMind's gemma library, but no published code used to pre-train Gemma 4.

Vector database

A database that stores embeddings together with the items they represent and finds the stored vectors closest to the vector of a query, which lets search and retrieval systems find related content by meaning. The Faiss (external site: github.com) similarity-search library, for example, compares vectors by L2 distance or dot product and offers indexes that trade some search precision for speed or memory on very large collections.

In this catalog: vector databases and vector-search libraries are project records, and the explainer on retrieval-augmented generation shows where they fit in a retrieval system.

Example: Chroma is an open-source database for AI applications that stores embeddings with metadata and supports dense, sparse, and hybrid vector search, keyword and regex search, and metadata filtering. It can run locally, be self-hosted, or be used as a managed cloud service.

Watermark (AI content)

A signal embedded in AI-generated content, usually imperceptible to people, that a detector can later check for to estimate whether the content came from a particular model or service. Google's SynthID documentation (external site: ai.google.dev) describes detectors that score content for the likelihood that it was watermarked, and notes that the score can drop sharply when generated text is thoroughly rewritten or translated.

In this catalog: watermarking tools are project records. A watermark is different from content credentials, which attach signed provenance information to a file, although the C2PA specification can use a watermark to find credentials that were removed from a file.

Example: SynthID Bio, from Google DeepMind, watermarks AI-generated protein sequences and biomolecular structures; its repository contains the code for watermarking sequences generated with ProteinMPNN and for computing detection scores.

Weights

The numerical parameters a model learns during training. Together with the model's architecture and inference code they make up the model, a breakdown the Open Source AI Definition (external site: opensource.org) also uses. Weights are usually distributed as large files, sometimes with checkpoints saved at intermediate points in training.

In this catalog: weights are the first checklist item for a model release, and their availability decides whether a release can be labeled Open-weight (methodology).

Example: Pythia 12B publishes its final weights and 154 intermediate checkpoints as branches of its Hugging Face repository.