← All guides · Published November 14, 2026 · Reviewed November 14, 2026 · By the Ingenious AI team · 6 min read

How Do You Verify a Block Kit Is Genuine and Unchanged?

The short answer: every policy the generator builds is stamped with a kit ID and a kit hash computed from its contents — the blocked and allowed lists, allowlist, path rules, rate caps and database version. The verifier at /verify-kit recomputes the check against a supplied or cookie-held policy and reports whether the kit is genuine, unchanged and current. Team adds bulk verification for up to 100 kits at once, which is how agencies prove a whole estate in one pass.

Build my block kit — free · Test a policy in the simulator first

What is a kit hash?

a fingerprint computed over an AgentBlock policy's contents at generation time, stored beside its kit ID in the policy itself. Because the hash covers the blocked/allowed lists, allowlist, path rules, rate caps and database version, any later edit to the kit changes the fingerprint — which is what the verifier detects.

Three questions, one check

Owners actually ask three different questions about a deployed kit, usually in one breath. Is it ours — generated from a real policy, not hand-assembled by a departed contractor? Is it unchanged — the artifact in production byte-identical in effect to the policy on record? And is it current — built from a database version the world still recognises? A kit hash answers the first two cryptographically and the third by the version it embeds; the verifier is the tool that asks all three in one submission.

Without the hash, each question degrades into archaeology: reading a Worker script line by line, diffing a plugin file against a memory. Archaeology does not scale past one site and does not survive staff changes. A fingerprint does both.

How kits drift from policies

The edit during an incident, made directly in the Cloudflare dashboard at midnight and never back-ported. The plugin file tweaked by a developer who meant to regenerate and forgot. The hosting migration that restored an older artifact from backup. None of these are negligence; they are the ordinary entropy of production systems, and each leaves the policy record describing a kit that no longer exists.

Verification converts that entropy into a detectable event. Run the verifier after any incident, migration or contractor session, and the answer is arithmetic: the deployed contents hash to the recorded fingerprint, or they do not. When they do not, the policy diff shows what changed, and the decision — adopt the edit into the policy, or regenerate clean — is made deliberately for once.

Bulk verification and the estate view

Single-site owners verify occasionally; agencies hold a portfolio problem. A policy change, a database update or a platform migration raises the same question across every client kit at once, and checking them one page at a time is how verification quietly stops happening. Team's bulk endpoint takes up to 100 kit policies in one call and returns a verdict per kit — genuine, changed or stale, in a list an operator can work through.

That list is the estate view crawler control needs to be a managed service rather than a per-site craft: one regeneration wave, one bulk verification, one exceptions list. The exceptions are the work; everything else is confirmed by arithmetic.

What verification cannot say

A verified kit proves the artifact matches the policy. It says nothing about whether the policy is wise — a faithfully deployed bad decision verifies perfectly. Nor does it prove the artifact is actually receiving traffic: a verified Worker on a route that no longer points at your domain is genuine, unchanged and irrelevant, which is why verification pairs with evidence (are events arriving?) and the stale check (is the world still the one the policy describes?). Three cheap checks, three different failure classes, no overlap wasted.

Keep the trio on one calendar line. Owners who run them together quarterly almost never appear in these guides' incident stories; owners who run none of them eventually star in one.

Five actions to take today

  1. Record kit ID and hash at deploy. They are the policy's fingerprint; file them with the policy note and date.
  2. Verify after incidents and migrations. Any emergency edit or restore is a drift suspect until the hash says otherwise.
  3. Diff before you judge a mismatch. Use the policy diff to see what changed; adopt deliberate edits into the policy, regenerate accidents away.
  4. Bulk-verify estates after waves. On Team, run the up-to-100 bulk check after any fleet-wide regeneration and work only the exceptions.
  5. Pair with evidence and stale checks. Genuine, current and actually receiving traffic are three facts; verify all three quarterly.

Worked example: the midnight edit the hash caught

During a traffic incident, a contractor for Bluefin Outfitters, a fictional outdoor retailer, edited its live Worker directly to allow an agent he believed was choking a partner integration. The incident ended; the edit stayed; the policy record did not learn about it. The agent he allowed was a retrieval name — harmless-looking, and wrong for the retailer's substitution-sensitive buying guides.

The quarterly verification flagged the kit: hash mismatch. The policy diff isolated the single flipped decision in under a minute, and the review could have the real conversation — was the exception ever justified? — with the edit in front of them instead of discovering it through a citation anomaly.

The exception was revoked, the kit regenerated, the new hash filed. Total cost of the episode: one quarterly check and fifteen minutes. The counterfactual — an unrecorded exception persisting into a data-partner audit — is the expensive version the hash exists to prevent.

Frequently asked questions

Where do I find my kit's ID and hash?

Inside the policy itself: the generator stamps kit_id and kit_hash into every policy it builds, and they travel with the generated artifacts. The verifier accepts a pasted policy or works from your current builder policy if the kit was built in this browser.

What exactly does the hash cover?

The policy's operative contents: the blocked and allowed agent lists, the allowlist, the path rules, the rate caps and the database version. Edit any of them in a deployed artifact and the fingerprint changes — which is the detection property the verifier relies on.

What should I do when verification fails?

Diff first. The policy diff shows what the deployed kit does that the record does not expect. If the change was deliberate, adopt it into the policy properly and regenerate; if it was entropy, regenerate clean and re-verify. Never leave a known mismatch unfiled — note the decision and the date.

How many kits can bulk verification check?

Up to 100 kits in one call on Team, returning a verdict per kit. It is designed for the estate workflow: regenerate a wave, bulk-verify, and work only the exceptions list rather than touring every site by hand.

Does a verified kit mean my policy is good?

It means your policy is what is deployed — genuine and unchanged. Quality is a separate question answered by the impact preview's numbers and your review. Verification is about truth of installation, which has to come first: a wise policy wrongly installed protects nothing.

Build my block kit — free · Browse the agent database

Related guides

HONEST SCOPE: this policy blocks KNOWN agent user-agents and behaviors listed below. Sophisticated spoofing can bypass any user-agent block (e.g. an agent sending a stock browser UA, or rotating residential IPs). This is a control, not a guarantee.
← Back