since-cutoff

<p align="center"><picture> <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MohammadHijjawi97/since-cutoff/main/docs/img/logo-dark.svg"> <img src="https://raw.githubusercontent.com/MohammadHijjawi97/since-cutoff/main/docs/img/logo.svg" width="72" height="72" alt="since-cutoff logo"> </picture></p> <h1 align="center">since-cutoff</h1> <!-- mcp-name: io.github.MohammadHijjawi97/since-cutoff -->

Your coding assistant's training data stops before your dependencies' latest releases, so it can write calls your pinned versions no longer accept. since-cutoff shows where your code uses an API that changed after the model's training cutoff, and writes the short notes your assistant needs to avoid the old form.

since-cutoff is a command-line tool and MCP server for Python projects. scan reads your lockfile, takes each dependency's latest release published at least 30 days before your coding model's training cutoff (by default), compares that release's public API with the version you pin, statically, and shows which of the changed APIs your code uses, where, with a note for each. sync writes the notes into AGENTS.md or CLAUDE.md and keeps them in step with the lockfile; status, pre-commit hooks and a GitHub Action tell you when they fall behind. run, optional, measures which of the changes your model actually gets wrong and whether the notes help. Only run calls a model.

English | 简体中文 | Español | Français

Install

Python 3.10 or later, on Linux, macOS or Windows.

pipx install since-cutoff    # or: pip install since-cutoff

Or run it without installing: uvx since-cutoff scan downloads the current release and runs it (uvx since-cutoff@latest scan picks up new releases instead of the first one uv cached).

run type-checks the model's answers with basedpyright, an extra of 180 MB that the other commands never use: pip install "since-cutoff[run]" (or pipx install "since-cutoff[run]") installs it, and uvx --with basedpyright since-cutoff run adds it to a run without installing; without it, run stops at once and says so.

Run it from your project root. It reads uv.lock, poetry.lock, pdm.lock, pylock.toml, Pipfile.lock, requirements*.txt, pyproject.toml, Pipfile, the pip: block of a conda environment.yml or a .venv (not setup.py or setup.cfg). Without --model it uses the model your coding agent is set up with, from the Claude Code, Codex, Gemini CLI, OpenCode or Aider settings; for any other model, pass --model (see Choosing the model). scan, sync and status call no model and need no API key; run sends prompts to the model provider and uses your API credits or Claude Code usage.

Inside a coding agent, a skill runs these commands for you: see In Claude Code and In other coding agents. The MCP server gives any agent the same diff.

Quick start

The sample project calls client.messages.create and pins anthropic 1.8.0. The latest anthropic release at Claude Sonnet 4.5's training cutoff was 0.60.0, whose create still took temperature; 1.8.0 raises TypeError for it. What scan prints, trimmed to the anthropic part (it compares from 0.56.0, the latest release 30 days before the cutoff: models know the weeks before their cutoff least):

$ uvx since-cutoff scan --model anthropic:claude-sonnet-4-5
Your code uses 2 APIs that changed after claude-sonnet-4-5's training cutoff (2025-07-31)

huggingface-hub 0.33.1 -> 2.0.0 (0.33.1 was the latest release 30 days before the cutoff;
  pyproject.toml pins 2.0.0)
  ...

anthropic 0.56.0 -> 1.8.0 (0.56.0 was the latest release 30 days before the cutoff; pyproject.toml
  pins 1.8.0)
  Messages.create: temperature, top_k and top_p were removed                          uses this API
    app/main.py   calls create
    Note: `Messages.create()` no longer accepts `temperature`, `top_k` or `top_p` as keyword
          arguments. If the API still needs them, pass them through its `extra_body` argument.
          [diff]

2 notes ready: `since-cutoff sync` writes them to AGENTS.md and keeps them in step with
  pyproject.toml.

The call in app/main.py passes none of these parameters, so it is marked "uses this API", not "old form": it works today, but an assistant writing for 0.60.0 could add temperature=0.2 when it edits the call. The note is what since-cutoff sync writes into AGENTS.md so that it does not; its tag, [diff], says what the note rests on: a static comparison of the two releases' public APIs. The parameters left the signature, which is not the same as the API dropping the field, so where the pinned method has an extra_body argument the note says so instead of telling the assistant to drop the field.

since-cutoff sync then writes the two notes. It prints the block as a diff and asks Write this to AGENTS.md? [y/N] (--yes writes without asking; --dry-run only shows the diff). For the sample project, the block ends with:

**anthropic 1.8.0** (compared from 0.56.0)
- `Messages.create()` no longer accepts `temperature`, `top_k` or `top_p` as keyword arguments. If the API still needs them, pass them through its `extra_body` argument. [diff]

**huggingface-hub 2.0.0** (compared from 0.33.1)
- `huggingface_hub.hf_hub_download()` no longer accepts `proxies`, `force_filename`, `local_dir_use_symlinks` or `resume_download`; do not pass them. huggingface-hub's deprecation text says there is no replacement for `force_filename`, `local_dir_use_symlinks` or `resume_download`. For `proxies`, see https://github.com/huggingface/huggingface_hub/releases (2.0.0). [diff]
<!-- since-cutoff:end -->

Above the bullets are the start marker, a meta line (the model, its cutoff, where the versions come from, a hash of the dependencies and a hash of the block's own text, so that a hand edit shows) and a header that names the model, the cutoff and the file the versions come from, says what the tags mean and that no library code was run. The whole block is about 410 tokens. Text outside the block keeps its bytes, and since-cutoff unapply removes the block. After an upgrade, run sync again; sync --check in CI and status offline tell you when the notes fall behind (Keep the notes current).

Try it on your project. No API key, no model call. In the project root:

uvx since-cutoff scan

It detects your coding model (or pass --model), reads your lockfile, takes each dependency's latest release published at least 30 days before the model's training cutoff (by default), and compares that release's public API with the version you pin, statically: no package code runs. The cutoff only chooses which changes to look at; it says nothing about what the model memorised. Whether your model really gets them wrong, and whether the notes help, is what since-cutoff run measures; it calls your model and is optional.

When to use it, and what it does not do

Use it when you write Python with a coding agent and pin dependencies that have released since the model's training cutoff; for the Python AI stack, that is most of them (The problem):

• scan for a look: the changed APIs your code uses, where, and a note for each;
• sync to put the notes into AGENTS.md or CLAUDE.md and keep them current, and sync --check, status, the pre-commit hooks or the GitHub Action to be told when they fall behind;
• the MCP server to let an agent ask what changed in a library before it writes code;
• run to find out whether your model actually writes the old API, and whether the notes fix it.

It does not:

• call a model, except run: scan, sync, status, the MCP server, the Action and the hooks need no API key;
• run package code or model-written code: packages are read statically, and answers are only type-checked;
• see behaviour changes behind an unchanged signature, or deprecations that only warn at run time;
• name a replacement unless the library's own deprecation text states it;
• say what the model memorised: the cutoff picks the comparison release, and only run asks the model;
• rewrite your code: for migrating code you already have, a codemod is the right tool (How it compares);
• cover other languages yet: Python only, TypeScript is #1; and it names files, not lines (#8).

The full list is in Limitations.

The problem

Every model has a training cutoff; your lockfile keeps moving. When a library changes its public API after the cutoff, a model whose training data predates the change can keep writing the old calls. Some of that code fails at import or call time. Some still runs, because the old form is only deprecated, or still accepted with a warning.

A few of the changes since-cutoff scan finds for Claude Sonnet 4.5 (training cutoff July 2025) in the sample project, which pins six of its nine dependencies to current releases (for the other three, which are unpinned, the tool uses the latest release):

| library | release at the cutoff | pinned | what changed | |---|---|---|---| | anthropic | 0.60.0 | 1.8.0 | messages.create(temperature=..., top_p=..., top_k=...) is no longer accepted | | huggingface-hub | 0.34.3 | 2.0.0 | hf_hub_download(resume_download=..., force_filename=..., local_dir_use_symlinks=...) left the signature in 1.0 (2.0.0 still accepts them at run time, ignores them and warns) | | langchain-core | 0.3.72 | 1.6.5 | retriever.get_relevant_documents() and llm.predict() removed | | openai | 1.98.0 | 3.19.2 | 19 breaking changes, 6 new deprecations (+3 internal) |

In that project, 7 of 9 dependencies changed their public API after the cutoff. The static diff flags 257 breaking changes and 23 new deprecations in public APIs, and 71 changes to internal ones; the project's code uses 2 of the changed APIs.

It is not one model or one vendor. Across 36 widely used Python AI libraries and 21 models from OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, Moonshot and Mistral, even the newest model tested (Claude Opus 5.5, June 2026 cutoff) predates a