Skip to main content
plugin CX Codex

since-cutoff — Claude Code plugin: what it does, how to install

since-cutoff finds Python dependency changes after your model's knowledge cutoff and records short rules in AGENTS.md to stop the assistant from generating outdated API calls.

MIT ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install since-cutoff@awesome-codex-plugins
Open on GitHub

What since-cutoff does

The tool spots differences between pinned Python dependencies in your project and the older releases present in your coding model's training data. Its scan command inspects the lockfile, statically compares each dependency's public interface from before the cutoff with your pinned release, and pinpoints where your code touches changed signatures.

Running sync writes short hints into AGENTS.md or CLAUDE.md. The status command, pre-commit hooks, and a GitHub Action keep these notes aligned with lockfile updates. Local operations require no model calls and consume no API tokens.

Python 3.10 or later is required. The tool skips legacy setup.py or setup.cfg files, so your project must use a lockfile such as uv.lock, poetry.lock, or requirements.txt. If you run the optional run command to evaluate model prompts, you must install basedpyright.

What it helps with

  • stop coding assistants from writing deprecated API calls
  • generate concise syntax reminders in AGENTS.md from API diffs
  • monitor dependency changes against model training cutoffs
  • verify whether assistants handle updated method signatures correctly

Example prompts for the agent

  • Run since-cutoff scan to detect breaking API changes across project dependencies
  • Sync updated dependency notes into AGENTS.md using since-cutoff sync
  • Check if project notes match the lockfile with since-cutoff status

How to install since-cutoff

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install since-cutoff@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about since-cutoff

How to install since-cutoff in Claude Code?

Run both commands in sequence: first add the catalog with /plugin marketplace add hashgraph-online/awesome-codex-plugins, then install the package with /plugin install since-cutoff@awesome-codex-plugins.

What does since-cutoff do?

It statically diffs pinned Python packages against releases available prior to your model's cutoff date. When differences surface, it documents the new signatures in AGENTS.md so the agent uses the right parameters.

Does since-cutoff require API keys to run scans?

No, scan, sync, and status operate entirely offline without LLM requests. Only the optional run command invokes the model and uses API credits.

Source text

since-cutoff · MIT
<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.

[![PyPI](https://img.shields.io/pypi/v/since-cutoff)](https://pypi.org/project/since-cutoff/)
![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)
[![CI](https://github.com/MohammadHijjawi97/since-cutoff/actions/workflows/ci.yml/badge.svg)](https://github.com/MohammadHijjawi97/since-cutoff/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/MohammadHijjawi97/since-cutoff/blob/main/LICENSE)
![Status: beta](https://img.shields.io/badge/status-beta-orange)
[![since-cutoff MCP server on Glama](https://glama.ai/mcp/servers/MohammadHijjawi97/since-cutoff/badges/score.svg)](https://glama.ai/mcp/servers/MohammadHijjawi97/since-cutoff)

**English** | [简体中文](https://github.com/MohammadHijjawi97/since-cutoff/blob/main/README.zh-CN.md) | [Español](https://github.com/MohammadHijjawi97/since-cutoff/blob/main/README.es.md) | [Français](https://github.com/MohammadHijjawi97/since-cutoff/blob/main/README.fr.md)

## Install

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

```bash
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](https://github.com/DetachHead/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](https://github.com/MohammadHijjawi97/since-cutoff#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](https://github.com/MohammadHijjawi97/since-cutoff#in-claude-code) and
[In other coding agents](https://github.com/MohammadHijjawi97/since-cutoff#in-other-coding-agents).
The [MCP server](https://github.com/MohammadHijjawi97/since-cutoff#use-it-from-any-agent-mcp)
gives any agent the same diff.

## Quick start

The [sample project](https://github.com/MohammadHijjawi97/since-cutoff/tree/main/examples/agent-app)
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):

```console
$ uvx since-cutoff scan --model anthropic:claude-sonnet-4-5
Your code uses 2 APIs that changed after 2025-07-01, 30 days before 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:

```markdown
**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 for the changes since 0.33.1. [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](https://github.com/MohammadHijjawi97/since-cutoff#keep-the-notes-current-sync-and-status)).

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

```bash
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`](https://github.com/MohammadHijjawi97/since-cutoff#measure-your-model)
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](https://github.com/MohammadHijjawi97/since-cutoff#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](https://github.com/MohammadHijjawi97/since-cutoff#how-it-compares));
- cover other languages yet: Python only, TypeScript is
  [#1](https://github.com/MohammadHijjawi97/since-cutoff/issues/1); and it names files, not
  lines ([#8](https://github.com/MohammadHijjawi97/since-cutoff/issues/8)).

The full list is in [Limitations](https://github.com/MohammadHijjawi97/since-cutoff#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](https://github.com/MohammadHijjawi97/since-cutoff/tree/main/examples/agent-app),
which pins six of its nine dependencies to current releases (for the other three, which are
unpinned, the tool uses the latest release):

| library | compared from | pinned | what changed |
|---|---|---|---|
| anthropic | 0.56.0 | 1.8.0 | `messages.create(temperature=..., top_p=..., top_k=...)` is no longer accepted |
| huggingface-hub | 0.33.1 | 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.67 | 1.6.5 | `retriever.get_relevant_documents()` and `llm.predict()` removed |
| openai | 1.93.0 | 3.19.2 | 24 breaking changes, 6 new deprecations (+5 internal) |

Each library is compared from its latest release published at least 30 days before the cutoff
(the scan's default margin), so a change can be from the last weeks before the cutoff. In that
project, 7 of 9 dependencies changed their public API since that release. The static diff flags
331 breaking changes and 24 new deprecations in public APIs, and 139 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 public API break in 20 of the 36
([full results](https://mohammadhijjawi97.github.io/since-cutoff/ai-stack.html)):

<p align="center"><picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MohammadHijjawi97/since-cutoff/main/docs/img/ai-stack-dark.svg">
  <img src="https://raw.githubusercontent.com/MohammadHijjawi97/since-cutoff/main/docs/img/ai-stack.svg" width="860" alt="Bar chart: for each of 21 models from 8 vendors, how many of 36 Python AI libraries broke their public API and how many are on a new major version since the model's training cutoff. From 21 of 36 for GPT-4o (13 of the libraries did not exist yet) to 33 of 36 for models with early-2025 cutoffs, and 20 of 36 for Claude Opus 5.5 (June 2026).">
</picture></p>

since-cutoff does three things about it:

1. **`scan`** finds, for each dependency, the newest release published at least 30 days before
   the model's training cutoff (by default),
   diffs its public API against the version you pin, and shows which of the changed APIs your
   code uses, where, and a note for each. No model calls, no API key.
2. **`sync`** writes those notes into a marked block in AGENTS.md (or CLAUDE.md) after showing
   you the diff, and keeps them in step with your lockfile; `sync --check` and `status` tell CI,
   pre-commit and your agent when they fall behind. Each note is stated from the API diff and
   tagged with what was checked. No model calls.
3. **`run`**, optional, asks the model short coding tasks that need the changed APIs, with no
   tools and no docs, and scores each answer with a type checker against *both* versions:
   stale, wrong, deprecated or correct. No LLM judges anything. For each failure it writes a
   note, keeps a model-written note only if its example type-checks against your version, and
   re-tests the model on held-out tasks without and with the notes.

The same diff is available to agents through an [MCP server](https://github.com/MohammadHijjawi97/since-cutoff#use-it-from-any-agent-mcp)
and to CI through a [GitHub Action and pre-commit hooks](https://github.com/MohammadHijjawi97/since-cutoff#use-in-ci).
The explainer below covers this section in 2½ minutes.

<!-- The video is attached to the v0.5.0 release only (release.yml uploads dist/* alone), so its URL names that release. -->
<p align="center"><a href="https://github.com/MohammadHijjawi97/since-cutoff/releases/download/v0.5.0/since-cutoff-explainer.mp4"><img src="https://raw.githubusercontent.com/MohammadHijjawi97/since-cutoff/main/docs/img/explainer-thumbnail.png" width="560" alt="Watch the 2½-minute explainer (video with voice-over)"></a><br><a href="https://github.com/MohammadHijjawi97/since-cutoff/releases/download/v0.5.0/since-cutoff-explainer.mp4">▶ Watch the 2½-minute explainer (video with voice-over)</a></p>

## Using it

```bash
# the changed APIs your code uses, with a note for each (no model calls, no API key)
uvx since-cutoff scan

# write those notes into AGENTS.md (shows the diff and asks first); run it again after upgrades
uvx since-cutoff sync

# optional: measure which of the changes your model gets wrong, and test the notes (calls it;
# --with adds the basedpyright type checker, which only run needs)
uvx --with basedpyright since-cutoff run
```

What `scan` prints for the sample project, in full:

<p align="center"><img src="https://raw.githubusercontent.com/MohammadHijjawi97/since-cutoff/main/docs/img/scan.svg" width="100%" alt="since-cutoff scan --model anthropic:claude-sonnet-4-5 on the sample project. Your code uses 2 APIs that changed after 2025-07-01, 30 days before claude-sonnet-4-5's training cutoff (2025-07-31). huggingface-hub 0.33.1 -> 2.0.0: hf_hub_download, used in app/main.py, no longer has force_filename, local_dir_use_symlinks, resume_download and proxies in its signature; its note is tagged [diff], and a Runtime line says that 2.0.0's source still handles them, so calls passing them may run with a warning. anthropic 0.56.0 -> 1.8.0: Messages.create, called in app/main.py, no longer accepts temperature, top_k and top_p; its note is tagged [diff]. 2 notes ready for AGENTS.md; what uses this API and [diff] mean; 348 more changes in 7 packages that the code does not use, and 139 changes to internal APIs."></p>

Both APIs are "uses this API"; a file that passed `resume_download=True` or `temperature=0.2`
would make them "old form". `scan -v` lists every file that uses an API (3 are shown), and
`scan --all` adds every other change to a public API, package by package (`--internal` adds
the changes to internal APIs, which every count gives apart as "+N internal"). `scan --json` and
`.since-cutoff/results.json` have the same in `used_apis` (each API, where it is used, its
changes and its note, with the note's tags, the versions it applies to and what was checked),
and `.since-cutoff/report.md` starts with "Used by your code".

### Keep the notes current: sync and status

`since-cutoff sync` (0.4.0 and later) writes the notes that `scan` shows into a marked block: in
AGENTS.md, or in CLAUDE.md when only that file exists, or in both when CLAUDE.md does not import
AGENTS.md, and where a block already is, into that one (`--target` names another file). It
prints a unified diff and asks
`Write this to AGENTS.md? [y/N]`; `--yes` writes without asking, and with no terminal to ask in
it writes nothing. Text outside the block keeps its bytes, CRLF line breaks included, and
`since-cutoff unapply` removes the block. The block for the sample project is in
[Quick start](https://github.com/MohammadHijjawi97/since-cutoff#quick-start). The Runtime caveat
stays out of the block: the advice ("do not pass them") is the same either way.

Run `sync` again after you change the lockfile or the code. It adds notes for APIs your code
starts using, checks a bumped package again, and drops a package's notes when it is no longer a
dependency, is no newer than the comparison release, or its changed APIs are no longer used,
and says why. It keeps the model and cutoff the block was written for (so that teammates whose
agents use other models do not rewrite it back and forth) unless you pass `--model` or
`--cutoff`; `--model a,b` uses the earliest of their cutoffs. When nothing changed it writes
nothing, and the file keeps its bytes and modification time.

| command | what it does | exit code |
|---|---|---|
| `since-cutoff sync` | shows the diff, asks, writes | 0 written or up to date; 3 not written (you said no, or there is no terminal to ask in) |
| `since-cutoff sync --yes` | writes without asking | 0 |
| `since-cutoff sync --dry-run` | shows the diff, writes nothing | 0 |
| `since-cutoff sync --check` | writes nothing (for CI and pre-commit) | 0 up to date; 3 out of date |
| `since-cutoff sync --json --yes` | writes without asking; prints JSON proposals and write results | same as `sync --yes` |
| `since-cutoff sync --json --check` | prints JSON proposals; writes nothing | 0 up to date; 3 out of date |
| `since-cutoff sync --json --dry-run` | prints JSON proposals; writes nothing | 0 |
| `since-cutoff status` | compares the block with the lockfile, offline | 0 current, or no block; 3 out of date; 1 broken markers |

When the block was edited by hand, `sync` and `sync --check` show the diff, write nothing and
exit with code 4; `sync --force` replaces it. When a package the notes are about cannot be
checked (PyPI unreachable, or sources the running Python cannot parse), `sync` writes nothing
and exits with code 1.

`sync --json` requires `--yes`, `--check` or `--dry-run`; without one it exits with code 2
without prompting. Stdout contains only JSON, and stays empty when sync fails (a usage error,
exit code 2, or an error such as PyPI being unreachable, exit code 1); progress, diffs and
errors go to stderr. The object contains `exit_code`, `tip` (what sync says about
AGENTS.md and CLAUDE.md, or null) and `targets`. Each target
reports `target`, `action`, `changed`, `edited`, `written`, `model`, `cutoff`, `scope`,
`notes`, `changes` (each package's `package`, `done` and `state`), `retest` and `diff_lines`.
`written` distinguishes an applied proposal from a preview or a refused hand edit. The usual
exit codes and `--force` behavior still apply.

`since-cutoff status` reads no network and no code: per package, the version the notes are for
and the version the lockfile has, whether other dependencies changed, and whether the model
your coding agent is set up with has an earlier training cutoff than the notes (with the
`sync --model` command for it). `status --json` is for scripts. `status --hook` prints one line
only when the notes are out of date and always exits with 0, for example:

```text
since-cutoff: the library notes in AGENTS.md are out of date: anthropic 1.8.0 in the notes, 0.60.0 in pyproject.toml. `since-cutoff sync` updates them.
```

More options:

- `sync --scope imported` also notes the changes most likely to matter in each changed package
  your code imports (up to 5 APIs per package), for code that uses none of the changed APIs yet.
  `scan` suggests it when that is the case.
- `sync --profile evaluated` is the configuration the benchmark measured: `--scope imported`
  with up to 5 APIs per package (the same as giving both flags). The default scope, `used`,
  notes only the changed APIs your code already calls, so it writes a block in fewer projects
  and a shorter one, but the benchmark did not test it. The notes' wording has changed since the
  release that was measured (0.4.1), and that release compared from the release at the cutoff:
  add `--cutoff-margin 0` to compare from the same day.
- `sync --header-only` writes only the header: the packages whose API changed since the release
  they are compared from, each with its pinned version and that release, and the instruction to
  follow them, with no change lines (`--no-header-only` writes them again). It is the block of the
  benchmark's header-only arm: shorter (about 250 tokens with one package, against 285 to 505
  for the full blocks), and it tells the agent which packages to check, but not what changed
  or what to use instead. Without `--scope`, a new header lists the packages your code imports.
- `sync --suggestions` adds the names in the pinned version that merely look similar to what was
  removed, tagged `[not confirmed]`. The block records these choices (the scope, the APIs per
  package, the header only, the suggestions), and later syncs keep them.
- Notes that `since-cutoff run --apply` wrote are tagged `[type-checked]`. `sync` keeps each one,
  in place of the note from the diff for the same API, while its package keeps the same version
  and your code still uses that API.

Claude Code reads CLAUDE.md, and reads AGENTS.md only when there is no CLAUDE.md or when
CLAUDE.md imports it with a line `@AGENTS.md`
([memory docs](https://code.claude.com/docs/en/memory)); Codex, Cursor and Copilot read AGENTS.md;
Gemini CLI reads GEMINI.md, and AGENTS.md only when `context.fileName` in its settings.json lists
it (`"context": {"fileName": ["AGENTS.md", "GEMINI.md"]}`; [GEMINI.md
docs](https://github.com/google-gemini/gemini-cli/blob/main/docs/cli/gemini-md.md)). With both
files and no block yet, the notes go to AGENTS.md alone when CLAUDE.md imports it, and to both
files when it does not ([#13](https://github.com/MohammadHijjawi97/since-cutoff/issues/13));
`scan`, `sync` and `status` then say how to keep one copy: add the line `@AGENTS.md` to CLAUDE.md
and run `since-cutoff unapply --target CLAUDE.md`. A block already in AGENTS.md alone stays there,
and they say so when CLAUDE.md does not import it. When both files have a block and CLAUDE.md then
imports AGENTS.md, they say CLAUDE.md holds a second copy, with the same `unapply` command. An
`@AGENTS.md` in a code span or a fenced block is not an import.

### Measure your model

`since-cutoff run` is the optional step that calls a model. It asks the model short tasks that
need the changed APIs, with no tools, no docs and none of your code; scores the answers with a
type checker against both versions; writes a note for each failure; and tests the notes on
held-out tasks ([How it works](https://github.com/MohammadHijjawi97/since-cutoff#how-it-works)).
It uses your API credits or Claude Code usage and can take 5-20 minutes.

```bash
since-cutoff run --quick    # a smaller run: 12 probes, 1 held-out task, 3 regression checks
since-cutoff run --apply    # write this run's notes into the block
```

Without `--apply` the notes are shown, not written. `run --apply` replaces the block with that
run's notes; a later `since-cutoff sync` adds the notes from the diff for the other changed APIs
your code uses, and keeps the run's `[type-checked]` notes while their package's version stays
the same.

### In Claude Code

```text
/plugin marketplace add MohammadHijjawi97/since-cutoff
/plugin install since-cutoff@since-cutoff
```

Then ask Claude to "check which of our dependencies you are out of date on", or run
`/since-cutoff:since-cutoff`. The skill runs `since-cutoff scan` and offers the notes: it runs
`since-cutoff sync --dry-run`, shows you the diff and writes only when you agree. When you ask
it to measure the model, the measuring is done by a fresh, tool-less copy of the model, so the
agent cannot grade itself. The plugin also starts the
[MCP server](https://github.com/MohammadHijjawi97/since-cutoff#use-it-from-any-agent-mcp), so
Claude can look up a library's changes before it writes code, and (0.4.0 and later) runs
`since-cutoff status --hook` when a session starts, which adds one line to the session when the
notes are out of date (the first time, uvx downloads since-cutoff).

### In other coding agents

```bash
npx skills add MohammadHijjawi97/since-cutoff
```

This installs the same skill through the open [skills](https://github.com/vercel-labs/skills)
CLI for Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and other agents that read
`SKILL.md`. since-cutoff reads the model from the Codex, Gemini CLI, OpenCode and Aider settings
too; for other agents, tell it which model to use, for example
`since-cutoff scan --model openai:gpt-5.4`.
Add the MCP server as shown below.

Prompts that work well:

- "Which APIs that our code uses changed after your training cutoff?" The agent runs
  `since-cutoff scan` or calls the MCP tool `project_changes`.
- "Add notes about them to AGENTS.md." The agent runs `since-cutoff sync --dry-run`, shows you
  the diff, and runs `since-cutoff sync --yes` when you agree.
- "Measure which of those changes you actually get wrong." The agent asks you first, then runs
  `since-cutoff run --quick`.
- "Before you write the httpx code, check what changed in httpx since your cutoff." The agent
  calls the MCP tool `api_changes`.

### Choosing the model

| `--model` | uses | needs |
|---|---|---|
| `claude-code` (default when no setting names a model) | your Claude Code login (subscription or key), current model | the `claude` CLI |
| `claude-code:sonnet`, `claude-code:claude-haiku-4-5` | a specific Claude model | the `claude` CLI |
| `anthropic:<model>` | Anthropic API | `ANTHROPIC_API_KEY` |
| `openai:<model>` | OpenAI API | `OPENAI_API_KEY` |
| `openrouter:<vendor/model>` | OpenRouter | `OPENROUTER_API_KEY` |
| `deepseek:<model>` | DeepSeek API | `DEEPSEEK_API_KEY` |
| `ollama:<model>` | local Ollama | Ollama running |
| `openai-compatible:<model>` | any OpenAI-compatible server | `--base-url`, optional `OPENAI_API_KEY` |

The "needs" column is for `run`, which calls the model; `scan` and `sync` use only its training
cutoff. Without `--model`, since-cutoff 0.3.0 and later use the model your coding agent is set up
with, and the model line says where it came from ("model from .claude/settings.json"):

1. `SINCE_CUTOFF_MODEL` (a full spec such as `openai:gpt-5.4`) always wins.
2. Inside Claude Code (which sets `CLAUDECODE=1` for the commands it runs), only Claude Code's
   settings count: `ANTHROPIC_MODEL`, then the project's `.claude/settings.local.json` and
   `.claude/settings.json`, then `~/.claude/settings.json`.
3. Elsewhere the most specific setting wins: first `ANTHROPIC_MODEL`, `GEMINI_MODEL` or
   `AIDER_MODEL`, then the project settings, nearest folder first, from the scanned folder up to
   the repository root (never the home folder), then the user settings. In one folder the agents
   count in this order:

| agent | project settings | user settings |
|---|---|---|
| Claude Code | `.claude/settings.local.json`, `.claude/settings.json` | `~/.claude/settings.json` |
| Codex | `.codex/config.toml`, with its selected profile | `$CODEX_HOME/config.toml` or `~/.codex/config.toml` |
| Gemini CLI | `.gemini/settings.json` | `~/.gemini/settings.json` |
| OpenCode | `opencode.json`, `opencode.jsonc` | `~/.config/opencode/` |
| Aider | `.aider.conf.yml`, with Aider's aliases (`4o`, `flash`, `r1`, ...) | `~/.aider.conf.yml` |

When no setting names a model, it uses Claude Code's default model and says so. Only the model
fields are read, and a model name it cannot place stops the run with a message naming the
setting. A model that an agent reaches through another service (GitHub Copilot, Amazon Bedrock,
Vertex AI) is named after its maker, so `run` calls the maker's API (`openai:` needs
`OPENAI_API_KEY`). `sync` keeps the model a block was written for, whatever your agent uses now.

Training cutoffs come from [models.dev](https://models.dev) (a snapshot is bundled for offline
use). `since-cutoff models sonnet` lists them (`--makers` leaves out gateways and resellers,
`--json` is for scripts). A model that several providers list takes the cutoff of the
requested provider's listing (`opencode:glm-5.1`), else of its maker's, else the e...

© Mohammad Hijjawi · MIT · hashgraph-online/awesome-codex-plugins

Similar plugins

All plugins for Agent setup: memory, context, orchestration →

From the same set391

The whole set →
spec-driven spec-driven turns a feature idea into requirements, design and tasks, then lets the agent build them. CX Codex ★ 1,596repo stars sno-station-standalone The sno-station-standalone plugin for Claude Code and Codex reviews code, audits intent, and generates tests locally without accounts or external hooks. CX Codex ★ 1,596repo stars skill-sync-publisher skill-sync-publisher is a plugin for Claude Code and Codex that checks a local SKILL.md package and syncs it with GitHub and skill directories. It publishes one version to several registries. CX Codex ★ 1,596repo stars skill-skill skill-skill writes agent skills that change what gets generated, then lints SKILL.md against the Agent Skills spec and scores its health from 0 to 100. CX Codex ★ 1,596repo stars simple-man The simple-man plugin cuts praise, recaps, and filler from agent replies while preserving actionable details. Use it when coding responses need less noise. CX Codex ★ 1,596repo stars sealos Deploys applications to Sealos Cloud directly from an agent, configuring databases, storage, and HTTPS with readiness checks. CX Codex ★ 1,596repo stars runtype-skills A skill bundle for building and operating AI products on Runtype, covering platform work, agent tools, Persona widgets, templates, and SDK workflows. CX Codex ★ 1,596repo stars roadmapsmith roadmapsmith keeps ROADMAP.md honest: one command writes it, the other proposes edits backed by real code and waits for your ok. CX Codex ★ 1,596repo stars

Project sponsors

Companies that keep this analytics open