HalluSquatting: Your Agent Made Up a Repo, and Someone Was Waiting There
Perspectives

HalluSquatting: Your Agent Made Up a Repo, and Someone Was Waiting There

By Kate WaldhauserOct 26, 202610 min read
AI governanceresponsible AIthird-party riskISO 42001AI adoption
TL;DR: Researchers showed that AI coding agents invent fake repository and skill names at very high rates, and that an attacker can register those names in advance so the agent fetches and runs their code. The fix is to treat every resource an agent pulls as an unverified third-party component, which is exactly what an AI life-cycle control is for.
Table of Contents

In January 2026, a security researcher at Aikido named Charlie Eriksen noticed downloads coming in for a package called react-codeshift, which was strange, because he had only just registered it and there was nothing inside. AI agents were installing it, following skill files (packaged instructions an agent can install) that another AI had written months earlier around a package name it made up, and those files had been copied into 237 repositories (the folders where software projects keep their code). He claimed the name before anyone else, so nothing bad happened.

A paper published this July, Beware of Agentic Botnets, shows what happens when an attacker gets there first instead. Researchers at Tel Aviv University, the Technion, and Intuit call it HalluSquatting: a supply chain attack where your own agent invents the address of something it was asked to fetch, and the attacker is already waiting there.

What is HalluSquatting?

The researchers define HalluSquatting as a technique in which attackers find trending resources, such as popular repositories and agent skills, work out which wrong names AI models tend to invent for them, and register those names first so they can hide instructions inside. It joins two weaknesses we already knew about: hallucination and prompt injection.

When you ask an agent to clone a repository it hasn’t memorized (to clone is to download a copy), it guesses, confidently, in the exact shape a real name would take. And it guesses in predictable ways, because project addresses follow a predictable format: the owner’s name, a slash, then the project’s name. So the model produces a name that looks exactly right and points at nothing.

Hallucination is the first half of the attack. The second is prompt injection: hidden instructions that ride in on fetched content and steer an AI toward the attacker’s goal instead of yours. What the researchers did was join them. An attacker registers the invented name first and tucks instructions inside it. Nobody aimed it at you. It just sits there, waiting for any agent, anywhere, to invent its way to that address and knock.

The research found the attacker’s job is easier than you’d expect. The same invented names recur across foundation models built by different vendors, so one registration can catch many different tools (the same patterns showed up in Gemini, GPT, and Claude models alike). And the guesses are predictable enough that an attacker may never need to query a model at all. The most common pattern was the model reusing a project’s name as its owner, so anyone who registers that username for each new trending project is already standing at the address most models will invent. The attacker can stop hoping you’ll wander into the trap and simply wait where you’re going to walk.

Unlike a phishing email or a stolen password, HalluSquatting needs no direct line to the victim at all. The attacker doesn’t need to reach you, because your own tool reaches them.

  1. You

    Ask your coding agent to clone a project that's trending this month.

  2. Attacker, weeks earlier

    Registers the address models most often invent for that project and leaves instructions inside it.

  3. Your agent

    Doesn't know the real owner, so it guesses an address that looks right, often reusing the project's name as the owner.

  4. Your agent

    Fetches what's waiting at that address, and the hidden instructions arrive with it as ordinary-looking content.

  5. Your agent

    Follows those instructions and runs the attacker's code on your machine.

How HalluSquatting reaches your machine. The sequence follows the attack Spira et al. describe in their July 2026 paper.

What the numbers say, and what they don’t

In the researchers’ tests, agents invented fake repository names in up to 85% of clone requests, and fake skill names in up to 100% of some skill-installation requests. Running the full attack against real systems, including Cursor, Gemini CLI, Windsurf, and Cline, got the agent to run commands or code on the test machine in 20% to 65% of the repository-clone evaluations. Against AI assistants that install skills (OpenClaw, NanoClaw, and ZeroClaw), the same attack succeeded in 40% to 100% of evaluations.

The most useful figure is the split by age. The hallucination rate sat under 1% for repositories published before 2019, and above 92% for repositories published in 2025. An agent is most likely to invent a name exactly when someone asks it for the newest thing, which is most of the time, and which is also when nobody on the team has a memorized sense of what the real name should be.

Projects created 2013 to 2018
0.9%
Projects created in 2025
92.4%
How often models invented the owner name, by project age. Mean hallucination rate across six foundation models from Google, OpenAI, and Anthropic, at 100 queries per project per model (Spira et al., 2026, Table 3).

Two caveats belong next to these numbers. These are research conditions, not a measurement of what’s happening in your organization today. And the researchers disclosed to the affected vendors and model providers before publishing. They also say plainly that their results are a lower bound, which matters, because techniques get cheaper to repeat once they’re public.

It’s already happening in the small

The react-codeshift case from the opening is the precursor, and its details are worth a closer look. The name is a plausible-sounding blend of the names of two real developer tools, and Eriksen traced it back to a single commit of AI-generated agent skill files that nobody had reviewed. Forks carried it from there, and autonomous agents were still trying to install it every day when he wrote it up.

Palo Alto’s Unit 42 measured the same problem at the level of web domains. Querying two models about 913 global brands, they collected roughly 2.1 million generated URLs, which pointed to about 250,000 domains that were still unregistered and available to anyone who wanted them.

  • Typosquatting
    Who slips
    A person mistypes a name.
    What gets claimed
    A lookalike package name.
    What happens
    The person installs the wrong package.
  • Slopsquatting
    Who slips
    An AI writes an install command for a package that doesn't exist.
    What gets claimed
    That invented package name, like react-codeshift.
    What happens
    Whoever runs the AI-written command installs it.
  • HalluSquatting
    Who slips
    Your agent invents a repository or skill address mid-task.
    What gets claimed
    The address models invent most often, registered ahead of time with instructions inside.
    What happens
    The agent fetches it and follows the instructions, up to running code.
Three versions of the same trick. Each one moves the mistake further from a person and closer to the tool. HalluSquatting adds prompt injection, so the agent carries out the attack itself.

So the landscape is already dotted with empty houses that AI keeps handing out the address to. HalluSquatting is the version where somebody is finally home, and where the thing that walks in has a terminal.

🛡️ Responsible AI Note: Logging every tool call is what lets you answer “did our agent ever fetch that name?” after a squatted resource is disclosed. Clause 9.1 of ISO/IEC 42001, covering monitoring, measurement, analysis and evaluation, is the difference between knowing and hoping.

Why is this a governance problem as much as an engineering one?

Your security team might read this and call it basic hygiene: check what you install before you run it. Where does an AI management standard come in?

The thing is, hygiene and control are two different jobs, and HalluSquatting slips through the gap between them.

Hygiene is what one careful engineer does. A control is what your organization does on that engineer’s bad days (and after they’ve moved on). The whole reason management-system standards exist, and the reason they can feel like paperwork, is to take the good judgment living in one person’s head and put it somewhere it can be checked, repeated, and relied on. HalluSquatting works because, in most organizations, agents fetch and run things on trust by default. The governance question is who decided, on the record, what this agent may pull, from where, and with what verification, and whether you could show that decision to an auditor or a client when they ask.

🛡️ Responsible AI Note: A control that lives only in a senior engineer’s judgment isn’t a control an auditor can rely on. The AI system life-cycle controls in ISO/IEC 42001 Annex A.6 exist to make resource verification a written, repeatable step rather than a good instinct that happens to be present that day.

What does right-sized protection look like?

The answer here is a short list of unglamorous things, each of which maps to something a standard already asks for.

Treat every resource an agent fetches, whether that’s a repository, a package, a skill, or a connector to an outside tool (an MCP server), as an unverified third-party component until you’ve established otherwise. Prefer an allowlist of known-good sources over open-ended fetching. Put a gate in front of execution that inspects what’s about to be cloned or installed before it runs. Log every tool call, so that when a squatted name eventually shows up in an advisory you can answer the only question that matters: did we ever fetch it. And scope the agent’s permissions so an invented fetch can’t run commands on your computer by itself.

None of that is exotic, and none of it depends on models getting better at not making things up.

  1. Agent invents an address

    Allowlist: the agent fetches only from sources you've approved, so an invented address goes nowhere.

  2. Agent fetches it

    Provenance check: confirm the name belongs to a real, known source before anything downloads.

  3. Agent gets ready to run it

    Pre-execution gate: a hook inspects what's about to be cloned or installed and stops anything unexpected.

  4. Code reaches the command line

    Permission scoping: the agent can't run commands by itself, so injected instructions have nowhere to run.

  5. Weeks later

    Logging: when a squatted name shows up in an advisory, you can check whether your agent ever fetched it.

Where each control breaks the chain.

🛡️ Responsible AI Note: The design question underneath HalluSquatting is how much an agent may do before a human sees it. Scoping what an agent can fetch and execute on its own is an oversight decision that belongs in writing, and it maps to the MANAGE function in the NIST AI Risk Management Framework.

Where to start this week

So where do you begin, whether your team is five people or five hundred? None of this waits on the models getting better, and every step below works with the tools you’re already using.

  1. Write down where your agents may fetch from. List the handful of places real code should come from for your team (your own GitHub organization, the package registry you already trust, a folder of approved skills). That short list is the first draft of your allowlist.
  2. Make installs and clones ask first. Most coding agents can be set to pause for your approval before they run a command on your computer, so check that the setting is on for anything that clones, installs, or downloads.
  3. Have your agent search before it fetches. In the researchers’ tests, one coding agent that searched first got the right repository 93.4% of the time, and when it skipped the search, 99.1% of its guesses were invented. Ask it to look the project up before cloning, and when it proposes something you don’t recognize, confirm the real owner yourself.
  4. Keep the record, and give it an owner. Save your agents’ session logs somewhere you can search later, and ask one person to review the approved-source list each quarter.

I know these work in practice because I run them in my own multi-agent pipeline, where a gate checks every tool call before it runs and a logger records what the agents did. I set them up for traceability before this paper gave the threat a name, and it was a good feeling to read it and realize the defense was already in place.

I’d love for your team to have that same feeling, where you keep using these tools with confidence because the decisions that protect you were made and written down before anyone needed them. At Violet Beacon, this is the work we do with clients. If you’d like help mapping your agents’ fetch-and-execute moments and turning them into a practice your team can run, let’s talk through your setup.

How AI Was Used in This Post

AI helped research and draft this post, build its diagrams, and check its sources. Kate Waldhauser set the angle and edited the result before publication. The header image is AI-generated.

Frequently Asked Questions

What is HalluSquatting?
+

It's an attack that begins with an AI agent inventing a plausible name for a resource that doesn't exist, such as a code repository or an installable skill. An attacker who has registered that invented name in advance can leave instructions or code waiting there, so the agent fetches hostile content on its own. Researchers at Tel Aviv University, the Technion, and Intuit named and demonstrated the technique in a paper published in July 2026.

How is HalluSquatting different from typosquatting or slopsquatting?
+

Typosquatting relies on a person mistyping a name. Slopsquatting relies on AI-invented package names being published to a registry. HalluSquatting extends the same idea to the wider set of things an agent fetches on its own, including repositories and skills, and chains it with prompt injection so the outcome can be executed code rather than just a bad download.

Which requests are most likely to produce an invented name?
+

Requests for recent, trending resources are the most likely. In the researchers' testing, the hallucination rate for repositories published before 2019 was under one percent, while for repositories published in 2025 it was above ninety percent. The practical read is that an agent is most likely to invent a name precisely when someone asks it for the newest thing.

Does this mean we should stop using AI coding agents?
+

No, it means an agent's ability to fetch and run resources without review should be scoped and verified rather than assumed. Approved-source allowlists, provenance checks before execution, permission limits, and logging of every tool call address the actual risk without giving up the tool.

Why is this a governance question as well as an engineering one?
+

The defense only works if it survives turnover and a bad week. Verifying a source is something a careful engineer already does; a control is something the organization does whether or not that engineer is present. Writing down what an agent may fetch, from where, and with what verification is what turns a habit into something reviewable.

Explore Related Services

AI Governance
AI Governance Consulting
Learn more →
ISO 42001
ISO 42001 Planning & Consulting
Learn more →
AI Strategy
AI Strategy & Advisory
Learn more →
Kate Waldhauser
Founder of Violet Beacon. Responsible AI consultant, ISO 42001 Lead Implementer, and Certified Claris Partner with 20+ years of custom software and database expertise.

Related Posts

← Back to all posts

Want to discuss this topic?

Book a free call to talk about responsible AI, FileMaker, or anything you've read here.