Back to Blog
    Threat Intelligence

    26 ARTEX Repos, One Tiny Tower of Terror, Zero New Attacks

    James McMurryNovember 20, 202621 min read

    Here is the part nobody selling you an ARTEX feed wants to say out loud: ARTEX did not invent a single attack. Not one. It is a reasoning model wearing the tools you already know, curl, sqlmap, nuclei, ffuf, a headless browser, a webshell, driven by a planner that does not get tired and does not go to lunch.

    Amazon, after catching these agents in its own decoy sensors, said it better than I can: “None of the techniques in these campaigns were new. What AI agents change is the speed and persistence of the attacker.”

    Some of these builds call a hosted model, some run DeepSeek, some run whatever you point them at. It does not matter, and here is why: you will not see the model in the first steps. There is no packet that says “a language model decided this.” The model traffic runs between the operator and whatever serves their model, and it never crosses your network. What reaches you is the tool the model picked. What you will see is speed, noise, and the same known attacks you have blocked for years, run consistently, in order, without a coffee break. Speed and reasoning matched with persistence. That is the whole product.

    I did not want to take a vendor’s word for that, including my own instinct. So I pulled every version of ARTEX I could find, built a lab mean enough to run them, and let them off the leash against targets I own. This is what I learned.

    What ARTEX is, and why everyone suddenly cares

    ARTEX is an open-source, self-hosted penetration testing framework that hands the driving to large language models. It showed up on GitHub in July 2026, and an English-language continuation still lives there. The loop is simple: you give it a target and a goal, a planner agent breaks the goal into tasks, worker agents run ordinary tools (Nmap, curl, browsers, the usual suspects) and write what they learned back into a shared graph, that wakes the planner, it picks the next move, and around you go until the goal is met. It works with whatever model you point it at. As the project itself brags, accurately, “It explores, it doesn’t chat.”

    Built for authorized testing. Adopted by everyone else. Microsoft says a China-state aligned actor used ARTEX to automate attacks on hundreds of organizations, with cases where “the time from initial targeting to privileged access was less than 3 hours,” and that the activity generates alerts but “the speed of the activity allows very little time for Defenders to respond.” Google’s threat intelligence group calls it “a paradigm shift towards intrusions occurring at machine speed,” while noting these frameworks “trade stealth for velocity.” Wiz, watching an actor grind through identity providers for a full day at a stretch, put it plainly: “While a human attacker is bound by time constraints and fatigue, an autonomous agent does not give up.”

    And the operators are not hiding. Censys counted 1,465 hosts running an exposed ARTEX console in early November, and the FBI issued a FLASH warning that the framework lets threat actors with minimal technical expertise run complex, multi-target operations. That is the picture. Here is what I think it means.

    The clock is the attack

    The techniques are old: password spraying, leaked secrets, exposed admin panels, web shells, OAuth apps with too much trust. What is new is the clock.

    The original project went closed-source, and the forks took over and kept growing. One fork has a design for spotting honeypots before it wastes a payload on them. Another just ripped out its tell-tale user agents and swapped in a rotating pool of real browser strings. Honeypot data I have been digging through shows sessions routing through rotating residential proxies, dropping a web shell, forging a hosting-panel API token from the panel’s own key, and reading system config and cron jobs. Nothing in that chain is clever. All of it is fast.

    And the “safety features” in these tools belong to whoever runs them. Spend caps that reset on a restart are not guardrails. They are a suggestion.

    How I collected them

    So I went fork hunting. The landscape is messier than the headlines suggest: plenty of repos carry the name but are empty mirrors, locale ports, or app-store wrappers around someone else’s image.

    After cutting the noise I kept 26 repos worth reading. 22 are working attack engines. The other 4 are not engines at all: an iOS port, an MCP bridge, and two app-store packages that just ship someone else’s container. I pulled each as a dated archive, recorded a SHA-256 for every one, and read the source before anything got near the lab, because two of the forks say in their own docs that one widely pulled image is backdoored. I have not verified that claim, and I would rather find out in a diff than in my own cluster. That reading is the backbone of the comparison later in this post. You cannot tell costumes apart until you have read what is under them.

    Inside the Tiny Tower of Terror

    Reading other people’s reports only gets you so far, and I wanted to see this first hand. So I spent more than 50 hours over one weekend, with no sleep, building what I am calling the Tiny Tower of Terror. When I say Tiny, I mean it: a 10-inch 12U rack packed full.

    The short version of the rack: a 16-node Proxmox cluster with quorum, three large local Norby LLMs served across two RTX 6000 Pros and two Nvidia Spark GB10s, and ARTEX running on a dozen of those nodes connecting the models to the testing tools. That is the whole hardware story you are getting; this post is about behavior, not my shopping list.

    The why matters more than the parts. I built it isolated on purpose. These are hostile agentic tools that will happily wander out of scope if you let them, and ARTEX’s own default blocklist protects almost nothing beyond .gov and .edu. A segmented lab with local models means I can hand one of these engines a real objective, watch every sensor, and not lie awake wondering whose network it drifted into. Local models also mean no API bill and no cloud provider reading over my shoulder, plus a very expensive space heater I get to call research.

    I installed and ran them

    Then I did the tedious part. I installed and ran all 22 engines on the tower, under scope, against things I built to be attacked, with the sensors recording. I give it an objective and a scope, it plans the steps, calls the tools its agents can reach, reads the output, and uses what it learned to decide what happens next. Planning, tool execution, asset tracking and evidence all live in one workflow.

    Two kinds of evidence sit in this post, and I am keeping them apart. What a fork is built to do comes from reading its source. What it did comes from the runs. The comparison tables further down are source reading. The noise, the trigger-happy behavior and the confidence problem are what I watched on the tower.

    In a controlled live check against services I own and control, I had ARTEX target three different mini organizations I had created, complete with Azure tenants, web apps, on-prem systems and firewalls. Through the many starts and stops I was running, I was surprised how trigger happy it is, which is where my noisy comment comes from, but if instructed and prompted properly it can be quite cunning. Let me be precise, because the internet will not be: that proves a working piece of the loop. It is not a benchmark of autonomous compromise, and nobody should screenshot it as one.

    What the runs actually taught me is less cinematic and more useful. If you are not careful, ARTEX is noisy, and its tool traffic is recognizable because it is the same traffic your scanners already generate, just relentless. Results swing hard with the model, the tools, the permissions and the configuration. And it has a confidence problem: the graph will happily mark a finding “confirmed” while the actual review is still pending. So no, today’s ARTEX is not a defender’s total nightmare. It is a fast, tireless one, and a reason to pay attention.

    Here is the part that should keep you up at night, and it kept me up, though that was mostly the cabling. I built this with off-the-shelf hardware, an open-source framework and a long weekend. This level of agentic capability is not far out of reach, and well-resourced threat actors and nation-state teams have far more compute, far more talent and far more patience than one sleep-deprived CEO. The automation tools of the past found things and then waited for a human to decide the next step, and that wait was our margin. Now a large reasoning model, handed the right goals up front, can reason its way from one result to the next on its own, and given enough attempts against an exposed, poorly watched environment, into most places.

    The versions, compared, and why the differences are costumes

    This is the part I actually care about, and the part that changes how you detect it. I read all 22 engines side by side. The headline finding is boring and important: they share one brain. Same task layout, same tools, and the same recon script in every single one. What the forks change is the face they show your web server, how loud they are, and what they leave behind. Costumes, not new creatures.

    Start with the face. 21 of the 22 engines hard-code the same recon user agent. One fork, RuoJi6, rotates through a pool of 20 real browser strings instead, a fresh pick per request, with an environment variable to override it. That sounds stealthy until you notice it only changes the string: the TLS handshake and cookies underneath never move to match, so one source cycling through five “browsers” in five minutes is its own tell. Every other engine is one edited line away from erasing the string you were keying on.

    Then the behavior underneath, which is where the real differences live, and none of them are new attacks:

    • azrielnan is the one that gets in and stays. It rotates a round-robin pool of egress proxies, so one task arrives from several source IPs by design. It drives classic one-line webshells that tag every request with Mozilla/5.0 (ARTEX), and it also generates its own AES-encrypted shells with random names that post a raw base64 body with no form fields. Same webshell game you have seen for a decade, just automated and consistent.
    • AdverserialAI tells its agent to name webshells like your app (index.jsp, main.php), never with giveaway names, then runs a cleanup agent that deletes the files the task planted after a typed confirmation. Blend in, then tidy up.
    • jaykwok quietly removes two guardrails the original shipped: the blocklist that skipped .gov and .edu, and the rule that refused to call delete-style endpoints. Nothing exotic, just the safety off.
    • hunmeng2012 and MoLeft push the model past its own refusals, one with an uneditable execution-discipline block on by default, one with an opt-in override mode. The point is the same: do not let the model say no.
    • BaaRai and Toru9X add a throttle so the agent can drop to as low as two requests per second, trading speed for quiet. They also store model keys encrypted, where most forks keep them in plaintext.
    • The enrich user agents (artex-enrich and its rebrands) are in the code but dormant: nothing outside the test files calls them in these snapshots. Do not build a program on a string that does not fire.

    Read that list again and notice what is missing: a new technique. It is all webshells, proxies, scanners, refusal-wrangling and throttling. The differences decide whether your string-based alert fires. The behavior underneath is the same attack done faster and more consistently than a human would bother to. Here is the lineage, then the wire view.

    Table 1. Lineage of the 22 engines

    Repo Based on Version Last update Notes
    iAm-182/ARTEX Original (deleted upstream) 0.3.15 2026-10-07 Mirror of the original. The baseline everyone forked
    Hinln/ARTEX Original 0.3.15 2026-10-08 Same code; update channel points at its own repo, token-gated
    RuoJi6/ARTEX Original 0.3.30 2026-11-14 Hardened: rotating UAs, Basic Auth gate, MCP server
    BaaRai/ARTEX Original 0.6.0 2026-11-19 English fork; optional throttle; browser extension
    Toru9X/ARTEX BaaRai/ARTEX 0.6.0 2026-11-18 Adds skills, interactsh, php2shell PoCs
    hunmeng2012/artex-hm Original 0.3.15 + mods 2026-11-19 Refusal-retry guard, Kali toolchain
    br0ny4/artex-redev Original Fork-0.3.0 2026-11-19 Policy engine, PoC replay, CVE novelty checks
    AdverserialAI/artex-attack Original 0.1.5 2026-11-19 English rewrite; Godzilla webshells; trace cleaner
    jiwoochris/artex-global Original 0.3.15-global.1 2026-11-19 Five languages; setup token; loopback bind
    Braedach/ARTEX-MUTANT jiwoochris/artex-global 0.2.0 2026-11-19 Hardening fork
    demonyaksa/ARTEX.pure Original 0.3.15 2026-11-19 Self-update removed
    wkend/Lodestar Original No tag 2026-11-18 Full rebrand to Lodestar
    sordado123/vulnetic-core BaaRai line (per its README) No tag 2026-11-19 Rebrand plus SaaS; reverse agent
    cskwork/scopeweaver Original (pre-0.3.15 commit) No tag 2026-11-17 Rebrand to ScopeWeaver; six languages; extra model presets
    MoLeft/ARTEX RuoJi6/ARTEX (0.3.18 era) 0.3.18 + mods 2026-11-16 Opt-in anti-refusal mode; Lightpanda browser; deeper failover
    jaykwok/ARTEX Original 1.0.5 2026-11-15 SQLite; .gov/.edu blocklist and delete-endpoint guard removed
    wpsec/ARTEX-Pro Original 0.3.18 2026-11-17 OWASP ZAP on by default; report pipeline
    RC-CHN/ARTEX Original 0.15.1 2026-10-27 93 own commits; Playwright, nuclei, sqlmap, katana toolkit; own callback service
    sharenjun/ARTEX-main Original (fresh history) 0.4.5 2026-11-02 ScopeSentry asset sync; request replay; multi-model worker pool
    Ariember/ARTEX RuoJi6/ARTEX (0.3.18 era) 0.3.18 + mods 2026-10-22 Maintained as fraternity-z/ARTEX; credential sorter; WeChat alerts
    bdg9412/artex-ko-plus Korean edition artex-ko (per its README) No tag 2026-11-07 AegisLoop: purple-team add-on with Splunk and threat hunting
    azrielnan/artex-ko-main Korean edition (per its changelog) No tag 2026-11-17 Webshell session driver; proxy rotation pool; suo5 and chisel tunnels

    RuoJi6’s changelog tops out at 0.3.30. MoLeft and Ariember both branched from it at 0.3.18, before rotation landed, so they still send the fixed strings. The two Korean-edition forks cite a base I did not pull, so I diffed them against the original instead of taking the README’s word.

    Table 2. How the engines look on the wire, differences only

    7 of the 22 send the fixed recon string, carry the dormant enrich string, drive Chromium and have no speed control. They are left out.

    Repo Recon user agent Enrich UA in code Headless browser Speed control
    iAm-182/ARTEX Fixed spa-api-recon Yes (dormant) Chromium None, loud by default
    RuoJi6/ARTEX Rotates 20 browser UAs No (removed) Chromium None; told to stop on rate limits
    BaaRai/ARTEX Fixed spa-api-recon; optional fixed override No Chromium Opt-in throttle, 2 to 20 req/s
    Toru9X/ARTEX Fixed spa-api-recon; optional fixed override No Chromium Opt-in throttle, 2 to 20 req/s
    hunmeng2012/artex-hm Fixed spa-api-recon; bare Mozilla/5.0 probe Yes (dormant) Chromium None; adds masscan, hydra
    br0ny4/artex-redev Fixed spa-api-recon; artex-poc-replay/1.0 Yes (dormant) Chromium None
    AdverserialAI/artex-attack Fixed spa-api-recon; norma/0.4 on WebFetch Yes (dormant) Chromium None
    wkend/Lodestar Fixed spa-api-recon; norma/0.4 on WebFetch lodestar-enrich (dormant) Chromium None
    sordado123/vulnetic-core Fixed spa-api-recon; Vulnetic-Verification/1.0; norma/0.4 on WebFetch vulnetic-enrich (dormant) Chromium None
    cskwork/scopeweaver Fixed spa-api-recon; norma/0.4 on WebFetch Yes (dormant) Chromium None
    MoLeft/ARTEX Fixed spa-api-recon Yes (dormant) Chromium and Lightpanda None
    wpsec/ARTEX-Pro Fixed spa-api-recon Yes (dormant) Chromium None; ZAP scanner on by default
    RC-CHN/ARTEX Fixed spa-api-recon; norma/0.4 on WebFetch Yes (dormant) Chromium (Playwright) None
    sharenjun/ARTEX-main Fixed spa-api-recon; norma/0.4 on WebFetch Yes (dormant) Chromium None
    azrielnan/artex-ko-main Fixed spa-api-recon; Mozilla/5.0 (ARTEX) on every webshell POST Yes (dormant) Chromium None; one skill script picks from 4 browser UAs with 2 to 3 s delays

    Everything the agent does through curl, sqlmap, nuclei or a browser carries that tool’s own user agent, in every fork. Only the recon script is ARTEX-branded, and only until someone edits one line. Now the network behavior and what each leaves behind after a foothold.

    Table 3. Network and evasion, differences only

    13 of the 22 handle the network exactly like the original: one optional proxy, no rotation, no hard-coded callback service, no reverse agent. They are left out.

    Repo Proxy handling Tor or IP rotation Callback services in code Reverse agent
    iAm-182/ARTEX One optional proxy; SDK can retry direct No None hard-coded No
    BaaRai/ARTEX Same, plus throttle No None hard-coded No
    Toru9X/ARTEX Same, plus throttle No interactsh No
    hunmeng2012/artex-hm kx wrapper strips proxy for tools No None hard-coded No
    br0ny4/artex-redev Same as original No dnslog, ceye, oast, Burp Collaborator No
    sordado123/vulnetic-core One optional proxy; direct retry read in bundled SDK No None hard-coded Yes, vulnetic.site gateway
    RC-CHN/ARTEX One optional proxy; direct retry read in bundled SDK No interactsh; own HTTP callback URLs No
    bdg9412/artex-ko-plus Same as original No oast.pro, oast.me in skills No
    azrielnan/artex-ko-main Round-robin pool of egress proxies for target traffic Yes, proxy rotation oast.pro, oast.me in skills No

    azrielnan is the first with real proxy rotation, and there is a twist that helps you: the agent’s built-in web fetch, from the bundled SDK, retries directly when a proxied request fails, and that direct hit does not go through the capture proxy. One run can wear several addresses and still leak the operator’s real egress next to them.

    Table 4. After a break-in, differences only

    8 of the 22 bundle no webshell kit and no cleanup, and add nothing after a foothold beyond what the original does. They are left out.

    Repo Webshell kit Cleanup Other post-exploit features
    iAm-182/ARTEX None bundled No Agent uses whatever tools it has
    BaaRai/ARTEX None bundled No Bigger toolchain: nuclei, sqlmap, ffuf
    Toru9X/ARTEX None bundled No php2shell PoCs; interactsh blind proof
    hunmeng2012/artex-hm None bundled No php2shell RCE skill; chisel tunnels; impacket
    br0ny4/artex-redev None bundled No Replays a finding’s PoC at the target
    AdverserialAI/artex-attack Godzilla, named like app files Yes, deletes its own files; told not to clear logs Avoids shell or cmd in file names
    sordado123/vulnetic-core None bundled No php2shell PoCs; live CVE verification
    jaykwok/ARTEX None bundled No No built-in block on delete endpoints
    wpsec/ARTEX-Pro None bundled No ZAP active scanning via MCP
    RC-CHN/ARTEX None bundled No chisel in its toolkit image; sqlmap, nuclei
    sharenjun/ARTEX-main None bundled No Request replay workspace
    Ariember/ARTEX None bundled No Sorts loot into accounts, passwords, tokens
    bdg9412/artex-ko-plus None bundled No php2shell research; defensive hunting add-on
    azrielnan/artex-ko-main Own generator: encrypted PHP and JSP shells, random names; drives PHP, JSP, ASPX one-liners No base64 to /tmp/.artex_* then sh; LD_PRELOAD bypass; suo5 and chisel

    Only two forks bundle an actual webshell workflow worth the name; most just let the agent use whatever it can reach. That is the pattern across every table: a handful of forks add a sharp edge, the rest are the same engine in a different shirt.

    A few things that MIGHT show something

    Because the behavior is shared, behavior is what you hunt. None of these is a silver bullet. Each is a maybe, a place to look that is more likely to be ARTEX than to be your users. Treat them as starting points and tune them to your own traffic.

    Start with what the agent cannot easily fake. A shiny new browser user agent riding a Go or curl TLS handshake. An X-Artex-Auth header landing on a panel. An MCP client that introduces itself as artex. A web server process reaching out to a hosting panel’s own local API. Those are behaviors, not strings, and they survive a user-agent swap. Then the specifics:

    • The recon user agent. Mozilla/5.0 (spa-api-recon) on the recon script is still in 21 of 22 engines. Trivial to change, so do not lean on it, but free signal is free signal while it lasts.
    • Mozilla/5.0 (ARTEX) POSTing to a script in your web root. That is not recon anymore. If you see it, assume a foothold and work backward.
    • The chunk sweep, then the 401 sweep. The recon script downloads every JavaScript chunk in your app, including ones no human loads, then hammers the logged-out API paths it scraped. One source pulling more chunks in a minute than any route imports, followed by a cluster of 401s and 403s across protected paths, is a sequence a browser does not produce.
    • base64-only POST bodies to a newly created script, and a web server process spawning sh with base64 -d on its command line. That is azrielnan’s encrypted shell and its command execution, more or less exactly.
    • The same path sequence from several source IPs seconds apart. That is proxy rotation. Correlate on the target and the request pattern, not just the source IP, or you will split one attack into three innocents.
    • A web shell landing, a forged panel token, a process reading cron jobs. That was the honeypot chain. None of it is clever. All of it is fast, and all of it is a real outcome you can alert on.
    • Decoys you plant yourself. Add one chunk id to your manifest that no route imports, and one hidden same-origin link that avoids the words the default spider skips. A browser never touches either. A hit is about as close to a signed confession as hunting gets.

    Two or three of those are cheap to stand up today. Here are short ones to start from, not production rules:

    Pseudo / KQL-style: chunk sweep then 401 sweep from one source

    WebLog
        | where uri_path matches regex @"/.*\.[0-9a-f]{6,16}\.js$"
        | summarize chunks=dcount(uri_path) by src_ip, bin(TimeGenerated, 1m)
        | where chunks > 30
        | join (WebLog
        | where uri_path startswith "/api/" and status in (401,403)
        | summarize denied=dcount(uri_path) by src_ip, bin(TimeGenerated, 5m)
        | where denied > 10) on src_ip
        | where TimeGenerated1 between (TimeGenerated .. TimeGenerated + 10m) // denials within 10 minutes of the chunk burst

    Pseudo / KQL-style: tagged webshell, and web server spawning sh with base64

    // ARTEX-tagged shell: that UA POSTing to a script in the web root
        WebLog | where http_method == "POST"
        | where http_user_agent == "Mozilla/5.0 (ARTEX)"
        | where uri_path matches regex @"\.(php|jsp|aspx)$"
        // On the host: a web server process spawning a shell with base64 -d
        Process | where parent_image has_any ("php-fpm","httpd","nginx","java","w3wp.exe")
        | where child_image has_any ("/sh","/bash")
        | where child_cmdline contains "base64 -d"

    Note what these do not key on: IP addresses, ASNs and TLS fingerprints can help an investigation, but none of them should carry the whole decision. That rotating user-agent pool proves the point. Blocking indicators is useful. Endless whack-a-mole is not a strategy. It is a hobby.

    Where this is going

    I see today’s ARTEX as an early draft of a much bigger problem. Picture a future system built on the same agentic ideas, handed the objective of getting into a company. It collects public records, probes exposed services, and when the main app gives it nothing, it refocuses on a forgotten support portal. A response looks promising but the tools cannot answer the next question, so the agent searches GitHub for one, reads its docs, installs it, and spins up new workers to chase separate leads in parallel. Their results flow back and change its priorities again. No operator prescribed those individual steps.

    That is a plausible direction of travel, not a claim that my lab is quietly cloning itself in the closet. And it is not just ARTEX. Any project that bolts an LLM back end onto agentic services is on the same road. As those systems get cheaper and more dependable, threat actors chase more leads with less effort. The limits that remain, compute, access, operational constraints, are shrinking, not growing.

    What you will actually see, and what to do about it

    Stop hunting for the word ARTEX. The model is invisible in the early moves, the user agent is a setting, and the name on the repo changes every week. What does not change is the shape: speed, noise, and the same known attacks run with a persistence no human sustains. So detect the behavior and the outcome, not the name. Correlate application, identity, endpoint and network evidence into a sequence, and act on the impact.

    And fix the boring things, because automation punishes exposure fastest. Prioritize remediation. Reduce exposure, starting with the admin interfaces and forgotten side apps nobody owns, something we have all been saying for at least 20 years. Tighten the non-human identities, limit lateral movement, and test whether your containment actually fires in minutes, because a detection that waits for the next meeting arrives after the data has already left.

    Audit yourself before something that does not sleep does it for you

    1. If ARTEX changed its recon user agent tomorrow, which of your alerts still fire?
    2. Do you alert when one source pulls more hashed JS chunks in a minute than any route actually imports?
    3. Do your API detections trigger on a cluster of 401s and 403s across distinct protected paths from one origin?
    4. Would a POST with Mozilla/5.0 (ARTEX) to a script in your web root page someone, right now?
    5. When php-fpm or java spawns sh with base64 -d in the command line, does anyone get paged?
    6. Would a web server process calling your hosting panel’s local API, or an X-Artex-Auth header on that panel, stand out?
    7. Can you link two or three source IPs hitting the same host the same way seconds apart?
    8. Have you planted a single decoy chunk id or hidden canary link anywhere?
    9. If an intrusion went from first contact to privileged access in under three hours, would your response keep up, or arrive in time for the postmortem?

    The bottom line

    ARTEX gives us something concrete to study today, so we can prepare now instead of reacting later. It is not a new kind of attacker. It is your old attacks, automated, backed by a model you will never see in the first move, run at a speed and with a persistence a human will not match. There is one ARTEX behavior and a closet full of costumes. Detect the behavior, and let the costume change.

    Test yourself the way attackers will: continuously, from the outside, with the same kind of agentic tooling, under written scope, against systems you own. Find the unlocked doors before something that never sleeps does. And if you would rather not lose 50 hours of sleep doing it yourself, that is literally what we do at ThreatHunter.ai. Let’s talk.