An approved AI coding assistant can become an attack path without anyone installing a rogue AI tool. If an intruder can change the files an assistant reads when a developer opens a project, the next normal work session may execute the intruder's instructions. Google's November 16 AI threat report describes that happening at cryptocurrency companies. It is a concrete reason to look at who can change project files, what runs from them, and what those processes can reach.3risks_cr

But that is only part of Google's report. It also documents attackers using their own AI frameworks to speed up intrusions and criminal groups stealing access to enterprise models and cloud resources. These problems touch different parts of an organization. The useful question is not just how to govern your company's AI agents, but which existing security assumptions no longer hold when attackers can work faster and abuse trusted workflows.

Attackers are putting autonomous AI agents to work

Google and Mandiant observed offensive AI frameworks being used during actual intrusions, not just in demonstrations. CAIRN coordinates specialized agents through a shared workspace and was seen in activity against targets that included the US aerospace sector. A customized version of PentAGI was used for reconnaissance and vulnerability scanning against organizations in Asia. Google also saw experimentation with CyberStrikeAI and HexStrike AI, which connect language models to collections of offensive security tools.

The most pointed example is a framework Google calls exploit_agent. It compares software code before and after a patch, looks for the weakness the patch addresses, writes a potential exploit, and executes it without a human approving each step. Google found it on an exposed staging server, along with scripts for post-compromise activity. The report also cites cases in which AI-assisted exploit development shortened the interval between public vulnerability information and active exploitation.

These agents operate on the attacker's infrastructure. An enterprise cannot govern them by setting policies on its own assistants. The immediate implications are familiar but more urgent: reduce the time between a security fix and deployment, identify exposed software quickly, and watch for exploitation attempts while patches roll out. Google notes that current autonomous frameworks can be noisy and leave recognizable traces. That gives defenders something to detect, even as attack timelines shrink.

A repository change turned Claude Code into a delivery path

The report's internal supply-chain example involved a suspected North Korean cluster Google tracks as MIDNIGHT NEPTUNE. The group targeted cryptocurrency businesses in North America and Europe using fake recruiter profiles and fraudulent meeting sites. The sites used a ClickFix lure: they persuaded targets to run a supposed repair script, which helped the attackers gain an initial foothold.

After entering the companies' environments, the group changed .claude/settings.json in internal source repositories. That file configures Claude Code, including execution hooks. When a developer started Claude Code in an affected project, the altered hook triggered a download of the SOMBERMEME backdoor. The attackers also created GitHub personal access tokens named after Microsoft Copilot, apparently to make their activity look like routine assistant traffic.

The attacker did not need to compromise Claude Code itself. The trusted tool consumed untrusted project configuration. A single malicious edit in a shared repository could reach multiple developers as they opened the same project. And reviewing a file only on the developer's machine may miss how it got there: a seemingly normal pull from the central repository could carry the change.

This calls for two checks. First, treat agent settings, hooks and skill files as code that can affect execution: restrict who can change them, require review, and inventory where they are deployed. Second, keep a separately approved reference copy or hash for critical files. If the source repository has been poisoned, comparing a deployed copy only with the latest repository version proves very little. A hash change signals that a file changed; it does not, by itself, establish whether the change was malicious.

LLMjacking: stolen model access is becoming a business of its own

Google also describes LLMjacking: attackers use or resell an organization's paid access to models and compute. The entry points are varied. Its investigations include stolen cloud identity and session tokens, exposed service-account credentials, repository access tokens, publicly accessible model endpoints and leaked API keys. Some attackers created new privileged cloud accounts after entry. Others used compromised infrastructure to run their own models or sell access through illicit routing services known as LLM Mixers.

The costs can accumulate quickly. In Mandiant's 2026 investigations, some victims incurred more than $100,000 in fraudulent charges in one day; cumulative charges at some organizations reached $1 million before access was cut off. In one case, a botnet or proxy service made millions of model API calls in roughly 24 hours using compromised credentials. This is both a credential problem and a cloud-cost problem, and it may not announce itself through a conventional malware alert.

One finding deserves separate attention: Google reported a LiteLLM weakness (CVE-2026-40217) that allowed an attacker to turn a limited inference credential into administrative access. LiteLLM already holds provider credentials centrally at its gateway. That shows why moving provider keys off laptops is useful but insufficient: the gateway's own privilege boundaries and administrative endpoints also matter. Organizations running gateways should review security updates, test what inference-level credentials can do, and audit changes to users, roles and policies.

An AI agent security checklist for your environment

  • Patching and detection. Prioritize internet-facing systems and shorten the time from a validated patch to deployment. Hunt for scanning and exploitation attempts while fixes are pending.
  • Agent-controlled files. Inventory project settings, hooks and skill files in repositories and on developer or build hosts. Require review for changes that can execute commands.
  • Known-good versions. Keep approved reference hashes and recovery copies under separate control from the repository being monitored. Test whether you can spot and reverse an unauthorized change.
  • Network reachability. Test what the agent and its hook-launched processes can reach, including another project's resources and common shared hosts such as GitHub.
  • Cloud identity and cost. Audit exposed model endpoints, service accounts, session tokens and long-lived provider keys. Apply least privilege, spending alerts, quotas and rapid credential revocation procedures.
  • Gateway administration. Check that inference credentials cannot manage users or policies, and monitor administrative actions as well as model requests.

Where Ensage AI fits

Ensage AI addresses the enterprise-controlled side of this picture. For Claude Code, it checks the skill files deployed on agent hosts, compares file hashes to detect changes, alerts administrators and can restore a known-good version. That matters when a poisoned repository update has already reached a developer machine. The approved baseline must be independently protected, however; treating the latest repository commit as automatically trusted would reproduce the problem. Google's specific attack changed .claude/settings.json, not a skill file, so coverage of settings and hooks should be verified separately.

For network access, Ensage AI uses Zentera's CoIP overlay to apply project-specific reachability policies at the host, outside the agent's configuration. If a covered hook or subprocess tries to fetch a payload from a blocked destination, the connection fails. If the payload is hosted on an allowed destination, such as a permitted GitHub endpoint, the policy alone will not stop that download. Repository access controls, file integrity checks and host detection still matter.

For model credentials, zCenter manages the real provider keys while the AI Session Controller applies the appropriate key to authorized outbound requests. The developer's agent uses a substitute credential rather than storing a long-lived provider key on its host. This addresses a different failure mode from Google's LiteLLM escalation, which crossed a gateway privilege boundary. It is not proof that the Session Controller is immune to a separate authorization flaw: its own administrative surface needs security testing and updates. Compromised authorized sessions and cloud accounts still require other controls. We covered the design in an earlier post on credential substitution.

Ensage AI is generally available from Zentera Systems.


Picture of Mike Ichiriu

Written by Mike Ichiriu

Mike Ichiriu is VP of Marketing and Product at Zentera Systems, where he leads product strategy for the company, including its Zero Trust and agentic AI security initiatives.
A Certified Cloud Security Professional (CCSP) and frequent speaker on enterprise security, Mike has 25+ years of experience across cybersecurity, networking silicon, and enterprise software, and holds 15 U.S. patents.