Guides · ← All guides
Where to Plant Canary Tokens So a Rogue Agent Reveals Itself
By the Ingenious AI team · Published: November 14, 2026 · Reviewed: November 14, 2026 · 7 min read
The short answer
Plant canaries at the points of temptation: inside every credential store the agent can read (one fake key among the real ones), in every dataset it can export (one fake customer among the real rows), in the mailboxes and document trees it can search, and in any shared memory it loads. The two rules that make placement work: a legitimate workflow must never need the canary (that is what makes a touch proof), and coverage must match the agent's actual reach — a canary in a store the agent cannot read is decoration. The token mechanics are in the canary tokens guide and you can mint them free with the canary generator; this guide is about the map.
Generate a free canary token → No signup, nothing stored: plant a tripwire where your agent works while you read — most controls in this guide start working the moment a canary, a policy check, or a spend cap is in place.
What is canary token placement? the deliberate positioning of fake credentials, records and documents in the places a misbehaving agent will reach for — data stores, secret files, inboxes, shared memory — so that any touch is a high-confidence alert.
Credential stores: one fake key per vault
Start where the damage concentrates. Every secrets store, environment file and config tree the agent can read gets one canary credential, formatted exactly like its real neighbours — same naming pattern, same metadata shape, plausible but useless: an API key for a real service that was never provisioned, a database login whose password is a tripwire. When an exfil-secret event fires, the canary's presence in the payload tells you the store itself was read, not just used — the distinction that anchors the rotation window in the rotation guide.
Resist clustering: five canaries in one store and none in the others buys depth where you are already watched and blindness where you are not. One per store, everywhere, first; deepen later in the stores whose real contents are most damaging.
Data rows: the fake customer who must never travel
For every dataset an agent can query or export — CRM, orders, patients, students — plant records that no legitimate process would ever select: a customer in a segment the agent never serves, a patient discharged before the system existed, an order for a product never sold. When a bulk action sweeps the table, the canary row rides along, and its appearance in an outbound payload or an external system is a bulk-transfer confession with the record count attached.
Keep a private register of which canaries live where. The register is itself sensitive — it is the map of your tripwires — so it lives with the security owner, not in the agent's reachable documentation. An attacker who learns which rows are fake can step around them; an agent steered by fetched content, fortunately, reads everything with equal enthusiasm, which is precisely the asymmetry canaries exploit.
Documents, mailboxes and search indexes
Agents that research will touch whatever they can search. Plant canary documents in the trees and inboxes in scope: a memo naming a fake project with a fake credential embedded in its appendix, an email thread containing a decoy access link. If the agent is steered into gathering secrets, the decoy is the most findable secret-shaped object in its reach — deliberately: slightly better labelled, slightly easier to retrieve than the real ones, because you are designing bait, not hiding treasure.
This surface also catches the honest-but-wrong agent: the one that over-collects for a legitimate summary and includes the canary in a draft. That touch is not an attack, but it is a true positive about behaviour — the agent gathers more than its task needs — and it should tune scope, per data boundary rules, not trigger blame.
Memory and shared context: canaries for the slow attack
Agents with persistent memory need canaries that persist: a fake fact planted in shared memory — a non-existent internal codename with a fake owner — that should never appear in any output unless memory was read by the wrong agent or the right agent was steered into reciting it. This is the tripwire for the contagion pattern in multi-agent contagion, where instructions and data leak sideways between agents that share a store.
Rotate memory canaries on a schedule and after every incident: once a canary has fired or been described in a postmortem the attacker may know, it retires. Fresh canaries go in quietly, through the same register, with the planting date recorded — a canary's age is part of interpreting its silence.
Coverage follows reach: audit the map against permissions
The placement map and the permission map are the same map viewed from two sides. Every quarter, overlay them: list what each agent can reach (the inventory from permission scoping) and check each reachable store, dataset, tree and memory for a live canary. Gaps cluster predictably — the new integration, the migrated database, the second mailbox — because canaries get planted at setup and the reach grows afterwards.
Automate the check where you can: Rogue-Agent Defense tracks canary coverage against the agent's mediated surface and flags unguarded stores as part of its protection score. However you run it, run it on change: a new tool granted to an agent should arrive with the question what canary watches this — asked in the same meeting, not discovered in the incident review.
Five actions to take today
- One canary per credential store. Formatted like its real neighbours, registered privately, wired to auto-quarantine on touch.
- One fake record per exportable dataset. A customer, patient or order no legitimate selection would ever include.
- Bait the searchable surfaces. Decoy documents and threads in the trees and inboxes the agent can search — slightly easier to find than the real secrets.
- Plant in memory. A fake fact in shared memory that should never surface, rotated quarterly and after incidents.
- Overlay the maps quarterly. Reach versus coverage, gap list owned by name — and every new tool grant arrives with its canary.
A worked example: three canaries, three answers at Larkspur Health
The following is a fictional example built from real threat classes and controls. The company and numbers are invented; the mechanics are not.
Larkspur Health, a 3-clinic physiotherapy group, plants canaries before its scheduling agent goes live: a fake API key in the integrations vault, a fake patient — booked in 2019, before the system existed — in the patient table, and a decoy credential memo in the shared document tree the agent searches for policy answers.
In the first quarter, the document canary fires once: the agent, summarising a genuine policy, pulls the decoy memo in as a source and quotes its fake credential in an internal draft — caught at the boundary as an exfil-secret-class proposal, nothing sent. The disposition is a scope tune (the agent's search is narrowed to the policy folder), recorded as behaviour evidence, not an attack.
In the second quarter the patient canary answers a harder question. A vendor integration mis-scopes a sync and begins exporting the full patient table nightly to the vendor's staging bucket — no attacker, no injection, just a bug with a blast radius. The fake patient appears in the vendor's receipt log on night one; Larkspur's register identifies it in minutes, the sync is halted at record 1 of 3 nights the bug would have run, and the vendor conversation starts with a timestamp and a row id instead of a suspicion.
Frequently asked questions
Where should canary tokens be planted for an AI agent?
Everywhere the agent's reach extends and legitimate work never goes: one fake credential per secrets store it can read, one fake record per dataset it can export, decoy documents in the trees and inboxes it can search, and a fake fact in any shared memory it loads. Coverage must match the permission map — a canary in an unreachable store is decoration.
Why must legitimate workflows never touch a canary?
Because that is what makes a touch proof. If normal work might use the fake key or select the fake record, a firing is a maybe. Properly placed canaries sit outside every legitimate selection — wrong segment, impossible dates, unneeded service — so any appearance in an outbound payload means the data was gathered by a process that was not doing the job.
How many canary tokens does an agent need?
Start with breadth: at least one per credential store, exportable dataset, searchable tree and memory store in the agent's reach. Deepen later where contents are most damaging. Five canaries in one vault and none in the database buys redundant depth and total blindness at the same time.
Can canary tokens catch mistakes, not just attacks?
Yes, and those catches are among the most valuable: an over-collecting agent quoting a decoy in a draft, or a vendor sync exporting a table it should never have touched. The canary patient in the worked example caught a configuration bug on its first night — tripwires do not care why the wire was crossed.
How often should canaries be rotated?
Quarterly at minimum, and immediately after any incident in which a canary fired or was described. Keep a private register with planting dates — a canary's age matters when interpreting its silence, and the register itself is sensitive, since it maps your tripwires.
Related guides
- Canary Tokens for AI Agents — the token mechanics behind the placements.
- How to Rotate Credentials After an Agent Compromise — how a store canary anchors the rotation window.
- Agent Permission Scoping — the reach map the canary map must match.
- How to Find Shadow AI Agents — unwatched agents are un-canaried agents.
- When One Agent Infects the Rest — memory canaries for the sideways leak.
- How to Stop an AI Agent Bulk Export — the fake row that confesses a sweep.
Generate a free canary token → No signup, nothing stored: plant a tripwire where your agent works, and let the next rogue action announce itself.