ARTEX-Global: When Your Penetration Testing Framework Needs to Think in Five Languages
Hook
The Korean data breach investigation that put ARTEX on the map in October 2024 wasn't caused by the tool—it was discovered because attackers were already using autonomous LLM agents, and defenders had no way to understand what they were facing.
Context
Traditional penetration testing frameworks like Metasploit require human operators to make every decision: which port to scan next, which exploit to try, how to pivot after initial access. This works when you're modeling human attackers, but modern threat landscapes include a new adversary: autonomous AI agents that can plan multi-stage attacks, accumulate knowledge across targets, and make tactical decisions without human intervention.
ARTEX emerged from Chinese security research as an answer to this gap—a framework where LLM-driven agents autonomously conduct penetration tests using real offensive tools. The original ARTEX (Autumn-27/ARTEX) proved the concept but remained locked to Chinese, limiting its utility for international red teams and detection engineers who needed to understand autonomous AI attacks in their own language. ARTEX-Global fork addresses this by adding English, Korean, Spanish, and Japanese support, but does so with an architectural approach that reveals fundamental tensions in multilingual LLM systems: do you translate everything and risk degrading agent performance, or keep the reasoning layer in the original language and only localize output?
Technical Insight
ARTEX's architecture centers on a three-tier agent hierarchy that mirrors how human penetration testers actually work. A planner agent receives high-level objectives ('compromise acme.com'), decomposes them into concrete subtasks ('enumerate subdomains', 'scan for vulnerabilities on discovered assets'), and distributes work. Worker agents autonomously execute these tasks by invoking real tools—nmap, curl, custom scripts—in containerized environments with bind-mounted skill directories. A reporter agent synthesizes findings into coherent narratives. All state persists in PostgreSQL as a graph: assets are nodes, vulnerabilities and relationships are edges, enabling agents to reason about lateral movement opportunities that single-target scanners miss.
The internationalization layer reveals the framework's most interesting architectural decision. Rather than translating the entire prompt chain—which would require re-benchmarking agent performance in each language—ARTEX keeps all reasoning prompts in the original Chinese and uses a code-enforced directive to force only final output into the target language. In agent/prompt.go, you'll find logic similar to:
func BuildWorkerPrompt(task Task, lang string) string {
// Core reasoning prompt stays in original Chinese
basePrompt := `你是一个渗透测试专家。分析目标并选择合适的工具...
[detailed Chinese instructions for tool selection, reasoning, error handling]
`
// Language directive appended to force output translation
outputDirective := map[string]string{
"en": "\nIMPORTANT: Provide your final summary in English only.",
"ko": "\n중요: 최종 요약은 한국어로만 제공하십시오.",
"es": "\nIMPORTANTE: Proporcione su resumen final solo en español.",
"ja": "\n重要: 最終要約は日本語のみで提供してください。",
}[lang]
return basePrompt + outputDirective + formatTaskContext(task)
}
This is pragmatic but fragile. Frontier models like GPT-4 generally respect the directive, but cheaper models (gpt-4o-mini, domestic Chinese alternatives) frequently fall back to the base language or leak English technical terms in structured fields. The system includes no validation layer to catch these regressions—you discover them when reviewing agent reports.
Real tool execution happens through a skill system that's more flexible than hardcoded modules. The ./skills directory contains executable scripts that workers can invoke. A skill for subdomain enumeration might look like:
#!/bin/bash
# skills/subdomain-enum.sh
DOMAIN=$1
OUTPUT_FILE=$2
subfinder -d "$DOMAIN" -silent -o "$OUTPUT_FILE.subfinder"
amass enum -passive -d "$DOMAIN" -o "$OUTPUT_FILE.amass"
cat "$OUTPUT_FILE.subfinder" "$OUTPUT_FILE.amass" | sort -u > "$OUTPUT_FILE"
Worker agents receive tool descriptions via prompt context and autonomously decide when to invoke them, passing parameters and interpreting outputs. This is fundamentally different from Metasploit's module system where humans select exploits; here, the LLM chooses tools based on accumulated knowledge in the PostgreSQL graph.
The vulnerability graph representation is where multi-target reasoning emerges. When a worker discovers a Jenkins server on subdomain-a.target.com and later finds SSH credentials on subdomain-b.target.com, the graph structure allows the planner to recognize pivot opportunities: 'use credentials from B to access Jenkins on A, then deploy a reverse shell to the internal network.' Single-target scanners cannot connect these dots because they don't maintain cross-target state.
The Go backend serves a Next.js static frontend via go:embed when built with the embedui tag, keeping deployment to a single binary. The recording proxy on port 8788 captures all agent HTTP traffic, critical for understanding what autonomous tools are actually doing—LLM decision-making is opaque, but network traffic is observable. This proxy generates PCAP files that blue teams can replay through their SIEM to validate detection rules.
OpenAI-compatible LLM routing allows swapping backends by changing a base URL in configuration profiles. This matters for teams in jurisdictions with API export restrictions (China, Russia) or air-gapped labs that need to run self-hosted models. However, the system assumes OpenAI token budgets—the default 32,768 exceeds gpt-4o's 16,384 limit, causing silent 400 errors that manifest mid-pentest as stuck agents. There's no startup validation of model capabilities against configured budgets.
Gotcha
The prompt-based language directive is a hack, not an architecture. ARTEX's i18n works when you're using GPT-4-class models and reviewing reports manually, but degrades unpredictably with cheaper alternatives or when agents generate structured output (JSON findings, command parameters). You'll discover mid-engagement that half your Korean reports contain Chinese technical terms, or that the Spanish planner is issuing English task descriptions to workers. There's no validation layer or fallback strategy—the system just hopes the model complies.
The security surface is alarming for a tool designed to execute offensive operations autonomously. Worker containers have bind mounts to host directories (./skills, ./data), and agents execute arbitrary tool commands. A compromised LLM—either through adversarial prompting or a malicious model endpoint—could write malicious scripts to the skills directory and potentially escape container isolation via misconfigured Docker networking or volume permissions. The system includes no sandboxing beyond default Docker isolation, no command whitelisting, and no output sanitization. For a framework explicitly warning about the October 2024 Korean breach investigation, the lack of defensive depth in its own execution layer is conspicuous.
Cost control is absent. Agents run in concurrent loops (default 3 workers, configurable) with no per-task budget ceiling or rate limiting. A runaway planning loop—easy to trigger by feeding the planner an ambiguous objective—can burn through thousands of API calls before you notice. The upstream repository being 'currently unreachable' means no security patches, and the fork maintainer has inherited full CVE responsibility for complex multi-agent offensive code already implicated in real-world incidents.
Verdict
Use if: You're a detection engineer building SIEM content for autonomous AI-driven attacks and need realistic telemetry that static analysis cannot provide. Use if you're conducting authorized red team research into how LLM agents conduct multi-stage exploitation and need a working implementation to probe defensively. Use if you operate in jurisdictions requiring non-English security tooling and can tolerate fragile i18n that degrades with model choice. Use if you're building purple team labs where the included Sigma rules and detection artifacts justify the operational complexity. Skip if: You lack explicit written authorization for autonomous offensive testing—this tool's autonomy makes scope creep trivial and its legal surface area is massive. Skip if you need production-grade internationalization; the language layer is a research prototype. Skip if you're looking for conventional penetration testing; Metasploit offers better reliability, legal precedent, and community support. Skip if you cannot accept the security risks of executing LLM-chosen commands with filesystem access—there are no guardrails beyond Docker defaults.