When Code Assistants Look Like Intruders
For a full week, Sophos watched its own endpoint detection logs and found something surprising. AI coding agents — tools like Claude Code, Cursor, and OpenAI Codex — kept setting off rules written to catch human attackers.
These agents aren’t malicious. They just behave in ways that, to a behavioral detection engine, look nearly identical to an active breach.
The specific actions that raised flags? Decrypting browser-stored credentials. Listing everything inside Windows’ credential manager. These are classic reconnaissance moves. But in this case, the actor was a developer’s assistant, not a hacker.
Why Behavioral Detection Gets Confused
Endpoint detection and response (EDR) systems rely on behavioral patterns. They don’t just scan for known malware signatures — they watch how software acts. When a process reaches into a browser’s password vault or queries the Windows Credential Store, the engine assumes an attacker is gathering loot.
That assumption is usually correct. But AI coding agents increasingly need access to those same resources to function. Claude Code, for instance, might decrypt credentials to authenticate with a cloud service during deployment. Cursor can invoke shell commands that touch sensitive OS APIs. Codex agents run code that reads configuration files containing secrets.
From the security tool’s perspective, the behavior is indistinguishable from a post-exploitation toolkit. The result: a flood of false positives that security teams must triage.
The Data Behind the Discovery
Sophos didn’t release the raw numbers from that week-long sample, but the pattern was consistent enough to warrant a public warning. The company noted that the alerts weren’t one-offs. They recurred across different agent types and different developer environments.
This isn’t a bug in the agents or the security tools. It’s a fundamental collision between two legitimate functions: the need for developer tools to access sensitive data, and the need for security tools to flag exactly that kind of access.
What This Means for Security Teams
If you run a security operations center, here’s the practical problem: your alert queue just got noisier. Every AI-assisted developer on your network could be generating alerts that look like a credential theft campaign.
- Triage overhead: Analysts now have to distinguish between a real attacker dumping credentials and Claude Code doing its job.
- Policy gaps: Most organizations haven’t written policies that explicitly allow or block AI agents from accessing credential stores.
- Tool tuning: EDR rules may need exceptions or lower severity levels for processes signed by known AI agent vendors — but that’s a whack-a-mole approach.
One immediate fix: security teams should inventory which AI coding agents are in use, then create allowlists or behavioral exceptions for their specific process signatures. That’s not a permanent solution, but it cuts the noise while the industry figures out a better approach.
The Bigger Picture: Trust and Transparency
This discovery points to a deeper issue. AI agents are increasingly granted broad system access — file systems, credential stores, network sockets — because developers need them to be useful. But those permissions are exactly what attackers want.
The agents themselves are not the threat. The threat is that their operational patterns overlap with malicious behavior so closely that detection becomes unreliable. Over time, security tools that can’t distinguish between a helpful AI and a hacker will either generate unbearable alert fatigue or be tuned so broadly that real attacks slip through.
Some vendors are already working on solutions. Behavioral models that recognize AI agent activity as a separate class of behavior — not attacker, not benign user — could help. So could cryptographic attestation, where the agent proves its identity and intent to the security tool before performing sensitive operations.
But those solutions aren’t here yet. For now, the burden falls on security teams to adapt their detection rules and on developers to understand that their productivity tools are setting off alarms.
What Developers Can Do Right Now
If you’re using Claude Code, Cursor, or Codex agents in your daily work, a few practical steps can reduce the friction:
- Run agents in isolated environments — containers or VMs where their credential access doesn’t trigger network-wide alerts.
- Use dedicated service accounts with scoped permissions instead of letting the agent inherit your full developer credentials.
- Communicate with your security team about which tools you use. A heads-up prevents a late-night alert review.
None of this means you should stop using AI coding agents. They’re powerful tools. But pretending they don’t interact with sensitive system resources is naive. The smarter path is acknowledging the friction and working around it.
The Road Ahead for Endpoint Security
Sophos’s week of data is a snapshot, but the trend is clear. As AI coding agents become more common, the collision with endpoint security will only intensify. Security tools will need to evolve — learning to recognize AI agent behavior as a distinct category, not a false positive to be suppressed or a threat to be blocked.
Until then, expect more alerts. More false alarms. And more conversations between developers and security teams about what an AI agent is allowed to touch.
The agents aren’t attackers. But they’re forcing everyone to rethink what an attack looks like.