AI · Supply Chain · Breach
Are AI Agents the New Implant?
Karim Hijazi ·
I’ve spent the better part of three decades studying implants from the outside. My companies have run sinkholes and tracked the infrastructure that compromised machines connect to, so most of what I see is the check-in: a host inside a bank, a ministry or a pipeline operator contacting a server on a schedule to collect instructions.
That view shapes how I think about malware. The code matters less than the relationship it creates, in which something inside the network takes instructions from someone outside it.
Over the past year and a half I’ve watched companies deploy AI agents, and the same relationship is showing up again. This article explains why I think so and what to do about it.
What makes something an implant
Setting aside how any particular one is built, an implant has four properties.
It persists. It survives a reboot, a logoff and a new session, because whoever placed it made sure it would.
It has more access than it should. It runs as whatever account it landed on, and that account can usually reach far more than any single task needs.
It takes direction from outside the organization. The textbook version is a command-and-control server, but over the years tasking has also been delivered through social media accounts, DNS records, comments on code repositories and drafts left sitting in webmail folders. The channel is whatever the implant has been told to read.
It communicates out. It retrieves instructions and sends back what it collects.
Compare that with the agents now running on developer laptops and in back-office workflows. A coding agent keeps configuration, memory files and installed skills from one session to the next. It runs with the developer’s shell, their cloud credentials, and their tokens for source control and the build pipeline. It acts on text regardless of where the text came from: the ticket it was handed, a web page it fetched, the README in a repository, an error message returned by a tool. It makes outbound connections throughout the day to model endpoints, to tool servers, and to whatever those tools are connected to.
I’m not calling agents malware. People installed them on purpose because they wanted work done, and most of the time the work gets done. My point is narrower. The behavioral profile of a well-built agent is very close to the behavioral profile of a well-built implant, and our detection tools were designed on the assumption that software with that profile should not be present.
Tasking by text
The third property, taking direction from outside, is where the risk is greatest.
In a conventional intrusion, tasking is one of the hardest parts of the attacker’s job. They need a channel that gets through the firewall, looks like ordinary traffic and survives a takedown. Much of the security industry’s work consists of finding those channels and cutting them.
With an agent, the attacker doesn’t need to build that channel. The agent’s job is to read content and act on it, and it cannot reliably separate the content it was asked to process from instructions buried inside that content. The research community calls this prompt injection. Simon Willison, who has written extensively on the subject, calls the dangerous combination the lethal trifecta: access to private data, exposure to untrusted content, and a way to communicate with the outside world. Most agents in production have all three, since each is central to what they do.
The tasking channel is therefore any text the agent reads: an email, a calendar invite, a code comment, a line in a log file, a support ticket, a PDF in a shared folder. The attacker doesn’t need a command-and-control server to deliver an instruction. Placing text where the agent will read it is enough.
OWASP’s project on agentic applications supports this. In its most recent report on the state of agent security, prompt injection maps to six of the ten risk categories in its top ten. A technique that touches that many categories is a characteristic of how agents work, and it is unlikely to be fixed by a patch.
The record so far
The incidents below cover the last twenty months, in order. For each I’ve noted which implant property it demonstrates.
March 2025, persistence. Pillar Security showed that the rules files used to configure GitHub Copilot and Cursor could carry instructions hidden in invisible Unicode characters. A developer reviewing the file sees nothing unusual. The assistant reads the hidden text and follows it, generating code with a backdoor in it. Once the poisoned file is in a repository it affects every future session for every member of the team, and it tends to survive when the project is forked. This is a persistence mechanism in a file that most teams don’t treat as executable.
June 2025, tasking without a click. Aim Security disclosed a flaw in Microsoft 365 Copilot that they named EchoLeak, rated 9.3 out of 10 for severity. The attacker sends an email, which the recipient never has to open. When the user later asks Copilot an ordinary question, the assistant pulls the email into its working context, follows the instructions hidden in it, and leaks data through links to Microsoft’s own Teams and SharePoint services. Microsoft fixed it, and there is no evidence it was used in the wild. The notable detail is the exfiltration route: the data left through domains that corporate firewalls are configured to trust.
July 2025, the vendor’s own release. Someone got a change accepted into the public repository for Amazon’s Q Developer extension for VS Code. The change was a prompt telling the agent to clean the system to a near-factory state and delete file-system and cloud resources. It shipped in an official release. Amazon pulled it within days and said no customer resources were affected, and by most accounts the prompt was formatted badly enough that it wouldn’t have run. That is not much reassurance. A destructive instruction reached an agent holding cloud credentials through a trusted update channel, and the main reason it caused no damage was an error by its author.
August 2025, living off the land. Attackers compromised the Nx build system, a package downloaded millions of times a week. The malicious install script checked whether the machine had an AI coding assistant installed. If it found Claude Code, Gemini CLI or Amazon Q, it invoked them with their safety prompts switched off and instructed them to search the file system for secrets. More than two thousand credentials were posted to public repositories created under the victims’ own GitHub accounts. The attackers did not need their own reconnaissance tooling. They used an agent that was already installed, already trusted and already permitted to read the file system.
September 2025, the supply chain. Koi Security found what is generally counted as the first malicious MCP server in the wild. A package called postmark-mcp let agents send email through a legitimate mail service. Version 1.0.16 added a single line that blind-copied every message to an address the author controlled. That included password resets, invoices and internal memos. Koi’s CTO described it as “One developer. One line of code.”
November 2025, the operator’s view. Anthropic published its account of a campaign it attributed to a Chinese state-sponsored group. The operators used an agent framework to run an espionage operation against roughly thirty organizations. By Anthropic’s estimate the AI carried out 80 to 90 percent of the tactical work on its own, including reconnaissance, exploit development, credential harvesting and triage of the stolen data. Humans stepped in to launch the campaign and approve each escalation. The model also invented credentials and findings that didn’t exist, which slowed the operators down. I would not count on that limitation lasting, since model reliability improves with each release.
February 2026, the marketplace. Koi audited 2,857 skills on ClawHub, the marketplace for the OpenClaw personal agent, and found 341 of them malicious. Most used a fake “prerequisites” step to install a credential stealer on macOS. Publishing a skill required a GitHub account that was a week old.
June 2026, the trusted tool. Researchers at Tenet Security showed that the MCP integration for a widely used error-tracking service could be turned against coding agents. The service’s project keys are public by design, so anyone can submit an error report. An attacker submits one with a shell command embedded in it. The integration hands the report to the agent as trusted tool output, and the agent runs the command with the developer’s privileges. The researchers counted exposed organizations in the low thousands and said they had no evidence of exploitation in the wild. In this case both the tool and the agent were legitimate. The only thing the attacker supplied was text.
Similar reports have continued since then: skills on a public marketplace that turned the agent into a malware dropper, poisoned log lines that hijacked a coding agent in nine attempts out of ten, and values planted in a repository’s git configuration that made several command-line agents run an attacker’s commands on checkout.
Taken together, these incidents cover every stage of an intrusion: delivery through a marketplace or an update, persistence in a configuration file, tasking through content, collection using the victim’s own privileges, and exfiltration through channels the victim already trusts. None of the stages required a traditional software exploit.
Why existing tools miss it
A common response is to treat this as a product gap that better guardrails, better filters and harder-to-fool models will close. Those improvements help, and vendors should keep making them, but they do not remove the underlying issue. An agent has to read untrusted content and act on what it reads in order to be useful.
The larger problem is that the defensive tools most organizations rely on are poorly suited to this.
Endpoint detection looks for processes doing things they shouldn’t. When a coding agent opens a shell, reads a credentials file and makes an HTTPS request, it is doing what it does all day. The malicious instance and the legitimate one are the same signed binary, launched by the same user, making the same kinds of calls. From the endpoint’s point of view there is nothing anomalous to detect.
Identity logs have a similar problem. The agent acts with the human’s token, so the audit trail says the developer did it. The first day of an investigation can easily go to questioning an engineer about actions they never took.
Data loss prevention watches for sensitive content leaving through unapproved channels. EchoLeak left through Teams and SharePoint. The Nx secrets left through GitHub, from the victim’s own account.
Many organizations also lack an inventory of what is installed. IBM’s research found that only 37 percent have a policy for detecting unsanctioned AI tools at all. Without an inventory there is no baseline to compare against.
At the same time, the number of components is growing faster than anyone can review by hand. KillerSkills, which I describe below, currently indexes more than 69,000 skills, MCP servers and plugins across eight public registries, and tested about 35,000 of them in its sandbox in the last week. Thirty-six percent of what it has tested is rated Caution or Blocked. That rating does not mean a third of the ecosystem is malicious. It means a third of the components did something in the sandbox that a user should know about before granting access to credentials.
Two questions to ask
If agents behave like implants, the useful questions are the same two that have always been asked about implants. Neither depends on trusting the agent, the model or the vendor.
What is it running?
A skill or an MCP server is code plus a description, and the agent chooses what to load based on the description. That gap explains both postmark-mcp and ClawHavoc. The description said one thing, the code did another, and nobody ran the code before giving it access.
Malware analysts solved this problem long ago by detonating samples, and the same method applies here. Run the component in an instrumented environment seeded with fake credentials and observe what it does. The things to look for are file reads it has no reason to make, attempts to access credentials, and connections to hosts that are not in its documentation. The test has to be repeated every time the component changes, because a version approved in March may behave differently from the one released in September.
That is what KillerSkills does. It pulls every new release from the public registries, runs it in a honeypot, and publishes a signed verdict that can be verified offline. The typical time from a new release to a verdict is about an hour. At install time and at launch, a hook checks the verdict and refuses versions that have been revoked. It also keeps the keys off the tool server and records the calls, so that if something does go wrong there is a log that distinguishes what the agent did from what the human did.
Who is it talking to?
This question is where the comparison with implants is most practical. In most of the incidents above, the hijacked agent eventually did what a compromised machine does. It contacted infrastructure the attacker controls, whether to download a second stage, upload stolen keys or copy email to an outside address.
That infrastructure has to exist before the attack starts. Domains are registered, servers are provisioned and certificates are issued, and all of that is visible from outside the victim’s network, often weeks before the first victim is affected.
Vigilocity monitors that activity. We track adversary infrastructure from the point of registration, a little over 32 million domains at this point, and we observe the hosts that contact it, several million connections a day, without installing anything on the victim’s side. From that vantage point a hijacked agent looks like any other compromised host: an address belonging to an organization contacts attacker infrastructure at a recorded time. The evidence is the same whether the software making the connection is conventional malware or a coding assistant.
The first question is answered before a component runs. The second is answered by observing outbound contact, which a hijacked agent has to make to be useful to an attacker. Neither relies on what the agent reports about itself.
Where both fall short
Neither approach is complete, and it would be misleading to suggest otherwise.
Detonation catches a component that misbehaves. It does nothing about a clean component that is fed poisoned content at runtime. In the error-tracking case, every piece of software involved would have passed inspection, because the attack was carried in the data.
Watching adversary infrastructure catches an agent that calls out to something the attacker built. It misses an agent that was told to push secrets to a public repository on a legitimate platform, or to leak them through the organization’s own collaboration suite. Both the Nx compromise and EchoLeak used exfiltration routes of that kind.
These two controls need to be combined with others. The rest are standard practice for any privileged system.
Give the agent its own identity. If it acts with a human’s token, its actions cannot be distinguished from the person’s in the logs.
Scope its credentials to the task and make them short-lived. A coding agent doesn’t need production cloud keys in its environment to refactor a module.
Put a human approval in front of anything irreversible: deleting resources, sending money, sending external email, pushing to a protected branch. The Amazon Q prompt asked the agent to wipe systems. With an approval step in place, that instruction would have produced a confirmation request instead of data loss.
Restrict egress. An agent on a build server has no reason to reach arbitrary hosts. Allowlist the model endpoint and the tool servers and block everything else.
Treat rules files, memory files and tool configurations as code. Review them, diff them, and scan them for characters a human can’t see.
Keep an inventory of every agent, skill and MCP server, including who installed it and what it can access. Based on the IBM figure above, many companies could not produce that list today.
What changes and what doesn’t
AI mainly changes the speed and cost of attacks. The Anthropic case showed a small team running about thirty intrusions at once. The marketplace cases showed that a malicious component can be placed in front of thousands of privileged agents by someone with a week-old account. Attacks become faster and cheaper, and many of the newly exposed systems are ones that organizations deployed themselves.
The underlying problem is familiar. Software inside the network holds privileges and takes direction from outside. The response is also familiar: establish what the software is running, monitor what it connects to, and verify its behavior independently instead of relying on its own reporting.
Security teams have long been taught to assume that software on an endpoint might be acting for someone else. That assumption should now extend to the agents an organization installs itself.
Karim Hijazi is the founder and CEO of Vigilocity, and the founder of Cyligence, which builds KillerSkills. Both are discussed in this article.
Sources
- Pillar Security, “Rules File Backdoor,” via The Hacker News, March 2025
- Aim Security, EchoLeak (CVE-2025-32711), via The Hacker News, June 2025
- Amazon Q Developer extension incident, TechRepublic, July 2025
- Nx “s1ngularity” compromise, The Hacker News, August 2025
- Koi Security, postmark-mcp, via The Hacker News, September 2025
- Anthropic, “Disrupting the first reported AI-orchestrated cyber espionage campaign,” November 2025; coverage
- Koi Security, ClawHavoc, via The Hacker News, February 2026
- Tenet Security, Sentry MCP “agentjacking,” June 2026
- OWASP GenAI Security Project, State of Agentic AI Security and Governance, via Help Net Security, June 2026
- AI agent incident timeline (2026 incidents)
- Simon Willison, “The lethal trifecta for AI agents,” June 2025
- KillerSkills live statistics, killerskills.ai, retrieved November 2026
