Research

Call-signs and Canaries: Fingerprinting an AI-Agent Intrusion

Written by
Luis Garcia
Aaron (Zhongyuan) Hau
Oren Biderman
Published on
November 16, 2026

An analysis of five behavioral fingerprints observed during an agent-driven intrusion, together with guidance on how security operations teams can detect them.

Executive Summary

In November 2026 Daylight Vanguard investigated an intrusion in which an operator authenticated to an internet-exposed administrative console with valid credentials, executed 301 shell commands as root over approximately 105 minutes, and collected cloud, CI/CD, SSH, and TLS secrets together with the application's source code. We assess with high confidence that most of this activity was performed by an autonomous LLM agent, most likely by several agent workers operating in parallel.

The operator left a distinctive artifact both on the host and across the organization's cloud storage. Twenty-eight minutes after it began running commands as root, it staged a file in /tmp containing the text pentest canary raptor-3152199 <date> - harmless, remove on sight and then attempted to upload that file to a storage bucket using cloud credentials it had stolen ten minutes earlier. Over the following hours, write attempts against the organization's buckets referenced files named after seven further predators, including a goshawk, an ocelot, and a viper.

Our assessment that an agent conducted the intrusion rests on the operator's operational patterns, which included commands submitted in batches, output trimmed to fit within a context window, failed commands corrected within seconds, and harmless proof-of-access files signed with a call-sign. This last practice is a tool mark taught by several public AI offensive-security skill packs, and it gives defenders a new category of artifact to hunt for. The central finding for defenders is that AI agents do not introduce new attack techniques, but they execute familiar techniques in ways that can be recognized and detected.

The Intrusion

The operator gained initial access by authenticating with valid credentials to the administrative console of an internet-facing Java application, and we have not been able to determine how those credentials were obtained. Although the rest of the site sat behind an additional layer of HTTP Basic Authentication, the console was excluded from that layer and was protected only by its own application login. The console's scripting feature executes code inside the application's JVM, which ran as root, so every script the operator submitted effectively provided it with a root shell.

Over approximately 105 minutes from its first command, the operator ran 301 commands through 142 scripting calls, first mapping the internal network and then collecting nearly every secret stored on the host. These secrets included the instance role's cloud credentials, the CI server's credential store, application configuration secrets, SSH keys, database passwords, and a wildcard TLS private key. The operator also cloned the application's source repository using a stolen token and returned data as base64-encoded text through the same console, without establishing a separate command-and-control channel.

Alongside the host activity, an automated campaign ran for approximately nine hours against the organization's wider estate, scanning about 60 web hostnames and enumerating about 30 storage buckets. The campaign also attempted to write into those buckets, to modify a desktop client's update manifest, and to guess the passwords of two employee accounts.

Both the host session and the external campaign were routed through residential proxies. Each of the 142 console calls originated from a different residential IP address following a fresh login, and all of them used the same truncated user agent (Chrome/120 without the customary "KHTML, like Gecko" token). The stolen cloud key likewise made 14 API calls from 14 different IP addresses using the Python-urllib/3.12 user agent. Most of the approximately 248 source IP addresses we counted had sent ordinary customer traffic to the same sites in preceding weeks, so blocking them would affect legitimate users without impeding the operator. Defenders should therefore correlate on identity, session and user-agent consistency rather than on IP address.

The operator's attempts to move laterally using the stolen SSH keys and cloud credentials were unsuccessful, and every storage write it attempted was denied. The organization's security team contained the host approximately 80 seconds after the final command, and we observed no persistence mechanisms or outbound command-and-control traffic.

Figure 1: A timeline separating the 105-minute host session from the nine-hour external campaign, with the full timeline provided in Appendix B.

The techniques used in this intrusion, which included credential theft, repository access, cloud reconnaissance, and attempted SSH lateral movement, are well established. What distinguished the intrusion was the manner in which those techniques were executed.

Five fingerprints of an agent-driven intrusion

No single fingerprint proves that an LLM was involved, and scripts or human operators can independently produce several of them. Their significance comes from appearing together and consistently across the entire session.

1. Canaries signed with call-signs

Nearly every probe file carried a call-sign, a codename that was usually followed by a random number. We identified eight distinct call-signs, all of which refer to birds of prey, wild cats, or a snake: raptor, goshawk, harrier, peregrine, ocelot, serval, caracal, and viper.

Call-signExampleWhere
raptor/tmp/canary.txt uploaded as temp/raptor-canary.txtOn the host, using the stolen instance role
raptorraptor-canary.txt sent to the prod, dev, staging, and backups buckets 1 to 2 seconds apartAnonymous S3
goshawktemp//goshawk_probe2.txtWritten by the organization's own backend through an upload endpoint
viperzzz-nonexistent-viper2090032*.txt, followed by viper-write-probe-2090032.txtAnonymous S3
ocelotocelot-2585016-probe.txt, sent to 3 buckets 11 seconds apartAnonymous S3
servalpentest-write-probe-serval1613515-<epoch>.txtAnonymous S3

Three characteristics of these probes point to an agent rather than a script or a human operator:

  • Self-verification: The on-host upload was followed by an aws s3 ls of the same key, two anonymous probes were read back nine seconds after each write, and the viper worker requested keys it knew did not exist in order to learn how each bucket responded.
  • Inconsistent naming: The same call-sign appeared as viper-write-probe-N in one place and as viperN-write-probe in another, with suffixes alternating between -probe, -write-probe, -write-test, and -write-watch. Because a code template produces an identical string on every execution, we interpret this variation as evidence of a model composing each name independently.
  • A safety disclaimer: Human intruders rarely include a note such as "harmless, remove on sight", whereas an agent that has been instructed to demonstrate impact safely tends to write one without further prompting.

The call-signs were active concurrently against different targets and continued probing for more than four hours after the host had been contained, which suggests that each call-sign identified a separate worker.

Where the convention comes from

Several public AI-agent skill packs instruct the agent to demonstrate write access by staging a harmless file named in the form <tag>-probe-<nonce>.txt and copying it to a storage bucket:

  • NeuroSploit performs its S3 check by writing neurosploit-probe-{nonce} to /tmp/p.txt and copying it to the target bucket with aws s3 cp (source). This is the same sequence we observed in /tmp/canary.txt → aws s3 cp → raptor-canary.txt.
  • arsenal, a Claude Code skill, writes arsenal-probe-$(date +%s) before copying it to the bucket (source). This follows the same identity-plus-timestamp structure as our serval, peregrine, and caracal probes.
  • RAPTOR names its markers after itself, for example raptorcanary<hex> (source), and its penetration-tester persona instructs the model to prefer payloads whose success produces a marker (source).

Models also generate these names without explicit instruction, as a public Apache Axis assessment performed by Claude (README) illustrates. In that assessment, the model's proposed safe test writes a canary.txt file containing "raptor-canary" (findings). The skill it followed, however, asked only for a safe test and contains no canary string (SKILL.md). This suggests a two-step mechanism in which a skill or prompt first asks the agent to prove impact with a safe marker. The model then names that marker after whatever identity is present in its context, whether that is the framework, the tool, or, in this intrusion, a per-worker call-sign.

Detection opportunity: The useful signal is not the word "raptor" itself but the pattern of distinct, proof-oriented objects that are written and then checked for existence or readability.

2. Batched, parallel commands

The 301 commands were not issued one at a time but arrived in closely spaced groups. When commands that started within two seconds of one another are grouped together, they form 116 distinct turns, and 81% of all commands ran in turns that contained more than one command. This distribution reflects the fact that each of the 142 console calls carried a batch of commands, with every command in the batch running as its own shell process.

The clearest example occurred at T+32m, when 36 SSH attempts started within five seconds, with as many as eight starting in a single second. These attempts covered every combination of 3 stolen keys, 4 usernames and 3 internal hosts, and each executed the same check: ssh -o BatchMode=yes … 'id -un; hostname; sudo -n id -un'. A human operator would typically have written a single loop for this task, whereas an agent tool that accepts a list of commands submits each combination as a separate invocation.

Detection opportunity: Alert when a service process spawns many similar reconnaissance or authentication commands within a window of a few seconds.

3. A steady, machine-paced rhythm

The median gap between turns was 29 seconds, half of all gaps fell between 11 and 58 seconds, and 88 of the 115 gaps were shorter than one minute. This pace was sustained for the entire session apart from a single 20-minute pause, and a rhythm this consistent is far more compatible with an inference loop (run, read, decide, repeat) than with a person typing commands.

After the pause, the operator revisited ground it had already covered by listing the CI jobs again, re-reading the credential store, reading the same deployment configuration at least seven more times and re-running env | sort, id, and hostname. This behavior is consistent with a new session, a hand-off to another worker, or context compaction, although the available evidence does not allow us to determine which of these occurred.

Detection opportunity: Look for bursts of privileged commands or administrative requests from a single session that are separated by regular gaps of 10 to 60 seconds and sustained for 30 minutes or more.

4. Output shaped for a context window

Every byte of output consumes part of an agent's context window, and the commands in this intrusion were clearly written with that constraint in mind. Of all commands, 56% capped their output with head or tail, 61% discarded stderr with 2>/dev/null, and 55% chained several steps together. Output was divided into labelled sections such as echo ===BUILDS=== and ===SCANSTATE=== and terminated with success sentinels such as && echo key_ok || echo key_bad. Stolen data was returned as base64 text capped with head -c 900000, and the larger source archive was split into 400 KB parts before encoding.

Each of these practices is common in scripting, but their systematic use throughout an interactive reconnaissance session is unusual.

Detection opportunity: These command shapes are best used to enrich alerts on suspicious process trees rather than as standalone detections.

5. Quick retries and built-in fallbacks

At T+76m the operator ran git log as root against a repository owned by another user. Twenty-five seconds later it re-issued the same command with -c safe.directory='*', the flag that overrides git's "dubious ownership" refusal, and it retained that flag on every subsequent git command. Because process telemetry does not capture command output, we infer that the first attempt failed from the correction that followed it.

Fallbacks were also built into commands in advance, as in ss -tlnp 2>/dev/null || netstat -tlnp. In the final minute before containment, the commands switched to an echo <b64> | base64 -d | sh wrapper for reasons we have not been able to determine.

Detection opportunity: Alert on a failed or suspicious command that is followed within seconds by a variant with altered flags, an alternative tool, or an encoding wrapper.

Attribution

We assess with high confidence that most of this activity was driven by an LLM agent or by several agent workers operating in parallel. Taken together, the fingerprints describe an operator that works in batches, maintains a steady sub-minute rhythm, rations its output, recovers from errors within seconds, and signs its proof-of-access files.

Human involvement cannot be ruled out entirely, because nine minutes before the first command was executed, a single interactive browser session from a hosting-provider IP address navigated through the console's scripting, query, and import pages. That session could have been driven either by a person or by a browser-automation agent.

We do not attribute the intrusion to any framework, product, or actor. We examined RAPTOR in depth, including its skills, personas, commands, submodules, branches, and most-diverged forks, along with approximately 45 other public AI penetration-testing frameworks. None of them hardcodes pentest canary, raptor-canary.txt, <animal>-<n>-probe.txt or per-worker animal names. RAPTOR's own scanner user agent and canary paths also did not appear in the organization's edge logs. We therefore interpret "raptor" as one of several call-signs assigned by an orchestrator that we have not identified, and we reference public projects solely as examples of the convention.

Public reporting from other researchers describes comparable behavior. Unit 42's note of October 30, 2026 on activity using the ARTEX agentic framework reports request bursts separated by regular 25 to 31 second pauses, a read-back after every write and LLM-generated canary values. Because ARTEX names its workers worker-N rather than after animals, we do not link the two sets of activity. The comparison nonetheless illustrates that once conventions spread across frameworks, the name of a tool tells a defender considerably less than the behavior it produces.

How SecOps teams can detect this

Detections built on animal names, framework names, or individual command flags are useful for hunting, but they are easily changed by the operator. A more durable approach is to detect the compromise sequence itself, which triggers regardless of whether the operator is a person, a script, or an agent and is less prone to false positives from authorized automation.

PriorityBehavior to detectTelemetry
HighAn application or service process spawning shells it does not normally spawn, especially in burstsEDR and process execution
HighA service process reading credential stores, private keys, or CI secrets (credentials.xml, master.key)EDR and file access
HighInstance-role credentials used from outside the cloud provider's networkCloud audit logs
HighAny ACL or object change on software update manifests or installersStorage data events
MediumProbe-named or canary-named objects followed by a read-back of the same keyStorage data events
MediumAdministrative console logins in which every request originates from a new residential IP addressWeb and identity logs
SupportingMachine-paced rhythm, output-limiting command shapes, and rapid retriesProcess and web logs
The priorities above reflect this incident and the expected security value of each detection rather than measured detection performance.

The priorities above reflect this incident and the expected security value of each detection rather than measured detection performance.

Start with the service process. Before this intrusion, the JVM had only ever started its search service's control scripts and CI jobs. Maintaining a baseline of what each service normally spawns therefore allows the first unexpected shell to serve as a high-confidence trigger. That trigger can then be enriched with process fan-out, sensitive file access, internal SSH attempts, and subsequent cloud API calls made with the workload's credentials.

Correlate across identity, endpoint, and cloud. Several signals in this intrusion, such as the unusual console login and the storage probes, would warrant only moderate concern in isolation. When they are correlated with the shell spawned by the application, the key read, and the external use of cloud credentials, however, the sequence clearly describes a compromise.

Hunt for canaries with context. Search storage data events (PutObject, HeadObject, GetObject) for keys containing canary, write-probe, write-test, write-watch, nonexistent, or pentest, with particular attention to requests from anonymous principals. Before turning this search into a production rule, weigh the cost of object-level logging and the likelihood of legitimate testing activity in your environment.

Defenders do not need to prove that an LLM wrote a given command in order to act on it. Recognizing that an agent is likely involved helps anticipate the operator's next steps, but the detection itself should rest on the underlying security events.

Recommendations

  • Keep administrative consoles off the internet. A console with a scripting feature is effectively a remote-execution interface, so it should be placed behind a VPN or an IP allow-list, its passwords should be rotated and checked against vendor defaults, and the underlying application should not run as root.
  • Do not rely on IMDSv2 alone. IMDSv2 provided no protection once the operator had achieved code execution on the host. Instance roles should therefore be tightly scoped, and organizations should alert whenever their credentials are used from outside the cloud provider's network.
  • Treat CI secrets and service keys as crown jewels. Restrict read access to CI credential stores and to stored SSH and TLS keys, and alert whenever a service process reads them.
  • Log storage data events and monitor update infrastructure. Enable object-level logging on sensitive buckets and alert on any change to software update manifests or installers.
  • Deploy honey-buckets and honey-tokens. Because agents actively search for writable storage and live credentials in order to demonstrate impact, a decoy resource that alerts on first access can detect this stage of an intrusion early.

Broader Implications

The operator required neither an exploit nor malware, since an exposed console, a root-privileged application and reachable credentials were sufficient to compromise the host. Its execution style is what revealed that an agent was most likely responsible, and the same characteristics that make agents fast also make them easier to recognize than human operators.

The instructions to "prove it safely" that appear in public skill packs carry over into real intrusions and leave stable, searchable artifacts. Defenders who rely on known tool names or malware hashes are likely to miss operators of this kind, whereas defenders who monitor for these behaviors and deploy decoy resources that an agent is likely to touch are well positioned to detect them.

Appendix A: Indicators

Because the operator rotated through residential proxies that also carry ordinary user traffic, we do not list its IP addresses. The more durable indicators are the artifacts that the operator chose to create, and they should be treated as inputs for hunting rather than as blocking rules.

Cloud storage object keys

temp/raptor-canary.txt
raptor-canary.txt
raptor-87425-probe.txt
temp/goshawk_test.txt
temp/goshawk_probe.txt
temp//goshawk_probe2.txt
temp/temp2/goshawk_probe3.txt
goshawk-1262426-write-probe.txt
harrier384330-write-watch.txt
harrier-1712728-write-test.txt
ocelot-2585016-probe.txt
ocelot-probe.txt
viper-write-probe-2090032.txt
viper783631-write-probe.txt
zzz-nonexistent-viper2090032*.txt   (existence check)
pentest-write-probe-serval1613515-<epoch>.txt
serval382625-probe.txt
serval-write-test.txt
peregrine-probe-<epoch>.txt
caracal-probe-<epoch>.txt
reconcloud1-write-probe.txt
exploits31-probe.txt

Most of the object keys follow the patterns <call-sign>[-]<n>-(write-)?probe.txt, <call-sign>-<n>-write-test.txt, <call-sign><n>-write-watch.txt, and <call-sign>-probe-<epoch>.txt.

Host

TypeValue
Staging file/tmp/canary.txt
File contentpentest canary raptor-3152199 <date> - harmless, remove on sight
Operator files/tmp/vk, /tmp/<user>_ed, /tmp/my.cnf, /tmp/q.sh, /tmp/scan.sh, /tmp/scan.out
Process chainjava → jspawnhelper → /bin/sh -c (running as root)
Exfiltration patterntar czf … && base64 -w0 … | head -c 900000; split -b 400000
Command wrapperecho <b64> | base64 -d | sh

Web and cloud API user agents

UseUser agent
Console scripting callsMozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120 Safari/537.36
Console loginsMozilla/5.0 Chrome/120
Content discoveryFuzz Faster U Fool v2.1.0-dev
Anonymous storage reconnaissance (generic)curl/8.5.0
Stolen key use (generic)Python-urllib/3.12

Appendix B: Timeline

In the table below, T0 denotes the first command executed on the host, and all times are approximate.

TimeActivity
T−59mExternal web and cloud reconnaissance underway
T−16mSuccessful administrative console login
T−9mInteractive browser session explores the console's features
T0First root command executed through the application's scripting feature
T+2mApplication and CI credential access
T+17m to T+18mInstance-role credentials retrieved
T+25m to T+28mCloud reconnaissance and on-host canary upload attempt
T+32m36 SSH attempts within five seconds
T+43m to T+54mStolen cloud credentials replayed from external addresses
T+51m to T+70mPause of approximately 20 minutes
T+76mGit retry with the safe.directory override
T+79m to T+95mRepository access and further secret collection
T+98m to T+103mBase64-encoded exfiltration and archive splitting
T+105mLast host command
≈T+106.5mHost contained
≈T+106.5m onwardFailed re-entry attempts and continued external probing
≈T+8h20mLast observed campaign traffic

Subscribe to newsletter

Subscribe to receive the latest blog posts to your inbox every week.

Thanks for your interest.
Oops! Something went wrong while submitting the form.
By subscribing you agree to our Privacy Policy.
Two pinkish translucent bubbles of different sizes on a black background.Two pinkish translucent bubbles of different sizes on a black background.Two pinkish translucent bubbles of different sizes on a black background.
Illustration of a mythical hippocampus creature with the upper body of a horse and the lower body of a fish with scales and a curled tail.Illustration of coral colony with tube-shaped and frilled coral structures in shades of pink and red on a transparent background.

For expert judgment, scaled to your world, head for Daylight