AI Assistants / Grounding and disclosure / Knowledge cutoff notice

Knowledge cutoff notice

The answer is stated in the present tense about a world the model last saw a year ago.

Updated September 12, 2026

Problem

Someone asks who runs a company, what a product costs, or whether a library still supports a feature. The answer comes back fluent, specific and in the present tense, describing a state of the world that stopped being true some time after the model finished training and before the question was asked.

Solution

Surface the boundary at the moment it becomes relevant rather than as a permanent disclaimer. A footer saying the model may produce inaccurate information is read once and never again. A line on a specific answer saying the information predates a stated date is read every time, because it arrived attached to something the viewer cares about.

The trigger is the design problem. Flagging every answer is noise; flagging none is the status quo. The workable heuristic keys on the question rather than the answer: anything asking about current state, prices, people in roles, versions, availability, or events is time-sensitive by construction, and those are detectable. So is a question containing a recent year.

Once a model can search, the notice changes shape rather than disappearing. The useful distinction becomes whether this particular answer was checked against live sources or produced from training data. Those two look identical on screen and differ completely in reliability, and a viewer can’t tell them apart without help. The presence of a source list is the strongest available signal, which makes the absence of one meaningful in a product that usually shows them.

Precision matters more than it seems. A cutoff is a property of a specific model, and products offering several are offering several cutoffs. Providers publish these, and a product that lets people choose a model and then hides the date has left the most decision-relevant property out of the picker.

HAX guideline 2 asks systems to make clear how well they can do what they do, and a training cutoff is one of the few limits that can be stated exactly rather than estimated. That precision is worth using, because “may be outdated” carries almost no information while a date lets someone reason about whether it matters to their question.

Use when

The model answers from training data about things that change, and especially where a product also has a search mode that may or may not have run.

Don’t use when

The answer is drawn from supplied material or retrieved sources, or the task is generation rather than recall. A cutoff notice on a rewritten paragraph is noise attached to an operation the cutoff doesn’t affect.

Trade-offs

An honest notice lowers confidence in answers that are often correct, and the products that ship it most prominently look less capable than ones that stay quiet. Triggering on time-sensitive questions requires classifying the question, which adds latency and misclassifies. A permanent disclaimer is cheap, universally ignored, and mostly serves the people who wrote it. Stating a date also invites a reasonable follow-up the product usually can’t answer: what the model knows about the weeks just before it. Coverage thins out well ahead of the stated boundary.

Checklist

Does the notice appear on time-sensitive answers rather than all of them?
Is a specific date given rather than a vague warning?
Does the date track the model actually used?
Can the viewer tell whether this answer was checked against live sources?
Is the absence of sources meaningful in this product?
Does the model picker show cutoffs alongside the names?
Is there a one-click path from the notice to a search-backed answer?
Does the notice survive copying or sharing the answer?
How does it read on the tenth occurrence in one session?
Is the notice suppressed when the answer came entirely from supplied material?

Compare

Claude publishes per-model training cutoffs in its documentation, which makes the property checkable rather than folkloric, and leaves surfacing it to the product built on top. ChatGPT mostly resolves the question by searching when a query looks current. A disclosure problem becomes a retrieval one, and the viewer is left to infer from the presence of sources. Perplexity sidesteps the pattern almost entirely by retrieving for nearly everything, so its equivalent risk is a stale source rather than a stale model. GitHub Copilot shows the same limit in its sharpest form, suggesting code against the library versions present in its training data, so a stale cutoff surfaces as a deprecated API call rather than as a wrong fact.

Citation chip and source list are the strongest evidence that a given answer went beyond training data. Mode switch is what a viewer reaches for once the notice tells them the answer needs checking. Refusal is the stronger response when the gap is too large to caveat. Model picker is where the cutoff belongs and is usually missing.

Wireframe — the pattern's anatomy, not any one product's version of it

Implementation

A date is information; a permanent “may be outdated” banner is not. The same question answered from training data and from live sources differ by whether a source list is present, and questions about current state are detectable before the answer is written.

shadcn: npx shadcn@latest add button
Tokens: --card--card-foreground--primary--muted--muted-foreground--border--status-warn

LightDarkCode

Vite 5 is still receiving security fixes but no new features. Vite 6 changed the default environment API, so moving the build means updating any plugin that readsconfig.serverdirectly. Your slow build is more likely the three unbundled icon packs than the Vite version.

from training data to May 2026

no sources, so nothing was checked

CutoffNotice.tsxWraps an answer. Shows the model's cutoff as a date when the question is time-sensitive and no sources were checked; a source list suppresses it.

import type { ReactNode } from "react";
import { Button } from "@/components/ui/button";
import { isTimeSensitive } from "./timeSensitive";

/** A cutoff belongs to a model. A product with three models has three of
 *  them, so the notice takes the model rather than a date from a config. */
export type Model = { name: string; cutoff: Date };

type Props = {
  /** The answer this notice is attached to. */
  children: ReactNode;
  /** What was asked. Time-sensitive questions get the notice; the rest do not. */
  question: string;
  model: Model;
  /** What the answer was checked against. A non-empty list suppresses the
   *  notice: the sources are the signal, and their absence is what this line
   *  has to say out loud. */
  sources?: string[];
  /** The one-click path from a recalled answer to a checked one. */
  onSearch: () => void;
};

const monthYear = (d: Date) => d.toLocaleDateString("en", { month: "long", year: "numeric", timeZone: "UTC" });

export function CutoffNotice({ children, question, model, sources = [], onSearch }: Props) {
  const show = sources.length === 0 && isTimeSensitive(question);

  return (
    <div className="text-sm leading-relaxed text-card-foreground">
      {children}

      {show && (
        <div className="mt-3" role="note">
          {/* A date rather than "may be outdated". It is one of the few limits
              that can be given exactly, and a date lets the viewer reason
              about whether it matters to their question. */}
          <span className="inline-block rounded-md bg-status-warn/15 px-2.5 py-1 text-[11px] text-status-warn">
            from training data to {monthYear(model.cutoff)}
          </span>
          <p className="mt-2 flex flex-wrap items-center gap-x-2 text-[11px] text-muted-foreground">
            no sources, so nothing was checked
            <Button variant="link" size="sm" className="h-auto p-0 text-[11px]" onClick={onSearch}>
              check against live sources
            </Button>
          </p>
        </div>
      )}
    </div>
  );
}

timeSensitive.tsThe trigger. Current state, prices, roles, versions and recent years, all spotted from the question before the answer exists.

/**
 * The trigger keys on the question, not the answer. Current state, prices,
 * people in roles, versions, availability, and anything naming a recent year
 * are time-sensitive by construction, and every one of them can be spotted
 * before a token is generated.
 */
const CUES: RegExp[] = [
  /\b(who|which)\b.*\b(runs?|leads?|owns?|heads?|ceo|founder|maintainer)\b/i,
  /\b(cost|costs|price|pricing|how much|per (month|seat|year))\b/i,
  /\b(latest|current|newest|version|release|supported|maintained|deprecated)\b/i,
  /\b(now|today|currently|still|yet|any ?more|these days)\b/i,
  /\b20[2-9]\d\b/,
];

export const isTimeSensitive = (question: string) => CUES.some((re) => re.test(question));

demo.tsxHow it is called: a question about whether a version is still supported, answered without sources.

import { CutoffNotice } from "./CutoffNotice";

/**
 * A question about current state, answered from training data. The question
 * trips the trigger, there is no source list, so the answer carries the date.
 * Search would rerun the question against live sources and hand back a
 * source list, at which point the notice goes away on its own.
 */
const QUESTION = "Does Vite 5 still get security fixes, or do we have to move the build to 6?";

export default function Demo() {
  return (
    <div className="rounded-lg border bg-card p-4">
      <CutoffNotice
        question={QUESTION}
        model={{ name: "model", cutoff: new Date("2026-05-01T00:00:00Z") }}
        onSearch={() => {}}
      >
        <p>
          Vite 5 is still receiving security fixes but no new features. Vite 6 changed the default
          environment API, so moving the build means updating any plugin that reads
          <code className="mx-1 rounded bg-muted px-1 text-xs">config.server</code>
          directly. Your slow build is more likely the three unbundled icon packs than the Vite version.
        </p>
      </CutoffNotice>
    </div>
  );
}

What it renders. Identical markup in both panes, with only the token values changing.

Copy-paste: this implementation as plain text

Examples

No captures reference this pattern yet. Captures arrive product by product; see Products for what's in the gallery so far.

Machine-readable: this page as markdown