← All guides · Published November 14, 2026 · Reviewed November 14, 2026 · By the Ingenious AI team · 6 min read
How Do You Know If Your Block Kit Has Gone Stale?
The short answer: your kit tells you: every policy records the database version it was built from, and AgentBlock's stale check at /tools/stale-check compares that version against the current database (v2026-10-18) and shows the diff — what the world added, renamed or re-graded since your kit was built. The WordPress plugin even runs a stale-kit cron check on its own. Staleness is not a failure; ignoring it is, because a kit frozen in October governs a crawler population that has already changed.
Build my block kit — free · Test a policy in the simulator first
What is a stale kit?
an AgentBlock kit whose recorded database version is older than the current agent database. The stale check quantifies the gap as a database diff, and the remedy is regeneration — with a signed policy file kept so the previous kit can be restored exactly if the refresh misbehaves.
Why kits age even when untouched
A deployed kit is a snapshot of two moving targets. The agent population moves: vendors launch agents (three of the database's 25 entries arrived in a single October 2026 wave), publish user-agents for previously watch-class agents, retire tokens and correct documentation. The evidence moves with it: a reported token gets published, a note is revised, a vendor's IP ranges shift. Your kit, faithfully enforcing October's world, diverges from November's reality without a single thing breaking — staleness is drift in the world, not in your artifact.
That distinction changes the remedy. Artifact drift is fixed by the verifier; world drift is fixed by regeneration, and the decision it demands is not 'restore' but 'review': the diff shows what changed, and a human decides whether the new entries alter any decisions before the fresh kit ships.
Reading a database diff
The stale check returns the comparison in decision-sized pieces: new verified entries (new names your policy has no decision for — they will inherit class defaults on regeneration, which deserve a glance), re-graded entries (a reported token promoted, a watch agent named), and revised notes that change what an existing entry means. Most diffs are small. The dangerous ones are small too — a single new training crawler is a single line in a diff and a complete hole in a block-all-training posture.
Treat the diff like a changelog for a dependency you actually depend on, because that is what the agent database is: a dependency with versions, consumed by your edge. Software teams would never run a year-old dependency without reading its changelog; crawler policy deserves the same professionalism, and the stale check is the changelog rendered for owners.
The plugin that checks itself
The generated WordPress plugin carries a stale-kit cron check: on its own schedule it compares the kit it enforces against the current database and flags staleness in its admin surface. Self-checking artifacts matter because the most common staleness story is not refusal — it is forgetfulness on a site nobody logs into. A plugin that raises its hand converts a calendar discipline into a system property.
Worker deployments rely on the hosted stale check instead, which is an argument for putting the check on the same quarterly line as the verifier and the enforcement-gap audit: three checks, one sitting, covering artifact truth, world truth and layer agreement.
Rollback: the signed way back
Regeneration is safe to schedule because it is reversible by design. Before refreshing, export the current policy as a signed policy file (a Pro feature): the signature lets the import path verify the file is genuine, and importing it restores the exact previous policy — decisions, caps, fences, allowlist — which the stale tooling can then diff against the new one. A refresh that misbehaves is therefore a five-minute restore, not an archaeology project.
Keep the signed export with the kit hash it supersedes. The pair — old signed policy, new kit hash, diff between them — is the complete audit record of a refresh, and producing it should be as routine as the refresh itself.
Five actions to take today
- Run the stale check quarterly. Compare your kit's database version against the current one and read the diff before deciding anything.
- Review new entries as decisions. New verified agents inherit class defaults on regeneration — confirm those defaults are your actual choices for them.
- Export a signed policy before refreshing. The signed file is your exact way back; keep it with the superseded kit hash.
- Let the plugin nag you. On WordPress, heed the stale-kit cron flag in admin; self-checking only works if someone reads the flag.
- Regenerate, verify, file the diff. Fresh kit, hash check, and the old-versus-new diff stored as the refresh's audit record.
Worked example: the October wave a stale check caught
When AgentBlock's database shipped v2026-10-18, it absorbed a remarkable month: Meta's crawler family documentation, the Muse and Grok watch entries, ChatGPT Atlas — three watch entries and a restructured Meta picture in a single version. Kits built on the previous version had no representation of any of it.
One early adopter, the fictional Fern & Field garden retailer, ran its stale check the week the version landed. The diff showed 6 entries new or materially revised. Two changed live decisions: a Meta training entry it wanted blocked under its class posture, and a watch entry its policy note needed to acknowledge as unblockable-by-name.
The refresh took one sitting — signed export of the old policy, regenerate, verify, file the diff. The retailer's total exposure window to a changed crawler world was nine days, bounded entirely by how fast it ran a check that takes a minute.
Frequently asked questions
How does a kit know it is stale?
The policy records its database version at generation. The stale check compares that recorded version against the current database and reports the database diff between them — agents added, re-graded or revised since your snapshot of the world was taken.
Does a stale kit stop working?
No — it keeps enforcing its snapshot faithfully, which is precisely the risk. The world changes underneath a working kit: new agents have no decisions, re-graded tokens keep old treatment. Staleness is a correctness gap, not an outage, so only the check surfaces it.
What is a signed policy file?
A Pro export of your policy with a signature the import path can verify. It makes rollback trustworthy: the file you restore from is provably the policy you exported, unedited in between. The stale tooling uses it to restore and to diff old against new.
How often do database versions change?
Whenever the agent world changes materially — a launch wave, a vendor publishing new documentation, an evidence re-grade. October 2026 produced a version in a single month. That cadence is why the check exists as a tool rather than a newsletter you might miss.
Is the WordPress stale check automatic?
The generated plugin includes a stale-kit cron check that flags staleness in its admin surface on a schedule. It cannot regenerate for you — decisions deserve a human glance at the diff — but it removes forgetfulness from the list of ways a kit stays old.
Related guides
- How to Block AI Scrapers and Bots from Your Website
- Which AI Crawlers Should You Allow?
- How Do You Block AI Bots on WordPress, Cloudflare, or Plain JS?
- Pre-deploy breakage simulator — test a policy before it ships
- Impact preview — your server log against a draft policy
- What AI Crawler Policy Should an Ecommerce Store Run?
- How Should a News Publisher Handle AI Crawlers: Citations vs Training?
- What Crawler Policy Should a SaaS Documentation Site Run?
- How Should a Creator or Portfolio Site Handle AI Crawlers?
- Incident: What Happens When a Block Rule Breaks Your Link Previews?
- Block evidence — parse a log, build an evidence pack
- The dated agent database — 25 entries, graded