Watch a secret move between AI clients.

A tool for anyone running a website. It gives every bot that visits its own secret link, so that when a different bot comes asking for that link, you have a dated record of it instead of a hunch.

Two access-log records. The upper one is the page request that issued a secret to context A; the lower one is context B fetching that secret, with the 16-character secret marked inside the requested URL.
The actual product. The marked run of characters is the secret, in the request line of the context that fetched it; the record above is the page request that issued it. Seeded replay data, labelled as seeded on its own face.

In plain terms

THE PROBLEM

You cannot tell which bots are connected

Automated clients hit your site all day. Sometimes they are related: one finds something, another turns up for it. You have no way to know. Every identifier a client shows you — its user-agent, its address — is one the client chose, so comparing them is guesswork. And when you are sure, you have nothing to show anyone else.

WHAT THIS DOES

It plants something only one of them was shown

Each automated visitor is served a unique link that nobody else is ever given. If a different one later asks for that exact link, that is written down: two access-log lines, the same secret string in both, with the time between them. Nothing is guessed, and nothing is blocked.

WHAT YOU GET

A file that holds up without you

The records are hashed into a bundle. Anyone you hand it to can check it in their own browser, offline, with your server switched off — so they do not have to take your word for any of it. That is the whole point of the thing.

Who it is for: someone running a site or a public API who has been asked to show what happened, not just block it. What it will not do: tell you that two clients are two people. It cannot, and it says so on its own face — see the limits.

Why guessing from what clients look like is failing

“did get rate-limited (‘please stop rinsing my site’) and continued rinsing the API with requests regardless” … he cannot tell “whether it’s the same swarm, let alone the same agents”. Operator of the UNCTADstat API, September 2026

Cloudflare documented an undeclared crawler reaching robots.txt-blocked, newly purchased, unindexed domains at 3–6m requests a day — while presenting a desktop Chrome user-agent and rotating ASNs. Every identifier a client shows you is one the client chose. So stop reading identifiers, and plant something instead.

How it works

Three steps. The middle one is the only interesting one.

01 — MINT

Each visitor gets its own secret

An automated request is issued a canary URL derived as HMAC(salt, path | request-context). A human is never minted for and never enters the ledger.

02 — SIGHT

Someone else asks for it

The canary returns 200 for anyone — a 404 would tell the second client it was a trap. A fetch by a context other than the one it was issued to is written as a sighting, with both raw log records.

03 — PROVE

The record outlives the server

Rows are hashed into a Merkle-rooted bundle. A reader recomputes it offline. No server, no network, no trust in us.

A table titled ‘What separates the two request contexts’, with user-agent and network marked ‘differs’ and first-seen shown as matching.
The claim is that these two contexts differ, so the interface shows the difference rather than asking you to compare two identical-looking cards.

Try it

Four ways in, shortest first. Each one shows you something different, and none of the first three needs anything installed.

0 MIN · WATCH

The 110-second video

The whole thing end to end: a secret issued to one client and fetched by another, verified offline, and then the page is lied to and catches it.

1 MIN · IN YOUR BROWSER

Open the evidence and try to break it

Press Recompute the hashes locally and watch your network panel stay empty. Then open the page's own data.js, change any record or any number on screen, and press it again. It names what no longer matches.

2 MIN · ON YOUR MACHINE

Run it yourself

A clone and three commands, no credentials, no network after the install. Then open viewer/index.html from disk, with nothing running.

git clone https://github.com/itssaharsh/canary-maze && cd canary-maze
pip install -r requirements.txt
make verify     # five properties, each able to fail
make demo       # builds the offline viewer

5 min · read — what it found on the organizers' own corpus and on the public dump, with the two claims we withdrew: docs/RESULTS.md. The code is at github.com/itssaharsh/canary-maze.

Check this without trusting us

This is the part that makes it evidence rather than a dashboard. The verifier is stdlib Python. It makes no network call and does not need the server running — it would still work if this site were taken down permanently.

$ make verify

Canary Maze :: verify
  sightings before -> after                            0 -> 1  OK
  gate turned a browser away, stored nothing           turned away 1, in ledger 0  OK
  bundle verifies offline                              OK
  an edited row is caught and named                    OK
  laundered rows cannot reach the bundle               byte-identical  OK
PASS
The viewer's verification strip: ‘Verified. The server was not contacted.’ with the number of hashes recomputed, the Merkle root, and a note that what the page displays is what the bundle commits to.
Recomputed in your browser with crypto.subtle, from the bundle file alone. Edit any record — or any counter the page displays — and it names what no longer matches.

What is real here

Every number below is generated from the artefact this page links to — the seeded replay, which is the deterministic demo a judge can reproduce offline. It observes nobody, so its organic count is 0 by construction. The live public surface is reported separately, and generated the same way, in docs/RESULTS.md.

Secrets issued1to automated contexts, through the real gate and mint
Sightings in this replay1two clients we control, driven through the real gate, mint and detector
Organic sightings here00 by construction: a scripted replay observes nobody
Human requests stored0must be 0 — a non-zero value would mean a human reached storage
Hashes in the bundle5each one recomputed in your browser by the button above
Tests254make verify PASS

What a sighting does not establish

The most important section, and it is on the product’s own face too.

  • It is not two operators. One operator can rotate addresses: A sighting establishes that the secret moved between two request contexts. It does not establish that they are two different operators - one operator can rotate addresses. In the organizers' collusion.wiki dump, the busiest named agent label wrote 317 revisions from 308 distinct addresses. The schema has no actor table and no join that would produce one.
  • The HMAC bounds provenance, not distinctness. A secret that verifies was issued by us and cannot be forged. That says nothing about how many actors touched it. An earlier draft of this project claimed otherwise; that claim was false and is recorded as false so it cannot return.
  • Two clients can touch one secret without having talked — one may have followed the other through the same link graph. The bundle records a shared artifact, not intent.
  • Tokens can be stripped. A public tool detects canary tokens without triggering them. A motivated client defeats this.
  • The prior art is close. arXiv:2605.13706 already mints per visitor and keeps the ledger. What is new here is the sighting channel and the offline bundle, not the minting.
  • “Without trusting us” is narrower than it sounds. The operator computes the rows, the leaves and the root. The bundle proves nothing has been edited since it was built; it does not prove it was built honestly. Publishing the root somewhere we do not control would close that, and this build does not.
  • A client can manufacture a second context against itself by changing its user-agent, or by adding or dropping one of the standard request headers the context id looks at. (Adding an arbitrary header, or reordering them, no longer does it — that was a real defect, and it is recorded as F-0006.) The diff above makes the attempt visible, because the network would read as matching, but nothing refuses the record.
  • No organic sighting yet. Third-party fetchers have reached the live surface and been recorded — but only ones the operator handed a URL to, so every one of them is reported as paste-triggered and none is counted as organic. The operator publishing a URL is itself a row in the ledger, written before the URL is handed over, which is what makes that separation checkable rather than asserted.
  • The ledger records what an edge reported. The public surface runs on a host that does not refuse crawlers; the ledger is on the operator's machine, and the two are joined by a signed hand-off. Every row names the edge that reported it, and a row this process saw itself is marked differently from one it was told about.