ARTEX
ARTEX - AI autonomous penetration testing system (English translation; upstream: Autumn-27/ARTEX, AGPL-3.0)
Install / Use
claude mcp add BaaRai -- npx -y github:BaaRai/ARTEXIf the server publishes to npm under a different name, use that package instead — check the repo README.
MCP Server
Model Context Protocol server
Quality Score
Category
SecuritySupported Platforms
Our assessment of ARTEX
ARTEX scores 95/100 on our quality scale, 217th of 1,098 Security skills we index (top 20%).
Its MCP Server is 36 KB long, well organised into 44 sections with 22 code examples: a thorough specification that gives an agent plenty to work with.
With 15,717 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated today, so ARTEX is actively maintained.
- It is released under AGPL-3.0, a copyleft license: you can use it, but modified versions you distribute must carry the same license.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands.
Automated pattern scan on 2026-11-21. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
ARTEX compared with similar skills
All 4 of these similar skills score higher than ARTEX; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| ARTEX (this skill)by BaaRai | 95 | 15.7k | today | MCP Server |
| claude-memby thedotmack | 100 | 119.0k | today | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 114.0k | today | CLAUDE.md |
| hyperframesby heygen-com | 100 | 88.2k | today | CLAUDE.md |
| rufloby ruvnet | 100 | 82.3k | today | CLAUDE.md |
Frequently asked questions
- How do I install ARTEX?
- Run
claude mcp add BaaRai -- npx -y github:BaaRai/ARTEX. The install tabs above show the steps for each supported agent. - Which AI agents does ARTEX work with?
- It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
- Is ARTEX safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. It is AGPL-3.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is ARTEX still maintained?
- The repository was last updated today, so ARTEX is actively maintained.
Skill content
View source on GitHubARTEX
Autonomous penetration testing that keeps its receipts.
(upstream: Autumn-27/ARTEX, AGPL-3.0)
Self-hosted multi-agent offensive security. A planner explores, workers run real tools, and every finding stays bound to the assets and HTTP traffic that prove it.
Quick start · Screenshots · How it works · Install · Configuration · Security
</div>ARTEX is a self-hosted, LLM-driven penetration testing platform. It is not a chat wrapper around a scanner: a planner splits a goal into intents, workers execute them with real tools, and the results are written back into two linked graphs: one for what you know about the target, one for how the test is progressing. Every finding can carry the captured request and response that justify it, and every autonomous action passes through scope rules, approval gates and budgets.
- It explores, it doesn't chat. Goal decomposition, intent dispatch, worker execution and write-back form a closed loop that keeps advancing until the goal is proven.
- Two graphs, one audit trail. The shared asset graph says what exists; the per-task exploration graph says what was tried, what it produced, and why. Anchors link the two.
- Findings with evidence. A recording MITM proxy and a browser extension capture real traffic; findings, evidence quotes and retests are tied to the exact request/response.
- Autonomy with brakes. Human-in-the-loop approvals, argv-prefix rules, scope/deny gates, token and turn budgets, a target noise governor, and prompt-injection framing on tool output.
- Self-hosted and model-agnostic. One Go binary with the Next.js UI embedded, PostgreSQL, your own Anthropic/OpenAI-compatible endpoint, or a local Ollama.
Quick start
git clone https://github.com/BaaRai/ARTEX.git
cd ARTEX
cp .env.example .env # set POSTGRES_PASSWORD (and optionally an LLM key)
docker compose up -d --build # builds from this checkout, starts PostgreSQL
Open http://localhost:8787. On the first visit /setup asks for the one-time setup token
printed at startup:
docker compose logs artex | grep "Setup token"
There is no prebuilt Docker image to pull: the image is always built from your checkout. For all installation paths (script, binaries, source, release archives), see Installation.
Multi-provider workers
In System → LLM, configure the profiles you want to use. In System → Settings, set the concurrent worker count to at least 2 before starting a task (the count applies to subsequently started tasks). In System → Agents → Worker, leave the model set to follow the task; a fixed Worker model takes precedence over rotation.
When creating a task, select both profiles in LLM config chain, arrange their order, and enable Enable multi-LLM worker rotation. For an existing task, open its LLM config control, change the switch or profile order, and save.
Rotation assigns successive worker intents A, B, A, B, regardless of completion order. Separate intents can run concurrently on different providers; each intent keeps its selected provider unless it fails over. Planner and other unbound roles continue using the task's current profile. Turning rotation off restores ordered task-level failover. An excluded provider is skipped, so an intent pinned to an exhausted profile falls back to the task's current profile instead of retrying it; rotation keeps cycling the whole list and does not rebalance around a dead provider. Saving the chain resets their failure state. Changes do not interrupt in-flight calls. The rotation cursor starts again after a server restart and saving the chain does not reset it; the profile order and switch remain persisted.
The task creation and PUT /api/tasks/{id}/llm APIs accept llm_rotate: true alongside
the ordered llm_profile_ids. Omitting llm_rotate on an update preserves its value.
Screenshots
| Tasks | Findings |
| :---: | :---: |
|
|
|
| Task execution: sessions and tool calls | Exploration graph |
| :---: | :---: |
|
|
|
| Asset coverage graph | Traffic recording |
| :---: | :---: |
|
|
|
| Human-in-the-loop chat | Interception approvals |
| :---: | :---: |
|
|
|
| Assets | Agent management |
| :---: | :---: |
|
|
|
| LLM configuration | Backend logs |
| :---: | :---: |
|
|
|
How it works
Dual-graph architecture: exploration graph + asset graph
ARTEX separates what the goals are from how far testing has progressed into two independent graphs linked by anchors:
- Asset graph (shared across tasks). One source of truth for
root_domain / subdomain / ip / service / app / endpoint, owned by companies. Parent-child relationships and deduplication keys are computed by the program; agents only submit raw observations. - Exploration graph (per task). The task's reasoning and progress:
goal / intent / fact / finding / hintnodes connected byspawns / derived_from / yields / provesedges into a lineage chain. - Anchors link them.
exploration_anchors(node_id, asset_id)ties intents, facts and findings to concrete assets: which assets a direction touched, and which intents tested a given asset. This also powers asset test coverage and the coverage graph.
flowchart LR
subgraph EG["Exploration graph (per-task · advance chain)"]
direction TB
G["goal"]
I1["intent A"]
F1["fact"]
I2["intent B"]
FD["finding (vulnerability)"]
G -->|spawns| I1
I1 -->|yields| F1
F1 -->|derived_from| I2
I2 -->|proves| FD
end
subgraph AG["Asset graph (globally shared · source of truth)"]
direction TB
RD["root_domain"]
SD["subdomain"]
SV["service"]
EP["endpoint"]
RD --> SD --> SV --> EP
end
I1 -. anchor .-> SD
F1 -. anchor .-> SV
I2 -. anchor .-> EP
FD -. anchor .-> EP
The planner reads the exploration graph, judges goals, and dispatches intents only when there is an uncovered direction; a worker claims one intent, executes it, writes assets/facts/findings back into both graphs, then stops.
The engine loop
The engine is event-driven: any graph change wakes the planner, workers claim and execute intents,
write-back triggers the next round, until prove_goal closes the task.
sequenceDiagram
autonumber
participant EV as graph-change debounce
participant P as planner
participant FR as frontier intent queue
participant W as worker
participant PX as recording proxy
participant DB as dual graphs + activity
EV-->>P: wake up
P->>DB: read situation (graph_overview prefetch + coverage/scope)
P->>FR: dispatch 0..N intents (with asset_ids)
Note over P,FR: most wake-ups dispatch 0 (no new direction means done)
W->>FR: claimNext claims one intent
W->>DB: fetch the raw assets of the intent's asset_ids
W->>PX: real tool execution (Kali / Bash / HTTP)
PX-->>W: response (fully traced + CA verified)
W->>DB: write back fact / asset / finding + per-step activity
DB-->>EV: graph change
EV-->>P: wake again (closed loop)
Durable attack chains, shared worker memory
Real attack chains are multi-step and ordered (find an injection → get credentials → move laterally). The planner keeps a todolist retained per task across wake-ups: it records the chain once, then dispatches the next step only when its prerequisites are satisfied by facts.
Workers can also search each other's execution traces (search_all_worker_traces,
list_worker_traces, get_worker_trace). Observations that never became formal facts (an error
message, a response snippet, a hidden parameter) are still reusable by the next worker, while each
worker remains confined to the intent it claimed.
Features
Evidence, not chat logs
-
Recording MITM proxy (
:8788) with a generated CA: every Bash/HTTP tool call is traced, and request/response evidence can be bound to a finding. -
Browser extension (
<details> <summary>Using the traffic capture extension</summary>extension/) for authenticated targets: log in once (captcha, email OTP, 2FA included), capture the session, and the requests/responses land in the same traffic store.- Load the unpacked extension from
extension/(Chrome/Edge: Developer Mode → Load unpacked); - In the popup, set your ARTEX URL and token, then press Start capture on the tab you are browsing;
- Use the site normally; text requests/responses are batched to
POST /api/traffic/ingest(authenticated). Binary bodies (images, fonts) are skipped, bodies are truncated at 256 KiB, batches are capped at 50 entries; - Press Stop when done. Everything stays in your local traffic store.
- Load the unpacked extension from
-
Verified findings: findings carry a POE level, a verification status and a note; a finding is
verifiedonly when a bound proof/response and verbatim evidence quotes support it. Gzip/deflate bodies are decoded before the quote check. The findings table supports bulk status updates, and the report and export show each finding's proof strength next to its status. -
Traffic replay: open a captured exchange and replay the recorded request (method, URL, headers and stored body) from the traffic detail; replay stays disabled while only the body preview is loaded.
-
Vulnerability retest loop: a dedicated
retesteragent re-runs a finding with optional fixed version/conditions, recordsStill reproducible / Fixed / Cannot confirm, and can move the finding toFixedautomatically. Original evidence and reports are preserved. -
Reports and exports: findings, evidence and task archives, with traffic snapshots kept encrypted at rest.
Control without slowing down
- Interception gate: every tool call can require human approval, with rules by
string,regexor argv prefix. An argv rule is a JSON array of 1 to 8 tokens (Bash only, for example["git","push"]); it matches only a single simple command whose parsed prefix equals the pattern exactly. Pipes, lists, redirections, prefix assignments, subshells, background jobs, wrapper programs and command/parameter substitutions do not match; flags are ignored by construction (["git","push"]coversgit push --force, butgit -C /repo pushmatches nothing). Each approval records who decided:human,rule,modelorsystem. - Scope and target gate: scope rows define the coverage denominator; assets outside the declared scope are not explored. The target gate (off by default, API-only) can refuse destinations that were not approved.
- Budgets:
ARTEX_TASK_BUDGET_TOKENS/ARTEX_TASK_BUDGET_TURNScap a whole task (planner and workers);ARTEX_INTENT_BUDGET_TOKENS/ `ARTEX_
Truncated for display — read the full file on GitHub.
Related Skills
claude-mem
119.0kPersistent Context Across Sessions for Every Agent – Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
Agent-Reach
114.0kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
hyperframes
88.2kAI video you can actually edit. HyperFrames is a free, open-source AI video editor. Describe any video and get a real project you can change down to the frame.
ruflo
82.3k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
