SkillAgentSearch skills...

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/ARTEX

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill
🔌

MCP Server

Model Context Protocol server

Quality Score

95/100

Category

Security

Supported Platforms

Claude Code
Claude Desktop

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.

Substance
30/30
Structure
20/20
Description
12/15
Adoption
18/20
Freshness
15/15

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 found

Our 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.

SkillScoreStarsUpdatedFormat
ARTEX (this skill)by BaaRai9515.7ktodayMCP Server
claude-memby thedotmack100119.0ktodayCLAUDE.md
Agent-Reachby Panniantong100114.0ktodayCLAUDE.md
hyperframesby heygen-com10088.2ktodayCLAUDE.md
rufloby ruvnet10082.3ktodayCLAUDE.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.
<div align="center"> <img src="web/public/logo.svg" width="84" alt="ARTEX logo" />

ARTEX

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.

Release License CI Go

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 | | :---: | :---: | | Tasks | Findings |

| Task execution: sessions and tool calls | Exploration graph | | :---: | :---: | | Execution | Exploration graph |

| Asset coverage graph | Traffic recording | | :---: | :---: | | Asset coverage graph | Traffic |

| Human-in-the-loop chat | Interception approvals | | :---: | :---: | | Chat | Interception |

<details> <summary>More screenshots (assets, agents, LLM, logs)</summary>

| Assets | Agent management | | :---: | :---: | | Assets | Agent |

| LLM configuration | Backend logs | | :---: | :---: | | LLM | Logs |

</details>

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 / hint nodes connected by spawns / derived_from / yields / proves edges 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 (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.

    <details> <summary>Using the traffic capture extension</summary>
    • 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.
    </details>
  • Verified findings: findings carry a POE level, a verification status and a note; a finding is verified only 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 retester agent re-runs a finding with optional fixed version/conditions, records Still reproducible / Fixed / Cannot confirm, and can move the finding to Fixed automatically. 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, regex or 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"] covers git push --force, but git -C /repo push matches nothing). Each approval records who decided: human, rule, model or system.
  • 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_TURNS cap a whole task (planner and workers); ARTEX_INTENT_BUDGET_TOKENS / `ARTEX_

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars15.7k
CategorySecurity
Updated11h ago
Forks6.0k

Languages

Go

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions