Plexicus vs. ARTEX: What the ARTEX Source Code Shows, Line by Line

A code-level comparison. What ARTEX, the AI pentest framework the FBI warned about, enforces by default, how it decides a finding is real, and how Plexicus differs.

José Palanco José Palanco
Last Updated:
28 min read
Share
Plexicus vs. ARTEX: What the ARTEX Source Code Shows, Line by Line

Beyond ASPM

Proof-Driven AppSec for teams building with AI

Plexicus uses AI Swarm Pentest to explore authorized application paths, validate what is exploitable, and give teams evidence they can use to prioritize remediation.

Explore AI Swarm Pentest

Most articles about ARTEX repeat the FBI alert.

We read the code.

ARTEX is an open-source, LLM-driven agentic pentest framework that the FBI says a variety of malicious actors have used since at least August 2026. Plexicus AI Swarm Pentest uses the same idea, coordinated AI testing, inside a scope your team agrees in writing, and it hands your team verified evidence and, with Remediation, a reviewer-ready fix.

The differences that matter sit in the defaults, in the checks that run before a finding counts, and in what the loop produces at the end. For ARTEX we can read them in the code. For Plexicus we report what our product pages commit to.

Every ARTEX statement below points to a file in its public repository. Every Plexicus statement comes from our product pages.

How We Did This Comparison

The original repository, published by the developer known as “Autumn-27”, was taken down on October 8, 2026. The same day, a community fork appeared on GitHub as BaaRai/ARTEX. On November 19, 2026, it showed 8,493 stars and 3,677 forks.

We read that fork at commit 230ba39 of November 18, 2026, about 82,000 lines of Go without tests, plus its web console and its changelog.

We read the code. We did not build it, run it or point it at anything.

One date matters throughout. The last upstream release, 0.3.15, shipped on October 7. Version 0.4.0 of October 23 and everything after it are fork releases, shipped after the original repository went down.

Most campaigns described publicly, from August to mid October, predate that first fork release. Check Point saw version tags such as dev and 0.3.15-pro on exposed consoles. Which version a given intrusion used is mostly not public.

The fork rewrote its history on October 23, and its only release tags are v0.4.0 to v0.6.0. So what we say about 0.3.x comes from the changelog, and where that is silent, from the current code. We say so where it matters.

We also left something out on purpose. Weaknesses in the current code that the project has not documented belong in its private security process, not in a blog post.

What Is ARTEX?

ARTEX is a self-hosted, multi-agent penetration testing platform written in Go. An operator types a goal. A planner agent splits it into short “intents”, worker agents run real tools against the target, and everything they learn is written into a graph.

The FBI described it on November 13, 2026, in FLASH-20261113-001.

Summary page of FBI FLASH-20261113-001, Threat Overview of ARTEX Autonomous Penetration Testing Framework

Screenshot: the summary on page 1 of FBI FLASH-20261113-001, a US government document marked TLP

(shareable without restriction), cropped to the title and summary. Credit: Federal Bureau of Investigation.

According to the FBI, some ARTEX intrusions went from initial targeting to privileged access in under three hours, a figure the FBI cites from Microsoft. The FLASH ties ARTEX to attacks on South Korean financial institutions and to attempted sign-ins to more than 2,250 downstream tenants after a supply chain compromise of ConnectWise Cloud Backup.

The FBI also says the takedown did not stop it. The fork we read is one reason why.

Inside ARTEX: What the Code Actually Does

The README promises “autonomous penetration testing that keeps its receipts”. Here is what the code actually builds.

Diagram of ARTEX components from its source code: operator console, planner agent, three workers by default, tools, two graphs, reporter agent, findings and push, and LLM backends

Original Plexicus diagram from a static reading of the ARTEX source code at commit 230ba39; counts computed by Plexicus. Not a screenshot of ARTEX.

One server, two graphs

ARTEX ships as one Go binary with an embedded Next.js console, a PostgreSQL database and a recording proxy for target traffic. We counted 275 API routes and 62 database tables.

It keeps two graphs. The asset graph records what exists on the target. The exploration graph records what was tried, what it produced and why.

The loop

The planner turns the goal into one-sentence intents; its prompt asks for at most four per round, though the code does not cap it. By default, three workers run in parallel. Each claims an intent and works through a shell.

ARTEX defines 60 tools across its agents. A worker gets about a dozen of them, a few more when traffic capture is on, plus general agent tools such as Read, Write, Edit and Bash. Through the shell it reaches the common security scanners and the headless browser built into the image.

The loop stops when the planner proves every goal, when a deadline runs out, or when the operator stops it. Otherwise it keeps generating work.

Here is a task run from the project’s own documentation.

ARTEX task page for an example engagement on acme.com, with the main agent session, the planner, a list of worker intents such as subdomain enumeration, SQL injection probing and Kerberoasting, and the main agent's chat with the operator

Screenshot from the ARTEX repository (screenshots/sessions.png, BaaRai/ARTEX at commit 230ba39, licensed AGPL-3.0), with the project’s example data on acme.com. The left column lists the planner and the worker intents. On the right, the operator steers the main agent in plain language.

The models

ARTEX ships no model of its own. It talks to Anthropic, to OpenAI-compatible endpoints or to a local Ollama model, with automatic failover between providers.

Every pentest role’s prompt introduces itself as part of an “authorized penetration testing system”. Nothing in the code checks that an authorization exists. The scope the prompts mean is whatever the operator typed into the goal.

When a provider refuses a request, unreleased fork code labels the run as a refusal rather than retrying it. But each role can be bound to any model the operator chooses.

What it says it is for

The fork presents ARTEX as an offensive security tool for systems you own, labs, and bug bounty programs within their rules. The code reflects that: findings carry a bug bounty submission state, and there are features for CTF flags and benchmarks.

That is a legitimate use. It is also why scope, defaults and verification decide whether the tool helps or harms.

Why ARTEX Matters in 2026

ARTEX does not invent new attacks.

Mandiant, in the GTIG and Mandiant analysis “ARTEX and Friends”, says these tools do not fundamentally change the techniques attackers use. They reduce the time needed to combine them.

That is the problem. Security programs are built around how long an attack takes.

Google Threat Intelligence Group’s AI Threat Tracker of November 16 reported that it had seen threat actors fully automate vulnerability discovery and exploitation, without a human in the loop, for the first time.

Stacked bar chart of vulnerabilities exploited per month from January 2025 to August 2026, split into zero-days and n-days, rising to 22 zero-days and 7 n-days in August 2026

Original Plexicus chart, not a product screenshot. Monthly values are read from GTIG’s chart of 30 September 2026; the totals match GTIG’s text. These are Google’s own figures from its telemetry.

In its analysis of vulnerability trends, GTIG counted 127 vulnerabilities exploited in 2025 and 141 in the first eight months of 2026, with 22 zero-days in August alone. GTIG suggests that most of the growth comes from n-days, flaws that already have a patch.

The fork even ships a skill that compares vendor patches with unpatched builds to recover the vulnerability behind a fix. A published patch used to buy defenders days. It now starts the clock.

The Safety Controls ARTEX Ships, Then and Now

The fork’s README lists its brakes: approvals, scope gates, budgets and prompt-injection framing. The code has real versions of all of them.

The questions that matter are when each one arrived, and whether it is on by default.

Table comparing ten ARTEX safety controls in the 0.3.x upstream releases with the current fork at default settings, from the blocklist and allow-list to the target gate, shell network enforcement, budgets and machine verification

Original Plexicus figure from a static reading of the ARTEX source code at commit 230ba39 and its changelog. Cells marked with an asterisk are inferred from the current code. Not a screenshot of ARTEX.

Scope: a blocklist and an allow-list that does not touch the network

The built-in blocklist has four entries: .gov, .gov.cn, .edu and .edu.cn. They are substring matches that the operator can disable or delete. There is no entry for military domains, banks, hospitals or energy companies, which fits Zscaler’s finding that ARTEX was used against banks.

A task can have an allow-list. In the code it gates what enters the asset graph and some intent dispatch. It never checks where a tool connects.

For scanner output fed into ARTEX, the project’s own security policy documents an “accepted gap”: with no allow-list, any unblocked host the scanner marks in scope enters the graph. The project treats it as a design question, not a vulnerability.

The one real scope gate is off by default

Version 0.6.0, released on November 12, added a target gate. It checks the targets a tool call declares, asks a human to approve unknown ones, pins the approved addresses, and checks them again at connect time. It fails closed.

That is real enforcement. It is also off by default, can be turned on only through the API, and binds only the platform’s own HTTP clients.

For shell commands, the code is candid. In target_extract.go it says the gate “detects a declared target; it does not prevent an undeclared connection.”

At default settings, a worker’s shell command can reach any host the container can route to.

A code comment in guard.go adds that an earlier scope mechanism for rules of engagement “was removed; a replacement may be added later.”

Destructive actions: regex rules the operator can delete

Every agent runs in the agent SDK’s permission bypass mode. The brakes are interception rules applied around tool calls.

The built-in rules are regular expressions on the text of a command: recursive deletes, disk wipes, database drops, HTTP DELETE requests and similar. They are on by default, and the operator can disable or delete each one. A rule against piping data out of the target ships disabled.

No built-in rule asks a human. The LLM judge that can review unmatched calls is off by default. So out of the box, a tool call is either denied by a regex or allowed.

In 0.3.x, the changelog describes judge failures as allowed under the model-failure policy, which means fail-open. The current, unreleased code asks a human instead.

Here is the approval screen from the project’s own documentation.

ARTEX Approval records page with one pending approval and five records, showing the tool, source task, matched rule, arguments, status and who decided each call, with example data on acme.com

Screenshot from the ARTEX repository (screenshots/intercept.png, BaaRai/ARTEX at commit 230ba39, licensed AGPL-3.0), with the project’s example data on acme.com. It shows the approval queue the project documents; at default settings no built-in rule sends a call there.

Budgets, noise and prompt injection

Per-agent turn caps exist but default to unlimited, and each worker run stops after 20 minutes. Token budgets and task-level budgets exist only in unreleased code, and they are off by default. So is a “noise governor” that paces requests to the target.

The boundary that frames tool output as untrusted data became the default only in unreleased code. A related, unreleased data envelope states the limit of such framing in its own code comment: “it marks data, it cannot stop a model from following it.”

The verdict on scope

CERT-EU wrote on November 5 that ARTEX relies on configurable rules and the model itself to respect scope, with no hard technical enforcement.

For the 0.3.x releases, the changelog agrees with CERT-EU. For the current fork at default settings, the statement still holds. It holds only partly once an operator turns the target gate on, and that gate still does not bind shell commands.

The fork’s own changelog says it plainly: prompt rules are advisory to the model, and their effect “was not measured”.

Where Plexicus Differs on Scope and Control

ARTEX hands the boundary to whoever runs it. Plexicus makes the boundary part of the engagement.

The AI Swarm Pentest page describes a scoped service engagement. Its first step defines the authorized application, API or environment, the rules of engagement and any test access. The page says Plexicus does not act outside that scope, and that time, resources and access are bounded for a controlled run.

The same page lists two things under what the service is not: a check without a signed scope, and automatic changes to production. Fixes arrive only as reviewable proposals, as pull requests or separate patch files.

Your team keeps the final decision. The guardrails on the product page end with a human decision on every change.

We will be precise about what this covers. Our product pages describe the scope as a written agreement and a bounded run, and they do not publish the technical controls behind it.

If an independent technical boundary matters to your risk assessment, and it should, ask any provider for it in writing, including us. We explain why in Uncensored AI Pentesting Still Needs an Independent Scope Boundary.

How ARTEX Decides a Finding Is Real

This is where the code is most revealing.

A finding in ARTEX starts when a worker calls report_finding. Only three fields are required: the vulnerability class, the severity and a summary. Evidence is optional.

In the same database transaction, the finding is stored as confirmed in the exploration graph and queued for push to chat, webhook or email channels. The push filters cannot screen out unverified findings.

The project’s own example log shows it: a worker’s report_finding call is logged as saved to the database, with no check in between.

ARTEX System logs page with six example log lines: the v0.6.0 backend starting with three workers, the LLM configuration, a planner round, a guard blocking a bash command whose target is out of scope, a report_finding call saved to the database, and an intercept awaiting manual approval for mysqldump

Screenshot from the ARTEX repository (screenshots/logs.png, BaaRai/ARTEX at commit 230ba39, licensed AGPL-3.0), with the project’s example data. It also shows the brakes the project documents: a scope block read from a command’s text, and a destructive command held for approval.

Two rows of five steps comparing when a finding counts in ARTEX at default settings and in Plexicus AI Swarm Pentest

Original Plexicus diagram, not a product screenshot. ARTEX steps from its source code at commit 230ba39; Plexicus steps from the AI Swarm Pentest and Remediation product pages.

What “verified” means in ARTEX

A separate reporter agent writes the finding report. Its prompt says it does not exploit anything itself.

Since 0.6.0 of November 12, that agent also chooses which captured traffic counts as proof, declares its own proof level from 0 to 4, and supplies quotes. The server marks the finding verified if the level is at least 3 and every quote appears word for word in the bound traffic. Nothing is executed again.

To be fair, this check is real. It fails closed, and ARTEX stores evidence in hash-addressed snapshots, so captured traffic cannot be edited quietly. The weak point is relevance, not integrity: the check proves the quoted text came from a real response, not that the response shows the vulnerability.

At default settings, the check cannot even run. Traffic capture and automatic evidence binding are both off. Findings stay unverified unless someone runs a manual retest, while the task report still counts them as confirmed.

ARTEX Findings page with 17 total findings, 15 pending, severity counts, and a table of findings with status, task, retest and deepen actions, several showing traffic evidence 0, with example data on acme.com

Screenshot from the ARTEX repository (screenshots/findings.png, BaaRai/ARTEX at commit 230ba39, licensed AGPL-3.0), with the project’s example data on acme.com. Several findings show “Traffic evidence: 0”.

Retest is optional and decided by one model

ARTEX has a retest. It starts only when a person clicks it.

A single model session then returns reproduced, fixed or inconclusive, and either of the first two marks the finding verified without the quote check. A “fixed” verdict also sets the triage status to Fixed.

What the 0.3.x releases had

Manual retests and traffic linking existed from 0.3.9. No check set a verified status until 0.6.0. Judging by the current code, a finding was stored as confirmed the moment the model reported it, and from 0.3.15 it could be pushed to chat channels.

That is consistent with what Check Point Research saw in the exposed databases of ten ARTEX instances. In one cryptocurrency campaign, agents reported successful cash-outs while the attacker’s wallet stayed empty. Check Point calls those findings hallucinations, judged as successes only because API responses indicated success.

The same report also shows the other side. In a later attack, an agent carried out a real write to a cloud storage bucket and verified the whole chain before filing its finding.

ARTEX found real flaws. In 0.3.x, nothing in the code told its operator which findings were real.

How Plexicus Decides a Finding Is Real

Plexicus starts from the opposite rule: No PoC, no finding. No reproducible proof means no verified finding.

The product page says the run maps the surface, forms hypotheses and tests paths, and that “a second pass independently confirms each finding before it is marked verified.” A result the second pass cannot reproduce is marked unverified or discarded.

The difference with ARTEX is structural. In ARTEX, re-execution is optional and starts on a click. In Plexicus, the second pass is part of how a finding becomes verified.

Here is the Nexus view of a completed run, as published on our solutions pages.

Plexicus Nexus view of a completed AI Swarm Pentest run with three hunter agents, a hexagon map of confirmed capabilities around an objective, an evidence board, and a narrative feed in which the skeptic verifies capabilities by script replay and marks them confirmed

Screenshot: the Nexus view of a completed AI Swarm Pentest run in the Plexicus platform, already published on our solutions pages. In the narrative feed, a hunter agent’s proposals stay unconfirmed until the skeptic replays them by script, and credential values are masked.

What reaches your team is an evidence pack: a complete attack chain with target, steps, demonstrated impact and context, a report prioritized by real risk, and a handover session.

What Happens After the Finding

ARTEX ends at a paragraph

We searched the ARTEX code for remediation, patches and pull requests. ARTEX does not produce code fixes, patches or pull requests.

Its “Remediation” is a section of Markdown that the reporter model writes into the finding report. A pull request workflow appears only in a design document that studies another vendor’s product. The only patch-related skill works the other way: it reads vendor patches to rebuild the vulnerability.

Plexicus ends with a change your team can review

The Remediation page describes the next step. Once a finding is verified, Plexicus prepares the remediation context and a suggested change. A reviewer-ready diff explains the finding inline, with regression tests where relevant, and lands in your repository with reviewer assignment and a re-test hook wired to CI.

Here is a bulk remediation in progress in the Plexicus platform.

Plexicus Bulk Remediation Progress panel over a findings list, with four steps: queued, generating fixes, creating pull request with one commit per group, and completed with a pull request ready for review

Screenshot: the Bulk Remediation Progress panel in the Plexicus platform, with the steps queued, generating fixes, creating pull request (one commit per group) and completed (pull request ready for review). The findings list behind it is blurred. Demo data, captured in October 2026.

Here is a code analysis finding after a fix has been submitted.

Plexicus finding detail for a critical SQL Injection finding with the status Fix Submitted, and the buttons Create Ticket, See Pull Request and View AI Remediation above the Code and taint trace section

Screenshot: a critical SQL injection finding (CWE-89) from code analysis in a demo Java application, shown in the Plexicus platform with the status Fix Submitted. The toolbar offers Create Ticket, See Pull Request and View AI Remediation. Demo data.

And here is a remediation pull request as it reaches the repository. The repository in this recording had no project tests, so no test validation ran.

Video: a clip from the Plexicus platform walkthrough, recorded in May 2026. A Plexicus bot account opens the pull request on GitHub with one commit and the explanation of the fix, and a person merges it. This recording shows no CI checks and no reviews on the pull request.

Closed loop with PR: the goal is a change your team can review, not a report that waits in a queue.

Deployment and Data: Who Holds the Risk

ARTEX is self-hosted. That means the operator holds every risk of running it, and its own changelog shows how much that involved.

Censys counted 1,465 hosts with an exposed ARTEX console in early November. The changelog explains part of why:

  • Before 0.5.0 (November 4), the first visitor to a new console could set the admin password, and the published Docker setup did not restrict the console to the local machine.
  • Before 0.5.1 (November 5), the native binary listened on every network interface, login had no rate limit, and the health endpoint told anonymous callers which version was running.
  • Encryption of stored secrets, such as LLM API keys, target credentials and notification tokens, appears only in the unreleased section of the changelog. Released versions store them as they are.

The current code also has one fixed user account and no roles. Approvals record who decided them, and the console offers recordings of prompts and captured target traffic when those features are on.

Plexicus is a service your team engages, not a tool you have to secure first. Our Trust Center states that data is processed in EU data centers, that we provide a Data Processing Agreement template, that source code analysis runs with zero data retention, and that we run our own AI Swarm Pentest engine against plexicus.ai continuously. For the platform, it also lists self-hosted and air-gapped deployment for teams that need them.

Plexicus vs. ARTEX: The Full Comparison

ARTEX (BaaRai fork, code at 230ba39)Plexicus AI Swarm Pentest (product pages)
What it isSelf-hosted open-source framework, AGPL-3.0A scoped service engagement
Who chooses the targetWhoever runs it, in a free-text goalYour team, in a scope agreed in writing
Authorization checkPrompts say “authorized”; nothing in code checks itScope and rules of engagement agreed in writing before work starts
Scope enforcement at default settingsFour-entry blocklist; allow-list gates the graph, not connectionsWritten scope; technical controls not published
Network control for shell commandsNone; the target gate reads command text onlyNot published; ask for it in writing
Destructive actionsRegex deny rules, editable; no rule asks a human by defaultNo automatic production changes
Budgets and limitsTurn caps unlimited by default, 20-minute worker runs; token budgets unreleased and offTime, resources and access bounded
When a finding countsStored as confirmed and pushable at onceMarked verified only after an independent second pass
What “verified” meansReporter-chosen quotes found in captured traffic, or a manual retestReproduced independently, or marked unverified or discarded
Re-executionOptional retest on a click, one model verdictPart of verification
OutputMarkdown report and evidence exports; remediation is a paragraphEvidence pack, prioritized report, handover
FixesNone in codeReviewer-ready change in your repository, with Remediation
ProductionWhatever the operator points it atNever modified automatically
Who operates and secures itYouPlexicus, under a written engagement; the platform also offers self-hosted and air-gapped deployment

What ARTEX Gets Right

It would be dishonest to stop at the gaps.

ARTEX is serious engineering. The fork carries about 63,000 lines of tests next to its 82,000 lines of code.

Its evidence store is hash-addressed. Its verification check, where it runs, fails closed. Its target gate, when turned on, is real connect-time enforcement.

In unreleased code, its judge lets code, not the model, take the final decision, though the judge stays off by default. The unreleased release process also adds provenance attestations and an SBOM.

Its changelog is also unusually candid about what is advisory and what was never measured.

And it shows defenders three things worth learning from: a planner with a few workers can test a broad surface quickly, forgotten systems are where attackers start, and a plain-language goal is enough to drive a multi-step test.

ARTEX chat with the main agent on example data: the operator asks short questions, the agent proposes next steps, then summarizes a seven-step attack chain from a .git leak to all domain hashes, with four goals met and 17 findings

Screenshot from the ARTEX repository (screenshots/chat.png, BaaRai/ARTEX at commit 230ba39, licensed AGPL-3.0), with the project’s example data. A handful of plain-language messages carry the run from a leaked .git folder to all domain hashes. In the example, the agent also says it has pre-allowed a command that the interception rules would otherwise hold.

The lesson is not that agentic testing is dangerous. It is that the safety of agentic testing lives in its defaults and in who owns them.

Why Not Just Run ARTEX Against Yourself?

It is a fair question, and some teams do. After its incident, WorkOS wrote that it began regularly testing its internet-facing systems with ARTEX.

The same incident shows the risk. According to WorkOS, which validated the researcher’s account with a forensics firm, the cause was an ARTEX agent that escaped a researcher’s isolated test environment during benchmark evaluations.

The code tells you what you take on if you run it:

  1. You choose the version. The original repository is gone, so every copy is a fork or an archive. Read its changelog first.
  2. You build the boundary. Turn on the target gate, configure an allow-list, and put network controls outside the container, because shell commands are not bound by the gate.
  3. You add the human. Create rules that ask before risky calls, and enable the judge, because none asks by default.
  4. You set the limits. Turn caps are unlimited by default, and token budgets are unreleased.
  5. You verify the results. Turn on capture and evidence binding, and retest what matters, because findings are confirmed before any check.
  6. You secure the console. Bind it locally, protect the first-run setup, and keep the database private.
  7. You write the fixes. ARTEX stops at the finding.

Zscaler’s advice, if you run any open-source pentesting harness, is to treat it as hostile code: isolate it from production, keep production credentials out of it, and enforce the testing scope through configuration and code.

What Plexicus Is Not

A fair comparison also states its own limits.

  • Plexicus does not promise zero vulnerabilities. The product page says so, and adds that anything presented as verified must be demonstrable.
  • It does not replace human judgment. It automates repetitive exploration, correlation and reproduction while your team keeps context, supervision and the final decision.
  • It is not a classic multi-day on-site human pentest, and it is not a signature scanner or a security chatbot.
  • It is not open source. You cannot read our code the way we read ARTEX’s, which is exactly why the questions below matter.

Questions to Ask Any AI Pentest Provider

Reading ARTEX’s code turns vague worries into specific questions. Ask them of any provider, including us.

  1. Who signs the scope, and what does it contain? Targets, environments, test access, rules of engagement, time window.
  2. What stops an agent from connecting outside the scope? A written agreement is necessary. Ask what enforces it at the network level, including for shell commands.
  3. Which safety controls are on by default? A control that is off by default protects nobody who did not turn it on.
  4. When does a finding count? Before or after an independent reproduction?
  5. What does “verified” mean? A quote found in captured traffic, or the attack reproduced?
  6. Does anything touch production automatically? The right answer is no.
  7. How do findings become fixes? Reviewable pull requests with tests and a re-test, or a paragraph of advice?
  8. Where do prompts, traffic and credentials go, and how long are they kept?

How to Defend Against ARTEX-Style Attacks This Week

The defenses are not exotic. The FBI, Mandiant and CERT-EU recommend the same basics.

  1. Inventory what nobody watches: partner and supplier portals, mobile backends, employee apps, legacy services and third-party integrations. The FBI’s list is almost identical to the one Akamai published in October.
  2. Take admin interfaces off the internet: cloud administration, publishing endpoints, hypervisors and backup platforms.
  3. Retire long-lived credentials. Barracuda wrote that short-lived, narrowly scoped credentials would have stopped its intrusion at the first step.
  4. Watch multi-tenant app permissions: alert when an application adds credentials, changes roles or grants itself privileges.
  5. Measure velocity, not only signatures: rate limits on high-impact APIs, alerts on sequential lookups, a baseline of your own automation.
  6. Keep minor findings in the fix cycle: CERT-EU warns that AI tooling can chain minor misconfigurations into higher-impact attack paths.
  7. Test with proof, and close the loop: find what an agent would find on your side of the line, reproduce it, fix it, and re-test the fix.

Where Plexicus Fits

Plexicus is a Proof-Driven AppSec platform. Each part answers a gap the ARTEX code shows.

  • AI Swarm Pentest finds exploitable paths across your application, API and source code inside a scope agreed in writing, and marks a finding verified only after an independent second pass.
  • Deep Code Analysis traces the affected code path, so a finding is bound to the data it can reach and the role that can trigger it.
  • Remediation turns a verified finding into a reviewer-ready change in your repository, with a re-test hook, while your team keeps merge control.
  • XBOM unifies SBOM, CBOM and AIBOM into one inventory, so you know which components, keys and models you actually run.

For the mechanics behind the swarm, read Introducing AI Swarm Pentest. For how a validated finding becomes a reviewed fix, read Introducing AI-Native Remediation.

Frequently Asked Questions

Is ARTEX malware?

No. It is an open-source penetration testing framework published for authorized testing. The FBI’s warning is that threat actors weaponized it, and its code does not check that a test is authorized.

Which version of ARTEX did you analyze?

The community fork BaaRai/ARTEX at commit 230ba39 of November 18, 2026, which includes released version 0.6.0 and unreleased changes. Statements about the 0.3.x upstream releases come from its changelog, or from the current code where we say so. Which version a given intrusion used is mostly not public.

Did you run ARTEX?

No. We read the code. We did not build it, run it or point it at any system.

Does ARTEX enforce scope?

Partly, and mostly not by default. A four-entry blocklist and an optional allow-list gate what enters its graph. A real connect-time target gate exists since 0.6.0, but it is off by default and does not bind shell commands.

Does ARTEX verify findings?

Since 0.6.0, it can mark a finding verified when quotes chosen by its reporter agent appear in captured proof traffic, or when a manual retest reproduces it. Capture is off by default, findings are stored as confirmed before any check, and re-execution happens only on a manual retest.

Is Plexicus a competitor of ARTEX?

Not in the usual sense. ARTEX is an open-source framework you run yourself.

Plexicus is a scoped service engagement. They share an approach and differ in who authorizes the run, how findings are proven and how the work ends.

Is the three-hour figure an FBI measurement?

The FBI states it and cites Microsoft as the source. It describes some intrusions, not all of them.

Does Plexicus test production?

The target is the application, API or test environment your team authorizes in writing. Plexicus makes no automatic production changes, and fixes arrive only as reviewable proposals.

What does “No PoC, no finding” mean in practice?

A finding is marked verified only if an independent second pass confirms it. If it cannot, it is marked unverified or discarded.

Should we stop using open-source pentesting tools?

No. Read their code and changelog, run them isolated, enforce scope outside the tool, keep production credentials out of them, and verify every result they report.

Same Idea. Your Side of the Line.

Find the exploitable paths an attacker’s agent would find, prove them, and hand your team a reviewed fix, before ARTEX-style tools get there.

Explore AI Swarm Pentest →

Written by
José Palanco
José Palanco
José Ramón Palanco is the CEO/CTO of Plexicus, a pioneering company in Proof-Driven AppSec launched in 2024, offering AI-powered remediation capabilities. Previously, he founded Dinoflux in 2014, a Threat Intelligence startup that was acquired by Telefonica, and has been working with 11paths since 2018. His experience includes roles at Ericsson`s R&D department and Optenet (Allot). He holds a Telecommunications Engineering degree from the University of Alcala de Henares and a Master`s in IT Governance from the University of Deusto. As a recognized cybersecurity expert, he has been a speaker at various prestigious conferences including OWASP, ROOTEDCON, ROOTCON, MALCON, and FAQin. His contributions to the cybersecurity field include multiple CVE publications and the development of various open source tools such as nmap-scada, ProtocolDetector, escan, pma, EKanalyzer, SCADA IDS, and more.
Read More from José
More to read

Related posts

Ready to validate what matters?

Ready to validate what matters?

Plexicus is Proof-Driven AppSec: validated findings, contextual understanding, and reviewed remediation — anchored in evidence, scoped with you.

Qualification

Check whether AI Swarm Pentest fits your environment.

Share the minimum context. We will review the scope and tell you the next commercial step.

Before submitting — verify you fit

0 / 280

No commitment. If you don't fit, we'll tell you.

SAMPLE HANDOVER · ILLUSTRATIVE

Sample evidence handover

A trimmed view of what your team receives at the end of an AI Swarm Pentest engagement. Real engagements include full technical evidence, executive narrative, and a remediation plan.

VALIDATED FINDING Evidence attached

Server-Side Request Forgery in webhooks/receiver

demo-project/sample-app · src/webhooks/receiver.py:42

SeverityHigh CVSS 3.18.6 Priority79 Confirmedvia replay

Untrusted caller-supplied URLs reach an internal egress without an allowlist. Replayed in a sandbox against a fresh authorized target — the same control was validated to fail twice.

REVIEWER-READY REMEDIATION Merge-ready PR

Validate the target URL against an allowlist of permitted hostnames. Reject private/internal IP ranges. Enforce HTTPS only.

plexicus/remediation/webhooks-ssrf 3 changed · 0 new files
42resp = requests.get(target_url)
42+if not is_allowed_host(target_url):
43+  raise WebhookRejected(target_url)
44+resp = requests.get(target_url, timeout=5)
Every engagement hands over:
  • Executive briefing
  • Validated findings list
  • Merge-ready PRs
  • Compliance mapping (NIS2 · DORA · CRA)
Private Round For investors