Amazon built a trap that looked like an LLM API, and attackers’ AI agents walked right into it and handed over their plans.
Here’s what happened. From October 3 to November 5, Amazon’s decoy sensors posed as popular chat-completions endpoints. AI agents found them and started using them as their brain, sending prompts like the decoys were real models. Amazon assesses, with moderate confidence, that those agents were running an attack framework called ARTEX.
Think about what an agent sends a model every time it has to decide what to do next: the system prompt, the tool history, the shared memory, everything it’s found so far. So in Amazon’s words, “individual requests often contain the full operational history of a campaign.” Amazon is careful to say it can’t verify what the agents claimed to have done. It can only read what they wrote down. Nobody broke into anything. The agents treated the trap like their model, so they sent it their notes.
On November 13 the FBI put out a FLASH on ARTEX. Most of the headlines went with the speed and the scale. I want to come at it from the layer I spend most of my days in, the one between the agent and the model, because in ARTEX’s story that layer keeps showing up. Attackers steal it, they run on it, and it’s also what catches them.
The short version. ARTEX is an open-source framework that runs penetration tests with AI agents, and criminals and at least one state-aligned group picked it up within weeks. The techniques are old; what changed is cost and speed. You can build the same kind of trap Amazon used into your own gateway, and here’s what I’d do this week.
The tool the FBI is warning about
ARTEX showed up on GitHub on July 26, 2026, from a developer called Autumn-27. It’s written in Go. You give it a goal in plain language, a planner agent breaks that goal into tasks, and worker agents run the tools and write their results back to a shared memory. It took off fast. Censys estimates it hit 1,500 to 2,000 stars in ten weeks.
The developer said it was meant for authorized testing. The FBI says the repository went unavailable on October 8, the day after CrowdStrike reported ARTEX being used against South Korean banks. If you’ve been around open source for a while, you already know how that goes. Forks, archived copies and a commercial edition, ARTEX PRO, are all still out there.
According to the FBI, a range of actors have used it since at least August, against ten sectors from financial services to defense. The FLASH leads with two campaigns:
- South Korean finance. CrowdStrike assesses, with moderate confidence, that the actor is likely Chinese-speaking and financially motivated. The industry reports it cites describe a loan inquiry service for brokers breached at one bank, and an employee mobile work-support system at another. The FLASH puts the stolen personal data at about 67,000 people.
- ConnectWise Cloud Backup. Microsoft assesses that Storm-0940, a China state-aligned group, was behind the ConnectWise supply chain compromise, and then used ARTEX to attempt sign-ins to more than 2,250 customer tenants. Across the group’s ARTEX attacks, Microsoft saw “multiple instances where the time from initial targeting to privileged access was less than 3 hours.”
One caveat before going further: the FLASH is a compilation of vendor reports, so read its numbers carefully. The 2,250 are attempted sign-ins, not compromises, and Microsoft says “the majority of the targeting wasn’t successful.” “Under three hours” is Microsoft’s figure for multiple instances, not a median. Google tracks an overlapping actor at about four hours.
None of that makes the intrusions less real. It just shows what these agents are: noisy, fast, and sometimes wrong about their own success. Google watched ARTEX run in bursts of roughly 2 to 25 seconds, and logged errors “potentially caused by multiple sub-agents overwriting one another.” My favorite is from Check Point. Agents reported they’d found a way to cash out cryptocurrency, and the attacker’s wallet held $0. Check Point called the findings hallucinations. If you’ve run coding agents for any amount of time, you’ve seen that movie.
And what they exploited is old: unsigned SAML assertions, XXE, SSRF, hardcoded admin passwords in JavaScript bundles, unrotated authentication keys, Kerberoasting. Those are weaknesses in victim systems, not bugs in ARTEX. In Amazon’s words, “None of the techniques in these campaigns were new. What AI agents change is the speed and persistence of the attacker.” Even the AI part isn’t new. A year ago, Anthropic reported a group it assesses as Chinese state-sponsored using Claude Code against roughly thirty targets. What’s new is the package: an open-source harness, a swappable model, and several crews running it at once.
The guardrail they routed around
This is the part that jumped out at me. ARTEX doesn’t include a model. Like most agent harnesses, it takes an endpoint and a key, and the model is just a setting.
So the attackers did what any cost-conscious engineer would do. In the ten instances whose full databases Check Point could read, Chinese models dominated, mostly the DeepSeek Flash family. They were cheap, capable enough, and “did not show any signs of guardrails when executed under the ‘Pentest’ framing of ARTEX.”
Three of those consoles had American models configured. The only model that hit guardrails was Anthropic’s Opus 5.5, and the operator’s response was to switch to more permissive Chinese models.
So the guardrail worked, and the attacker just routed around it. That’s one operator in a ten-console sample, so I’m not going to turn it into some law of nature. But when the model is a setting, a refusal is a speed bump, not a wall. If your defense plan assumes the model will say no, you’ve assumed the attacker picked a model that does.
Then there’s the bill. One operator Check Point tracked ran two consoles in parallel for about two weeks against ten gray-market app signing shops, trying to steal their certificates and resell them. That operator went through 36 billion tokens, and 33.79 billion of them were cache-hit input tokens. Using DeepSeek’s published prices, Check Point estimates the model bill at $700 to $1,500.
My whole Black October story started with a token bill at work. So does theirs. Check Point doesn’t explain the cache ratio, but it fits how agents work, and you’ll see why in a minute. The same economics that make my coding agents affordable make their attack agents affordable.
The gateway that keeps showing up
Quick gut check before this next part. Somewhere in your company, there’s probably an Ollama box someone stood up for a demo, or a LiteLLM proxy nobody really owns. Keep that box in mind.
I’m an infrastructure guy, not a security researcher. I contribute to vLLM Semantic Router and run LLM gateways in my lab, so I’ll admit I read every one of these vendor reports looking for the gateway. It shows up three times. Not every one of these attacks touches your gateway. The ones that steal from it do, and those are the ones you can do something about.

The route they take to the model
Picking the cheapest model that can do the job is exactly what LLM routers do for legitimate traffic. I gave a whole talk on it. The attackers built the same plumbing. In the Korean campaign, CrowdStrike found the actor likely reached DeepSeek through an LLM reseller, xcai[.]pro. Hunt.io found a docstring in the operator’s own code describing one route, translated from Chinese: “The Gemini user path is Claude Code to CCR on port 3456, then to xcai at direct[.]xcai[.]pro, and finally to DeepSeek.” CCR is Claude Code Router, an open-source project that points Claude Code at other model backends.
Censys found the same kind of software sitting alongside exposed ARTEX consoles. 43 of those hosts also ran self-hosted LLM gateway or reseller software, mainly CLIProxyAPI (19) and New API (18). Censys notes some of those consoles likely belong to authorized testers.
So what does that mean for you? When the console and its model path run on the attacker’s servers, like in the Korean case, those calls never touch your network. Your egress logs only see agent traffic when an agent runs inside your walls (a compromised host, a tool someone installed without asking) or abuses one of your apps into calling a model for it. And if your proxy doesn’t decrypt TLS, it sees the hostname, never the prompt.
Even then, one hostname isn’t enough. This operator had two routes: the agents went through the reseller, while a small local shim sent other requests straight to api.deepseek.com. That’s why the FLASH asks for model endpoints and also for “unfamiliar LLM proxies or resellers in egress logs.” Go ahead, try blocking them:
Both routes reach the model.
The keys they steal
This is the finding I think matters most, and it’s Amazon’s. Amazon published it the same day as the FLASH, which doesn’t cite it. The most prominent ARTEX campaign Amazon saw was a large-scale theft of credentials to AI models, “organized as a self-sustaining operation in which stolen keys paid for the LLM inference powering further credential hunting.”
That’s pretty wild. Somebody’s stolen keys pay for the agents that go looking for the next person’s keys.
The agents went after applications that hold lots of provider keys, because one weak admin interface can give up a whole stack of provider accounts. Amazon’s list includes gateways like LiteLLM, One API and New API, and app builders like Dify, Langflow and Ollama. If you run AI infrastructure, you know these. I run Ollama myself. The playbook wasn’t anything fancy:
- uninitialized installs anyone could claim;
- anonymous management endpoints;
- default admin credentials (Amazon names “the LiteLLM default master key”);
- known CVEs;
- keys left in client-side JavaScript, source maps and environment files.
In one operation, every credential got a grade, from L1 (a lead) to L3 (readable data or a balance they could spend), and keys public for more than 30 days counted as low-value. Flip that around: fresh leaks are what they’re after. Amazon’s advice is to assume exposed secrets “will be found quickly.”

To be clear, stealing model access isn’t new. Sysdig’s researchers named it LLMjacking back in 2024. What’s new is the scale and the plumbing. Google describes “LLM Mixers” that “proxy, aggregate, and resell unauthorized LLM access,” and one group it tracks used new-api, the same software Censys found on some ARTEX hosts. (Google doesn’t tie that group to ARTEX.)
Here’s how I think about it now: an LLM gateway that holds provider keys is a key vault with an HTTP API in front of it. Attackers know that. Your security team should too.
The notes that give them away
Back to Amazon’s trap. Its sensors saw the campaign from the inside because agent frameworks send a model a lot of what they know. The request body read like the operator’s diary.
Here’s what that looks like turn by turn. It’s also why that operator’s bill was so cheap: agents resend the same long prefix every turn, and prompt caching charges a fraction of the normal price for the repeated part.
- system prompt
- tool history
- shared memory
- findings
- faded = cached prefix, bright = new this turn
The model reads the whole stack every turn. So does anything answering as the model.
Turn 32 of 32: 34 blocks sent, 33 of them cached. Cached so far: 94%. Check Point's operator: 94% of input tokens were cache hits.
That holds at any gateway an agent runs through, whether it’s a reseller’s, a provider’s, or yours. The calls can carry the plan. It’s also why one of the most specific asks in the whole FLASH is tucked into its information request: “token consumption patterns or API billing anomalies,” plus any self-hosted gateway or reseller software. Your gateway sees every call that passes through it, and keeps whatever you configure it to keep. So it’s where an agent shows up when it’s running on your hosts or through your apps, even if it never touches a known-bad IP. Get that data in front of your security team.
One catch, though. Seeing a request isn’t the same as keeping it. LiteLLM, for one, doesn’t store request or response bodies unless you turn that on. My take: log identity, source, model, tokens and cost everywhere, and capture bodies on purpose, with access controls and a retention limit, where an investigation would actually need them.
One more caveat: a stolen provider key can be used from anywhere, without ever touching your gateway, and the bill still lands on you. So watch provider-side usage and billing, not just your gateway’s logs.
The trap you can build into your own gateway
This is the part I’m most excited about, because it’s the stack I’ve been building in my lab anyway (I wrote about why in One Control Point): agentgateway in front, and vLLM Semantic Router behind it picking a model for every request. A semantic router already reads each request to decide where it goes. It’s built for cost and quality, and it has classifiers for things like jailbreaks and PII. Point that same machinery at this problem and you get Amazon’s trap, inside your own front door.
Here’s the idea. Pentest-framed system prompts, recon tool traces, a key that suddenly goes from chat to long tool loops: when a request looks like an attack agent, the router doesn’t send it to your frontier model. It sends it to a guard model that refuses, or to a decoy that plays along with Microsoft’s “fake wins,” while the gateway keeps the whole request. And remember, that request is the operator’s notes.
Two things have to be true for this to work. First, the attacker’s traffic has to come through your gateway, which is why I’d only ever hand apps gateway-issued keys, never raw provider keys. A stolen gateway key doesn’t work anywhere else. If they run everything on their own servers with their own keys, your gateway never sees them, and the only witnesses left are the providers, the resellers, and traps like Amazon’s. Second, the classifier will miss things, and it can misfire the other way too. I’ve already tried a piece of this. In It Was Never the Model, my guard model scored 87 percent on my test set, but when I wired it into the router it quarantined every request, even “say ok,” and I had to back it out. Getting the classifier right is the hard part. And it’s the Black October lesson one more time: a guard only counts on the paths it covers, so this is a layer, not the lock.
The boring fixes that still work
The good news is that these agents are loud and the fixes are boring. Amazon said the agents “succeeded where basic security hygiene was missing.”
Try this tonight. It takes ten minutes. From a machine outside your network (a phone hotspot works fine), ask your own gateway for its model list without a key, and look at the status code:
curl -s -o /dev/null -w "%{http_code}\n" https://your-gateway.example.com/v1/models
You want a 401 or 403. If you get a 200, check that the body is really a model list and not a login page, then send the smallest valid completion request your docs show, with no key, and make sure it’s rejected. While you’re in there, check whether the admin page loads from the internet, whether any key was copied from install docs, and whether your front-end bundles or source maps hold a provider key. All three are on the list Amazon’s agents worked from.
So I ran it on my own lab. From the internet, my GH200 inference box doesn’t serve inference at all, key or no key, and the Ollama on my laptop only listens on localhost. So far so good. Then I ran the same check from inside the WireGuard tunnel I use to reach that box, and vLLM happily listed its models and ran a completion with no key at all. Oops. The tunnel is the only lock on that door. Same lesson as my bug, just in my own house this time: a control only counts on the paths it covers. Anything that landed on a machine inside that tunnel got a free model. vLLM supports an API key, so I turned it on. The same request without a key now gets a 401.
Lock down what they steal.
- Find every gateway and inference endpoint you run. Remember that Ollama box? Find it, and every LiteLLM, Open WebUI, Dify, Langflow or New API install next to it, including the one somebody stood up for a hackathon. None should face the internet without authentication, or run on a master key copied from an install guide. Amazon’s advice: bring them “under the same controls as other production systems.”
- Treat provider keys like cash. Hand apps scoped gateway keys, never raw provider keys, and give each one its own budget. Use hard spend limits where your provider has them, because an alert isn’t a cap. Keep keys out of client-side code, and rotate a leaked key right away.
Watch how they reach the model.
- Look for LLM traffic you didn’t approve. Any host calling a model API other than your gateway is worth a look, and so is any reseller domain you don’t recognize. This only catches agents inside your network, but that’s where they hurt.
Use what your gateway sees.
- Baseline each key, then watch for change. Know each app’s normal token counts, tool use and source networks. A key that jumps from short chat turns to long, tool-heavy loops, or starts calling from a new network, is your signal.
- Set a trap. A decoy endpoint nothing legitimate should ever call flags an agent that’s already inside. Microsoft recommends honeypots, tarpits and “fake wins” too, or build the trap into your gateway like I described above. Either way, somebody has to watch it.
Don’t forget the boring stuff.
- Inventory from the outside in. Reported Korean targets included a broker portal and an employee app, the kind of systems that sit outside the flagship review. Start from what’s actually exposed and federated, not from the app catalog.
- Rate-limit the boring endpoints. On partner and employee portals, alert on sequential lookups and on sessions that pull an unusual number of records, and rate-limit them. The FLASH recommends exactly that.
The part that still doesn’t scale
In my Black October post, I said finding scales with compute and fixing doesn’t. ARTEX pushes that one step further. Now exploiting scales with compute too. Check Point puts one operator’s 36 billion tokens at $700 to $1,500. By my math, that’s a laptop.
Fixing still runs on people, though. Akamai reports that at three major Korean banks, reported time to detection ran from about 15 hours to nearly 68 hours. In a different campaign, Microsoft saw attackers reach privileged access in under three hours. Different victims, so it’s not a head-to-head race, but it tells you which clock each side is running on. The doors haven’t changed. What changed is how cheap it is to try every one of them, everywhere, at once.
So it’s the same work, just faster. Close the doors you already know about. Put your gateways and keys under real controls. And read your own logs before somebody else’s agent does it for you.
Amazon got the agents’ notes because its trap was listening. Make sure your gateway is too. Like I said at AIMUG: up our game, or get p0wn3d.
If you run an LLM gateway, I’d love to hear what you’re logging and who’s actually reading it. Find me on LinkedIn or X.