<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Mikalai Karytka</title>
    <description>The latest articles on DEV Community by Mikalai Karytka (@mkarytka).</description>
    <link>https://dev.to/mkarytka</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4209047%2F48262742-dabb-49b2-b239-2fea55bf0e04.jpeg</url>
      <title>DEV Community: Mikalai Karytka</title>
      <link>https://dev.to/mkarytka</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/mkarytka"/>
    <language>en</language>
    <item>
      <title>62% Fewer Tokens? Not in My Code Reviewer: Testing CodeGraph Three Ways</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Wed, 11 Nov 2026 19:02:13 +0000</pubDate>
      <link>https://dev.to/mkarytka/62-fewer-tokens-not-in-my-code-reviewer-testing-codegraph-three-ways-pg7</link>
      <guid>https://dev.to/mkarytka/62-fewer-tokens-not-in-my-code-reviewer-testing-codegraph-three-ways-pg7</guid>
      <description>&lt;p&gt;&lt;a href="https://github.com/colbymchenry/codegraph" rel="noopener noreferrer"&gt;CodeGraph&lt;/a&gt; promises 62% fewer tokens for coding agents. I tested it three ways in my multi-agent code reviewer, and it saved nothing in any of them. When it replaced the reviewer's own code map, the reviewer found 18% fewer real issues.&lt;/p&gt;

&lt;p&gt;The reviewer is a Claude Code plugin I built that reviews a whole backend instead of one PR (I wrote about it in &lt;a href="https://dev.to/mkarytka/half-the-price-missed-the-production-bug-opus-vs-sonnet-as-code-reviewers-4khp"&gt;my previous post&lt;/a&gt;). CodeGraph is an open-source MCP server that indexes a repository into a graph of symbols and calls, so an agent can ask "how does X reach Y" in one call instead of a grep-and-read loop. My reviewer reads a lot of code, so a code graph should make it cheaper. I measured that on the same four private projects as last time, with blind judges checking every finding against the code.&lt;/p&gt;

&lt;h2&gt;
  
  
  What CodeGraph promises
&lt;/h2&gt;

&lt;p&gt;CodeGraph parses the repository with tree-sitter, stores functions, classes, imports and calls in a local SQLite database, and keeps it in sync with a file watcher. The main MCP tool, &lt;code&gt;codegraph_explore&lt;/code&gt;, takes a question or a list of symbol names and returns the relevant source, the call paths between the symbols and their callers.&lt;/p&gt;

&lt;p&gt;Its README reports a benchmark: seven open-source repositories, one architecture question per repository, Claude Code headless with and without the MCP server, median of four runs. The headline is "88% fewer tool calls, 53% faster, 62% fewer tokens, 44% cheaper". The README is also candid about a trap: without blocking the CLI in the control arm, 26 of 28 control runs found CodeGraph through Bash anyway. That's why all my baseline runs happened before CodeGraph was on the machine at all.&lt;/p&gt;

&lt;p&gt;Indexing is fast. My largest project, 583 Python files, became 9,798 symbols and 26,368 edges in about two seconds.&lt;/p&gt;

&lt;h2&gt;
  
  
  What my reviewer already does
&lt;/h2&gt;

&lt;p&gt;My reviewer doesn't wander. Before any agent starts, a collect step builds the map it works from:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Modules.&lt;/strong&gt; The code is split into modules of at most 10,000 lines; one agent per module and aspect reads every line of its module.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;An import graph.&lt;/strong&gt; Per-file fan-in and fan-out, edges and cycles between modules and between top-level layers.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dead-code candidates&lt;/strong&gt; from per-language tools: staticcheck and deadcode for Go, knip and &lt;code&gt;tsc&lt;/code&gt; for TypeScript, vulture for Python, &lt;code&gt;cargo check&lt;/code&gt; for Rust.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Scanner and linter hints:&lt;/strong&gt; vulnerable dependencies, secrets, malicious packages, performance and security lint.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Module, security and performance reviewers work per module, an architect looks across modules, a global security pass looks at the attack surface, and a verifier tries to refute every finding. So the question was whether CodeGraph's map beats the one my reviewer already has, or adds something on top of it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The setup
&lt;/h2&gt;

&lt;p&gt;The same four projects as in the model comparison, at the same commits:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Project&lt;/th&gt;
&lt;th&gt;Language&lt;/th&gt;
&lt;th&gt;Reviewed&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;A&lt;/td&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;~830 lines&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B&lt;/td&gt;
&lt;td&gt;TypeScript&lt;/td&gt;
&lt;td&gt;~1,030 lines&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;C&lt;/td&gt;
&lt;td&gt;Rust&lt;/td&gt;
&lt;td&gt;~1,220 lines&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;D&lt;/td&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;~11,250 lines (2 modules)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Each project was cloned into a scratch directory, and collect ran once per project, so every run in a comparison started from the identical inventory. All baseline runs happened before CodeGraph was installed at all: no CLI on the PATH, no MCP server, no index. Then I installed it the way the README says:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm i -g @colbymchenry/codegraph@1.6.2
codegraph telemetry off
codegraph install --target claude --location global --yes
&lt;span class="nb"&gt;cd&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;repo&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; codegraph init
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The installer registers the MCP server in &lt;code&gt;~/.claude.json&lt;/code&gt; (loaded from the first prompt), allows its tools in &lt;code&gt;~/.claude/settings.json&lt;/code&gt;, adds a prompt hook and writes a section to &lt;code&gt;~/.claude/CLAUDE.md&lt;/code&gt; telling agents to reach for CodeGraph before grep or reading files when a repository has an index.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test 1: install it and let the agents decide
&lt;/h2&gt;

&lt;p&gt;Two full Opus 5.5 runs without CodeGraph, two with it, all four projects.&lt;/p&gt;

&lt;p&gt;The agents saw it. They listed the &lt;code&gt;.codegraph&lt;/code&gt; directory, excluded it from their greps, and carried on reading code with &lt;code&gt;sed&lt;/code&gt; and &lt;code&gt;grep&lt;/code&gt; exactly as their prompts tell them to. In 8 project runs there were 3 real &lt;code&gt;codegraph_explore&lt;/code&gt; calls, all from the global security pass on the Python project. A general hint in &lt;code&gt;CLAUDE.md&lt;/code&gt; loses to a specific role prompt.&lt;/p&gt;

&lt;p&gt;The bill went up, not down: $32.19 on average against $29.06, and 51.2M tokens against 43.3M. CodeGraph can't be the cause; it was barely called. The CodeGraph runs kept more findings on the Python project (59 and 48 against 40 and 42), and more findings means more verifier work. I read this as run-to-run noise.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test 2: make it mandatory where it should help
&lt;/h2&gt;

&lt;p&gt;Module reviewers must read every line of their module, so a graph can't spare them much. The roles that trace across files can benefit: the architect, the global security pass and the verifiers of their findings. I added one section to those three prompts:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;This repository is indexed by CodeGraph. For every question that crosses files
(who calls X, where a value comes from, how a request reaches Y, what depends
on a module, whether a guard exists upstream), call the `codegraph_explore` MCP
tool FIRST, with `projectPath` set to the repository root, instead of
grep/sed/cat loops.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then I ran only those agents, two runs per project, Opus 5.5, and compared them with the same agents from the full runs. Now they used it: 15 &lt;code&gt;codegraph_explore&lt;/code&gt; calls per run across the four projects, 8 to 10 on Python. Tool calls dropped from 190 to 178 per run. Tokens and cost didn't move: 14.6M tokens and $11.21 per run, against 14.9M and $11.26 without CodeGraph.&lt;/p&gt;

&lt;p&gt;The reason is in the output. One &lt;code&gt;codegraph_explore&lt;/code&gt; answer on the Python project was about 25,000 characters: the full source of every relevant symbol, plus call paths. It replaces three or four &lt;code&gt;sed -n&lt;/code&gt; reads of the right line ranges, but the agent was going to read those lines anyway, and the answer then stays in the context for every following turn. The agents made fewer round-trips and read the same amount of code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test 3: replace the reviewer's map with CodeGraph's
&lt;/h2&gt;

&lt;p&gt;The fairest test of CodeGraph as a tool, not as a hint: take out what my collect step computes about structure, put in the same fields computed from CodeGraph's index, and make every agent use the MCP tool. Arm A keeps the plugin's map, arm B gets CodeGraph's.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Kept in both arms:&lt;/strong&gt; the module partition, the vulnerability, secret and malicious-package scanners, and the linter hints. CodeGraph has no equivalent for those.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Replaced in arm B:&lt;/strong&gt; module and layer edges, cycles, per-file fan-in and fan-out, and the dead-code candidates. A short script read them from &lt;code&gt;.codegraph/codegraph.db&lt;/code&gt;. Dead-code candidates are functions, methods and types with no incoming call, reference, import or inheritance edge.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Arm A&lt;/strong&gt; ran on clones without an index, so the &lt;code&gt;CLAUDE.md&lt;/code&gt; section told its agents to skip CodeGraph. They did: zero calls.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Both graphs agreed on structure. On the Python project CodeGraph produced the same 33 module edges and the same two cycles as my import graph. They disagreed on dead code. In the two reviewed Python modules my tools reported no candidates; CodeGraph's "no incoming edge" reported 41 (229 across the whole repository), even after I dropped variables and Rust test functions. Getters, static members and framework-wired methods have no visible caller.&lt;/p&gt;

&lt;p&gt;All eight runs on Sonnet 5.5 at the same time, then one blind Opus judge per project with both finding lists in shuffled order and every mention of CodeGraph scrubbed from the findings. The judges found 86 distinct real issues and no false ones in either list.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxidg4byve3gm3unplb3t.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxidg4byve3gm3unplb3t.png" alt="Plugin map vs CodeGraph, Sonnet 5.5, 4 projects: tokens 40.1M vs 41.1M; real issues found 79 vs 65 of 86; WILL_COST 30 of 31 vs 29 of 31; WILL_ROT 49 of 55 vs 36 of 55" width="799" height="368"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Cost was identical, $17.37 against $17.41. The CodeGraph arm finished the Python project faster, 8.4 minutes against 11.8, and used CodeGraph 31 times. And it found fewer real issues: 65 against 79.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg66ju5y8xiloe7h5hun3.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fg66ju5y8xiloe7h5hun3.png" alt="Who found each real issue in test 3. WILL_COST: 28 found by both, 2 only with the plugin map, 1 only with CodeGraph. WILL_ROT: 30 by both, 19 only with the plugin map, 6 only with CodeGraph" width="800" height="322"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The costly issues came out even: 30 of 31 against 29 of 31. Each arm also caught one or two costly issues the other missed, so neither setup is a strict superset of the other.&lt;/p&gt;

&lt;p&gt;The gap is in maintainability findings: 49 against 36, most of it on the Python project. I can't prove the cause from one run. My best guess is attention: 41 dead-code leads that mostly didn't hold up, plus the instruction to go through CodeGraph first, pulled the reviewers away from reading. The CodeGraph arm also raised 4 more findings that its own verifier refuted (27 against 23). What it missed were mostly the quiet issues that reviewers pick up while reading: duplication, unused code and leftovers.&lt;/p&gt;

&lt;h2&gt;
  
  
  All three tests in one picture
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1tp3buv0b33j04kuylra.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1tp3buv0b33j04kuylra.png" alt="Promised vs measured, % change with CodeGraph. CodeGraph's benchmark: tokens -62%, cost -44%. Test 1, installed as shipped, 1.5 calls per run: tokens +18.3%, cost +10.8%. Test 2, required for cross-file roles, 15 calls per run: tokens -2%, cost -0.4%. Test 3, replaces the plugin's map, 31 calls per run: tokens +2.5%, cost +0.2%" width="800" height="484"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The vendor's benchmark and my tests measure different jobs. Its agent answers one question about an unfamiliar repository and would otherwise explore it with grep and file reads, so the graph replaces most of the work. My reviewer gets a map before it starts and is told to read every line of its module, so there is little exploration left to remove.&lt;/p&gt;

&lt;h2&gt;
  
  
  Limits
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Few runs.&lt;/strong&gt; Two runs per arm in tests 1 and 2, one in test 3. The two baseline runs of test 1 differed by 3% in cost; differences inside that band are noise.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The judges were Opus.&lt;/strong&gt; They were blind to which list came from which setup, but one model family judged both.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;My dead-code heuristic.&lt;/strong&gt; "No incoming edge in the graph" is my reading of CodeGraph's data, not a feature it ships. A better filter would cut the noise, and the maintainability gap with it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Small projects.&lt;/strong&gt; About 14,000 reviewed lines across four projects. On a large monolith, where the architect and the security pass have more to trace, the cross-file roles might profit more.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One plugin.&lt;/strong&gt; My reviewer front-loads structure on purpose. An agent that works without a prepared map is the case CodeGraph's own benchmark measures.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The MCP server needs &lt;code&gt;projectPath&lt;/code&gt;.&lt;/strong&gt; It starts in the session's working directory. My runs started elsewhere, so the agents had to pass the repository path, which CodeGraph's server instructions tell them to do.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What I'm doing with it
&lt;/h2&gt;

&lt;p&gt;My take: CodeGraph stays out of the reviewer. It cost the same as my own map, and replacing that map lost maintainability findings without adding costly ones. The two graphs agreed on structure, so for this job CodeGraph's index adds nothing my collect step doesn't already compute.&lt;/p&gt;

&lt;p&gt;Where I'd still use it: an interactive session in a large repository I don't know yet, where the alternative really is an agent grepping its way through it. That's the job it was benchmarked on.&lt;/p&gt;

&lt;p&gt;The general lesson is older than either tool: measure the claim on your own workload before you wire it in. What's in your agent setup that you added because a benchmark said so?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>codereview</category>
      <category>mcp</category>
    </item>
    <item>
      <title>Half the Price, Missed the Production Bug: Opus vs Sonnet as Code Reviewers</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Wed, 11 Nov 2026 17:38:52 +0000</pubDate>
      <link>https://dev.to/mkarytka/half-the-price-missed-the-production-bug-opus-vs-sonnet-as-code-reviewers-4khp</link>
      <guid>https://dev.to/mkarytka/half-the-price-missed-the-production-bug-opus-vs-sonnet-as-code-reviewers-4khp</guid>
      <description>&lt;p&gt;Sonnet 5.5 reviewed four codebases for half of what Opus 5.5 cost and did not report a single false finding. It also missed the one bug that had already caused a failure in one of my running projects.&lt;/p&gt;

&lt;p&gt;I built a multi-agent code-review tool for my own use, a Claude Code plugin that reviews a whole backend at once instead of one PR at a time. It started as a handful of prompts, grew about twenty static-analysis tools, and ended up running them in container images. Before relying on it I wanted to know if the cheaper model would do, and whether the tools were worth it. So I ran both models over four small private projects of mine, with and without the tool images, and had blind judges check every finding against the code.&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem: nobody reviews the whole service
&lt;/h2&gt;

&lt;p&gt;PR review sees a diff. It never sees the service as a whole: a fork taken over from upstream, a small proxy that works and so nobody reads, a module that grew through a hundred small PRs that were each fine on their own.&lt;/p&gt;

&lt;p&gt;The obvious shortcut, "here's my repo, review it", gives you a long list of plausible-sounding notes. Some are wrong, many are style, and you can't tell which ones are worth an afternoon. I wanted three things instead:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Coverage.&lt;/strong&gt; Every file is read by an agent whose job is that module and nothing else, so nothing is skipped because the context filled up.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Findings you can trust.&lt;/strong&gt; Each finding names a file and line, and a separate agent tries to refute it before it reaches the report.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A ranking by consequence, not by category.&lt;/strong&gt; "Will break in use" first, "will cost money or incidents" second, "will rot" last.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Stage 1: just prompts
&lt;/h2&gt;

&lt;p&gt;The first version ran on prompts alone: Claude Code subagents with different roles reading the code, and no static-analysis tools. A subagent is a markdown file: frontmatter with its name and allowed tools, then the prompt. The reviewers get read-only tools only:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;---
name: module-reviewer
tools: Read, Grep, Glob, Bash
model: inherit
---

You review ONE module of a backend codebase for defects that matter in
production. You never edit files. Bash is for read-only commands only
(&lt;span class="sb"&gt;`git log`&lt;/span&gt;, &lt;span class="sb"&gt;`git grep`&lt;/span&gt;, &lt;span class="sb"&gt;`rg`&lt;/span&gt;, &lt;span class="sb"&gt;`wc`&lt;/span&gt;, read-only scripts); never install
packages, run the app, run migrations or write outside the run directory.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The role prompts are still the core of the tool. Most of their length goes to rules that kill weak findings. A few excerpts from the current versions:&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;module reviewer&lt;/strong&gt; (correctness, contracts, concurrency, dead code):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Every finding must answer: "If this ships as-is, what concretely goes wrong,
for whom, and how badly?" If you cannot answer that, drop it.
- Never report style, naming, formatting, missing tests, or anything a linter
  catches.
- Prefer fewer, truer findings. At most 25 per module; if more survive, keep
  the most severe.
- Report exactly which files you read fully, skimmed, or did not open. Never
  imply full coverage you did not have.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;strong&gt;security reviewer&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;You look for defects an attacker or a curious tenant can actually exploit.
- Every finding needs a concrete attack: who sends what, through which entry
  point, and what they gain.
- Try to disprove each finding first: an upstream guard, middleware, tenant
  filter or validation kills it.
- No generic advice (rate limiting, CSP, MFA) unless the code shows the
  concrete gap.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;strong&gt;performance reviewer&lt;/strong&gt; has the strictest bar, because "this could be slow" is the easiest note for a model to write:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Report a finding only when you can state all four:
- (a) Why it is hot: the entry point and the file:line call chain that makes
  the code run per request, per message or per item.
- (b) The size driver: what n is and whether something bounds it. If n is
  bounded and small, there is no finding.
- (c) A cost estimate: queries or calls per request, allocations per item,
  big-O, bytes held, time blocked.
- (d) A cheaper alternative that does not hurt readability or correctness.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And the &lt;strong&gt;verifier&lt;/strong&gt;, which sees every finding from the others:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;You are the skeptic in a code review. You receive findings produced by another
reviewer and try to REFUTE each one against the actual code.
When in doubt between confirmed and refuted, choose refuted unless you have
direct evidence.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Every finding gets one of three tiers, ordered by consequence, and the verifier may move it up or down. The whole results section below rests on these three labels, so they are worth pinning down now:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tier&lt;/th&gt;
&lt;th&gt;What it means&lt;/th&gt;
&lt;th&gt;A concrete example&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;WILL_BREAK&lt;/td&gt;
&lt;td&gt;Wrong results, data loss, a crash, or a security hole in normal use&lt;/td&gt;
&lt;td&gt;a code path that returns wrong results on valid input&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;WILL_COST&lt;/td&gt;
&lt;td&gt;It still works, but burns latency, money, incidents or toil&lt;/td&gt;
&lt;td&gt;an unbounded query that slows down as the data grows&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;WILL_ROT&lt;/td&gt;
&lt;td&gt;A maintainability problem only: dead code, hygiene, confusion&lt;/td&gt;
&lt;td&gt;a module no caller reaches any more&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Stage 2: the prompts needed tools
&lt;/h2&gt;

&lt;p&gt;Prompts alone hit a ceiling, and it's a structural one. Some facts aren't in the code at all: whether a dependency version has a published vulnerability, whether a package on the registry is malicious or was taken over. Other facts are in the code but too expensive to establish by reading: whether a function is reachable from &lt;code&gt;main&lt;/code&gt; at all, or whether a secret was committed three directories away from the module under review.&lt;/p&gt;

&lt;p&gt;So the scanners and checks got deterministic tools, one set per language, and the prompts changed to treat their output as leads:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Language&lt;/th&gt;
&lt;th&gt;Dead code&lt;/th&gt;
&lt;th&gt;Performance and security hints&lt;/th&gt;
&lt;th&gt;Dependencies&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;staticcheck, deadcode&lt;/td&gt;
&lt;td&gt;golangci-lint, gosec&lt;/td&gt;
&lt;td&gt;govulncheck&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TypeScript&lt;/td&gt;
&lt;td&gt;knip, &lt;code&gt;tsc --noUnused*&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;cve-lite&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;vulture&lt;/td&gt;
&lt;td&gt;Ruff &lt;code&gt;PERF&lt;/code&gt;, &lt;code&gt;ASYNC&lt;/code&gt;, &lt;code&gt;S&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;osv-scanner&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rust&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;cargo check&lt;/code&gt;, cargo-shear&lt;/td&gt;
&lt;td&gt;Clippy &lt;code&gt;perf&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;osv-scanner&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;any&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;gitleaks (secrets)&lt;/td&gt;
&lt;td&gt;osv-scanner, GuardDog (malicious packages)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The prompts say how to use them. The performance reviewer gets "use the linter hints as leads, not findings", the security reviewer gets "never report a hint without the attack it enables", and the verifier still has to refute dead-code candidates by searching for reflective registration and framework wiring.&lt;/p&gt;

&lt;p&gt;That's about twenty tools across four ecosystems, each with its own version, installer and runtime. On the host that means a Go toolchain, cargo, &lt;code&gt;uv&lt;/code&gt;, Node, osv-scanner and cve-lite, all at versions that behave the same. Anyone running it would have to install and maintain that before the first review, on macOS, Linux or Windows, and keep it out of the way of their own projects.&lt;/p&gt;

&lt;h2&gt;
  
  
  Stage 3: the tools moved into images
&lt;/h2&gt;

&lt;p&gt;So the tools moved into container images, versioned together with the plugin: one image per language (core, Go, TypeScript, Python, Rust) plus one for polyglot repos, built on Wolfi and published for amd64 and arm64. The host needs only Docker.&lt;/p&gt;

&lt;p&gt;The plugin picks the image itself. It looks at which marker files the repository tracks and takes the image for that language, the polyglot image for several, or the core image (secrets, advisories) for none:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="no"&gt;MARKERS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;go&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;^|&lt;/span&gt;\&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="n"&gt;go&lt;/span&gt;\&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;mod&lt;/span&gt;$&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;node&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;^|&lt;/span&gt;\&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="k"&gt;package&lt;/span&gt;\&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;json&lt;/span&gt;$&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;python&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;^|&lt;/span&gt;\&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pyproject&lt;/span&gt;\&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;toml&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="n"&gt;requirements&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;^/&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;\&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;txt&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="n"&gt;setup&lt;/span&gt;\&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;py&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;$&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;rust&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;^|&lt;/span&gt;\&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="nc"&gt;Cargo&lt;/span&gt;\&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;toml&lt;/span&gt;$&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;languages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;Object&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;keys&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;MARKERS&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;filter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;lang&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;files&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="no"&gt;MARKERS&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;lang&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;test&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;languages&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;length&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="n"&gt;languages&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;languages&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;length&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="s1"&gt;'all'&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'core'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The image tag matches the plugin version, so a plugin update brings the matching tool versions with it. Without Docker the plugin falls back to whatever tools the host has, and the report says which were skipped.&lt;/p&gt;

&lt;p&gt;The images had their own surprises. Trivy in CI found HIGH vulnerabilities in my own tool images, which is an awkward thing for a review tool to ship. I swapped a secret scanner for the one Wolfi packages, built one Go linter from source, removed pip from a Python venv, and dropped a Kubernetes linter whose dependencies I couldn't get clean. The images run as a non-root user and pull fresh offline vulnerability databases on every run. The malicious-package check for Python was the slowest step at 765 seconds on a cold run; caching results per package version brought a warm run down to 3 seconds.&lt;/p&gt;

&lt;p&gt;This is the pipeline today:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkx3pz1nxryclqvcw2xd3.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkx3pz1nxryclqvcw2xd3.png" alt="Review pipeline: collect, per-module reviewers, verifier, report" width="800" height="402"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The experiment
&lt;/h2&gt;

&lt;p&gt;Four small private projects of mine, one per language:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Project&lt;/th&gt;
&lt;th&gt;Language&lt;/th&gt;
&lt;th&gt;Reviewed&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;A&lt;/td&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;~830 lines&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B&lt;/td&gt;
&lt;td&gt;TypeScript&lt;/td&gt;
&lt;td&gt;~1,370 lines&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;C&lt;/td&gt;
&lt;td&gt;Rust&lt;/td&gt;
&lt;td&gt;~1,220 lines&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;D&lt;/td&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;~11,250 lines (2 modules)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;For each project I ran collect once and gave both models the identical inventory, the same agent prompts and the same five aspects (defects, dead code, security, performance, architecture). Only the model changed. Claude Code workflows take a model per agent call, so the switch was one argument:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;modelOpt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="c1"&gt;// ...&lt;/span&gt;
&lt;span class="nf"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;reviewPrompt&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;moduleId&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;modelOpt&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;agentType&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'module-reviewer'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;schema&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then the judging. For each project a judge agent got both finding lists, labelled A and B in a shuffled order, and had to read the code and, for every distinct issue, decide: real, partly true, or false, and which tier is correct. For the Go project I also had a reference: an earlier run where a prover agent had confirmed its main bug with a failing test.&lt;/p&gt;

&lt;h2&gt;
  
  
  Results: Opus 5.5 vs Sonnet 5.5
&lt;/h2&gt;

&lt;p&gt;Across the four projects the judges found 99 distinct real issues.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo66gtrjk30orovpq2j10.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo66gtrjk30orovpq2j10.png" alt="Opus 5.5 vs Sonnet 5.5: cost $30.85 vs $15.79; costly issues found 95% vs 81% (35 of 37 vs 30 of 37); WILL_BREAK 2 of 2 vs 1 of 2; WILL_ROT 41 of 60 vs 44 of 60" width="799" height="389"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Neither model made things up. Both lists held up line by line, and both repeated themselves across the module, security and architecture passes. On dead code and maintainability Sonnet was as good as Opus, slightly better even. It was also faster: 16.1 minutes against 23.9 for the four runs.&lt;/p&gt;

&lt;p&gt;54 of the 99 issues were found by both models. The difference is in the ones only one model caught:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuatyvt2x810yw9l4fv9r.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuatyvt2x810yw9l4fv9r.png" alt="Who found each real issue. WILL_BREAK: 1 by both, 1 only by Opus. WILL_COST: 28 by both, 7 only by Opus, 2 only by Sonnet. WILL_ROT: 25 by both, 16 only by Opus, 19 only by Sonnet" width="799" height="347"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The gap is at the top of the list.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The bug that had already bitten.&lt;/strong&gt; In the Python project, a WILL_BREAK defect that the git history showed had already caused a failure once the project was running, where the earlier fix had closed only one of the affected paths. Opus found it in both of its runs. Sonnet missed it in both.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The proven bug, rated too low.&lt;/strong&gt; In the Go project, a WILL_BREAK defect that an earlier run had already confirmed with a failing test. Sonnet found it, but rated it WILL_COST, so in its report it would sit in the middle of the list instead of at the top.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The most serious issue in the Rust project:&lt;/strong&gt; Opus found it in both of its runs, Sonnet in one of two.&lt;/p&gt;

&lt;p&gt;The tiering pattern matters more than the counts. Opus errs high: the judges moved 8 of its tiers down and none up, among them three issues in the TypeScript project that it called WILL_BREAK and the judge rated WILL_COST. Sonnet errs in both directions: 7 tiers too high and 5 too low. A report is read top-down. An inflated tier wastes a few minutes of a reader's time. An under-rated one hides the thing you ran the review for.&lt;/p&gt;

&lt;h2&gt;
  
  
  Results: were the images worth it?
&lt;/h2&gt;

&lt;p&gt;To check stage 3, I ran all four projects again without Docker, on whatever tools my laptop had, with both models. This is what the images changed:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgol89jtuntpzmq3shslu.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgol89jtuntpzmq3shslu.png" alt="What the tool images changed, with images vs host tools. Opus: cost -16.7% ($37.03 to $30.85), tokens -25.6% (64.8M to 48.2M), run time -15.2% (28.2 to 23.9 min), findings kept -17.6% (108 to 89). Sonnet: cost -0.8% ($15.91 to $15.79), tokens -4.2% (35.6M to 34.1M), run time -19.9% (20.1 to 16.1 min), findings kept +25.7% (70 to 88)" width="800" height="421"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I expected the extra tool output to cost tokens. It did the opposite. With the linter and scanner results in front of it, Opus used 26% fewer tokens and cost 17% less, because it didn't have to find the same things by reading. Sonnet cost the same either way, but kept 26% more findings with the images (88 vs 70). Both finished faster. In money: Opus went from $37.03 to $30.85 across the four projects, Sonnet from $15.91 to $15.79.&lt;/p&gt;

&lt;p&gt;Some findings exist only because a tool produced them. A known dependency vulnerability and an unused dependency came from the scanners, so no host-tool run could report them. Even then, only one of the two image runs passed them on: Opus saw the same scanner output and left both out.&lt;/p&gt;

&lt;h2&gt;
  
  
  Limits
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;One run per cell.&lt;/strong&gt; The variance is visible: Opus without images missed a high-severity bug that every other run found, and Sonnet found the most serious issue in the Rust project in one run out of two. Treat single-digit differences as noise.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The judges were Opus.&lt;/strong&gt; They were blind to which list came from which model, but they are the same model family as one contestant.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Small projects.&lt;/strong&gt; Four of them, about 15,000 reviewed lines in total. A large monolith may behave differently.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;My laptop is not a clean machine.&lt;/strong&gt; It has the Go and Node toolchains installed, so "host tools" for the Go project still had most of its linters. On a clean machine the gap between the two image columns would be larger. I only judged the runs with the images; the host-tool runs are compared on cost, time and finding counts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Harness mistakes.&lt;/strong&gt; My first batch of runs failed because the session didn't know a newly added agent type, and one failed agent took down its whole module with it. I fixed that so each reviewer fails alone. I also passed a wrong module id for the TypeScript project in all four of its runs; the agents reviewed the right directory anyway, and the mistake is the same in every run.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What I'm doing with it
&lt;/h2&gt;

&lt;p&gt;My take: Opus stays the default for any review where missing a breaking bug is the expensive outcome, which is most of them. Sonnet is now a one-flag option for frequent passes and dead-code sweeps, where it matches Opus at half the price. The tool images stay on, because they make the expensive model cheaper and the cheap model better, and nobody has to set up twenty tools by hand.&lt;/p&gt;

&lt;p&gt;What I haven't tested yet is a mixed setup: Sonnet for the module and performance reviewers, Opus for security and the verifier. That's the next run.&lt;/p&gt;

&lt;p&gt;The cheaper model finds almost everything. Whether that's enough depends on how expensive the "almost" is for you. Would you trust a review that is 95% right at the top of the list, or 81%?&lt;/p&gt;

&lt;h2&gt;
  
  
  Appendix: what's in the images
&lt;/h2&gt;

&lt;p&gt;Every tool below is free and open source. Versions are from the images as built on 2026-11-08. The base is Wolfi; tools that Wolfi packages come from its signed packages, the rest are pinned by version and checksum or built from source.&lt;/p&gt;

&lt;p&gt;Shared by every image (the core image is just this):&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Version&lt;/th&gt;
&lt;th&gt;Used for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;osv-scanner&lt;/td&gt;
&lt;td&gt;2.7.0&lt;/td&gt;
&lt;td&gt;dependency advisories, offline database&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GuardDog&lt;/td&gt;
&lt;td&gt;3.2.0&lt;/td&gt;
&lt;td&gt;malicious-package and takeover signals&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;gitleaks&lt;/td&gt;
&lt;td&gt;8.30.1&lt;/td&gt;
&lt;td&gt;secrets committed in source files&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;actionlint&lt;/td&gt;
&lt;td&gt;1.7.12&lt;/td&gt;
&lt;td&gt;CI workflows (opt-in infra aspect)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;hadolint&lt;/td&gt;
&lt;td&gt;2.15.1&lt;/td&gt;
&lt;td&gt;Dockerfiles (opt-in infra aspect)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ShellCheck&lt;/td&gt;
&lt;td&gt;0.11.0&lt;/td&gt;
&lt;td&gt;shell scripts (opt-in infra aspect)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Node.js&lt;/td&gt;
&lt;td&gt;26.13.0&lt;/td&gt;
&lt;td&gt;runtime for the collector&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;3.13.18&lt;/td&gt;
&lt;td&gt;runtime for GuardDog&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;git&lt;/td&gt;
&lt;td&gt;2.56.0&lt;/td&gt;
&lt;td&gt;file lists and history&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Added per language:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Image&lt;/th&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Version&lt;/th&gt;
&lt;th&gt;Used for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;1.27.3&lt;/td&gt;
&lt;td&gt;toolchain, &lt;code&gt;go list&lt;/code&gt; import graph&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;golangci-lint&lt;/td&gt;
&lt;td&gt;2.15.0&lt;/td&gt;
&lt;td&gt;performance linters and gosec&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;govulncheck&lt;/td&gt;
&lt;td&gt;1.9.0&lt;/td&gt;
&lt;td&gt;advisories with call-graph reachability&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;staticcheck&lt;/td&gt;
&lt;td&gt;2026.2.2&lt;/td&gt;
&lt;td&gt;unused code (built from source)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Go&lt;/td&gt;
&lt;td&gt;deadcode&lt;/td&gt;
&lt;td&gt;x/tools v0.52.0&lt;/td&gt;
&lt;td&gt;functions unreachable from &lt;code&gt;main&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TypeScript&lt;/td&gt;
&lt;td&gt;knip&lt;/td&gt;
&lt;td&gt;5.88.1&lt;/td&gt;
&lt;td&gt;unused files, exports and dependencies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TypeScript&lt;/td&gt;
&lt;td&gt;madge&lt;/td&gt;
&lt;td&gt;8.0.0&lt;/td&gt;
&lt;td&gt;import graph and cycles&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TypeScript&lt;/td&gt;
&lt;td&gt;cve-lite&lt;/td&gt;
&lt;td&gt;1.38.0&lt;/td&gt;
&lt;td&gt;advisories for npm, pnpm, yarn and bun lockfiles&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;Ruff&lt;/td&gt;
&lt;td&gt;0.17.4&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;PERF&lt;/code&gt;, &lt;code&gt;ASYNC&lt;/code&gt; and &lt;code&gt;S&lt;/code&gt; rules&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;vulture&lt;/td&gt;
&lt;td&gt;2.16&lt;/td&gt;
&lt;td&gt;unused code&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python&lt;/td&gt;
&lt;td&gt;uv&lt;/td&gt;
&lt;td&gt;0.13.7&lt;/td&gt;
&lt;td&gt;dependency export for GuardDog&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rust&lt;/td&gt;
&lt;td&gt;Rust stable&lt;/td&gt;
&lt;td&gt;1.99.1&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;cargo check&lt;/code&gt; lints and Clippy &lt;code&gt;perf&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rust&lt;/td&gt;
&lt;td&gt;rustup&lt;/td&gt;
&lt;td&gt;1.29.2&lt;/td&gt;
&lt;td&gt;toolchain management&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rust&lt;/td&gt;
&lt;td&gt;cargo-shear&lt;/td&gt;
&lt;td&gt;1.14.0&lt;/td&gt;
&lt;td&gt;unused dependencies&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;TypeScript's &lt;code&gt;tsc --noUnused*&lt;/code&gt; check uses the compiler from the project's own &lt;code&gt;node_modules&lt;/code&gt;, so it isn't in the image.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fueokq8hj3g0l8vul1fd0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fueokq8hj3g0l8vul1fd0.png" alt="Tool image sizes: Rust 2.32 GB, Go 1.26 GB, TypeScript 1.09 GB, Python 940 MB, core 842 MB" width="800" height="421"&gt;&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>codereview</category>
      <category>devtools</category>
    </item>
    <item>
      <title>Dockerizing a Kali Security Toolset Without Losing a Weekend</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Sun, 08 Nov 2026 19:37:20 +0000</pubDate>
      <link>https://dev.to/mkarytka/dockerizing-a-kali-security-toolset-without-losing-a-weekend-5eil</link>
      <guid>https://dev.to/mkarytka/dockerizing-a-kali-security-toolset-without-losing-a-weekend-5eil</guid>
      <description>&lt;p&gt;I wanted a reproducible container: a Kali base, a focused set of web-pentest tools, and a Python service on top. Simple, in theory. In practice I hit three walls that turn a 20-minute Dockerfile into an afternoon. All three are on Apple Silicon (arm64), and all three are avoidable once you know them.&lt;/p&gt;

&lt;p&gt;This is the writeup I wanted while fighting it. Examples use a Kali base image and an open-source MCP tool server, but the lessons apply to any Python-on-Kali build.&lt;/p&gt;

&lt;h2&gt;
  
  
  Wall 1: Kali ships Python 3.14, and the wheels aren't there yet
&lt;/h2&gt;

&lt;p&gt;The naive Dockerfile:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="k"&gt;FROM&lt;/span&gt; kalilinux/kali-rolling
&lt;span class="k"&gt;RUN&lt;/span&gt; apt-get update &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; apt-get install -y python3 python3-venv python3-pip
&lt;span class="k"&gt;RUN&lt;/span&gt; python3 -m venv /opt/venv &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; /opt/venv/bin/pip install -r requirements.txt
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;…dies on the pip step with something like:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;error: [Errno 2] No such file or directory: 'aarch64-linux-gnu-gcc'
ERROR: Failed building wheel for cffi
ERROR: Failed to build 'zstandard' ...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two things collided. Kali rolling moved to &lt;strong&gt;Python 3.14&lt;/strong&gt;, and for arm64 there are no prebuilt wheels yet for the heavy C/Rust dependencies (&lt;code&gt;cffi&lt;/code&gt;, &lt;code&gt;zstandard&lt;/code&gt;, &lt;code&gt;cryptography&lt;/code&gt;, &lt;code&gt;pydantic-core&lt;/code&gt;, &lt;code&gt;aiohttp&lt;/code&gt;, &lt;code&gt;psutil&lt;/code&gt;). pip falls back to compiling from source, and there's no compiler in the image.&lt;/p&gt;

&lt;p&gt;You &lt;em&gt;could&lt;/em&gt; install a full toolchain and compile everything. It works, but it's slow (Rust builds for &lt;code&gt;cryptography&lt;/code&gt; and &lt;code&gt;pydantic-core&lt;/code&gt; are not quick) and it bloats the image.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fix: let apt do the heavy lifting, pip the rest
&lt;/h2&gt;

&lt;p&gt;Kali packages most of those heavy libs as &lt;strong&gt;prebuilt&lt;/strong&gt; apt packages. Install those, create the venv with &lt;code&gt;--system-site-packages&lt;/code&gt; so it inherits them, and pip-install only the handful that apt doesn't carry.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="c"&gt;# Prebuilt heavy deps from apt (no compiling), plus a small toolchain for the rest&lt;/span&gt;
&lt;span class="k"&gt;RUN&lt;/span&gt; apt-get update &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; apt-get install -y --no-install-recommends \
      python3 python3-venv python3-pip python3-dev \
      build-essential libffi-dev libssl-dev pkg-config cargo rustc \
      mitmproxy python3-flask python3-requests python3-psutil \
      python3-bs4 python3-selenium python3-aiohttp \
    &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; rm -rf /var/lib/apt/lists/*

&lt;span class="c"&gt;# venv inherits the apt libs; pip only adds what's missing&lt;/span&gt;
&lt;span class="k"&gt;COPY&lt;/span&gt; requirements-lean.txt /opt/requirements-lean.txt
&lt;span class="k"&gt;RUN&lt;/span&gt; python3 -m venv --system-site-packages /opt/venv \
    &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; /opt/venv/bin/pip install --no-cache-dir -r /opt/requirements-lean.txt
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;requirements-lean.txt&lt;/code&gt; then contains only the packages apt can't provide: in my case two pure-Python ones plus &lt;code&gt;pydantic-core&lt;/code&gt;, which the small &lt;code&gt;cargo&lt;/code&gt;/&lt;code&gt;rustc&lt;/code&gt; toolchain compiles quickly. The build went from "fails" to a couple of minutes.&lt;/p&gt;

&lt;p&gt;The general principle: &lt;strong&gt;on a bleeding-edge Python, prefer the distro's prebuilt packages over pip wheels for anything with a C/Rust extension.&lt;/strong&gt; &lt;code&gt;--system-site-packages&lt;/code&gt; is the bridge that lets a venv use them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Wall 2: a tool name that isn't the tool you think
&lt;/h2&gt;

&lt;p&gt;My service shelled out to &lt;code&gt;httpx&lt;/code&gt; and every call failed with:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Error: No such option: -l
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The trap: on Kali, &lt;code&gt;/usr/bin/httpx&lt;/code&gt; is the &lt;strong&gt;Python HTTP client&lt;/strong&gt;, not ProjectDiscovery's &lt;code&gt;httpx&lt;/code&gt; probe. The security tool is packaged as &lt;code&gt;httpx-toolkit&lt;/code&gt;. Same name, completely different CLI.&lt;/p&gt;

&lt;p&gt;Fix: point the name you call at the tool you meant.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="k"&gt;RUN&lt;/span&gt; apt-get install -y --no-install-recommends httpx-toolkit \
 &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="o"&gt;[&lt;/span&gt; -x /usr/bin/httpx-toolkit &lt;span class="o"&gt;]&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="k"&gt;then&lt;/span&gt; \
      ln -sf /usr/bin/httpx-toolkit /usr/local/bin/httpx&lt;span class="o"&gt;;&lt;/span&gt; \
    &lt;span class="k"&gt;fi&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Lesson that generalizes: in a big toolbox, &lt;strong&gt;verify what a binary actually is&lt;/strong&gt; (&lt;code&gt;command -v&lt;/code&gt;, &lt;code&gt;&amp;lt;tool&amp;gt; -version&lt;/code&gt;) before wiring it into automation. Name collisions between a language package and a security tool are more common than you'd expect (&lt;code&gt;http&lt;/code&gt;, &lt;code&gt;dig&lt;/code&gt;, &lt;code&gt;ab&lt;/code&gt;, and friends).&lt;/p&gt;

&lt;h2&gt;
  
  
  Wall 3: installing 150 tools and failing on the one that moved
&lt;/h2&gt;

&lt;p&gt;A single apt line with dozens of packages fails entirely if one name changed or isn't available for your arch. Split it: a &lt;strong&gt;core&lt;/strong&gt; line that must succeed, and a &lt;strong&gt;best-effort&lt;/strong&gt; line that tolerates individual misses.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight docker"&gt;&lt;code&gt;&lt;span class="c"&gt;# core: must succeed&lt;/span&gt;
&lt;span class="k"&gt;RUN&lt;/span&gt; apt-get update &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; apt-get install -y --no-install-recommends \
      nmap nuclei sqlmap gobuster ffuf nikto subfinder \
    &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; rm -rf /var/lib/apt/lists/*

&lt;span class="c"&gt;# best-effort: don't sink the build over one unavailable package&lt;/span&gt;
&lt;span class="k"&gt;RUN&lt;/span&gt; apt-get update &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; p &lt;span class="k"&gt;in&lt;/span&gt; katana dalfox hakrawler httpx-toolkit chromium &lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt; \
      apt-get install -y --no-install-recommends &lt;span class="s2"&gt;"$p"&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"[skip] $p"&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; \
    &lt;span class="k"&gt;done&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; rm -rf /var/lib/apt/lists/*
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now a renamed or arch-missing extra prints &lt;code&gt;[skip] &amp;lt;name&amp;gt;&lt;/code&gt; instead of failing the whole image, and you can see at a glance what didn't make it.&lt;/p&gt;

&lt;h2&gt;
  
  
  A few more things that paid off
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Pin the source.&lt;/strong&gt; If you clone an upstream tool inside the image, check out a specific commit via an &lt;code&gt;ARG&lt;/code&gt; so rebuilds are reproducible: &lt;code&gt;ARG TOOL_SHA=...&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Keep it lean on purpose.&lt;/strong&gt; I only needed a web-app subset, so I skipped the binary-analysis and forensics tooling. Smaller image, faster build, less to patch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Add a healthcheck&lt;/strong&gt; for any service in the image so &lt;code&gt;docker ps&lt;/code&gt; tells the truth: &lt;code&gt;HEALTHCHECK CMD curl -fsS http://127.0.0.1:PORT/health || exit 1&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bind services to localhost&lt;/strong&gt; (&lt;code&gt;-p 127.0.0.1:PORT:PORT&lt;/code&gt;): a security toolbox is the last thing you want listening on all interfaces by accident.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Takeaway
&lt;/h2&gt;

&lt;p&gt;Three rules save the weekend on a Kali + Python image:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;On a brand-new Python, install heavy C/Rust deps from &lt;strong&gt;apt&lt;/strong&gt;, not pip; bridge with a &lt;code&gt;--system-site-packages&lt;/code&gt; venv.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verify binaries&lt;/strong&gt; before automating them; name collisions are real (&lt;code&gt;httpx&lt;/code&gt; vs &lt;code&gt;httpx-toolkit&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;Split apt installs into &lt;strong&gt;must-succeed&lt;/strong&gt; and &lt;strong&gt;best-effort&lt;/strong&gt;, pin sources, and keep the image to what you actually use.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;em&gt;Isolation note: run offensive tooling in a sandbox and bind it to localhost. The next piece covers microVM sandboxing for exactly this.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>docker</category>
      <category>kali</category>
      <category>security</category>
      <category>python</category>
    </item>
    <item>
      <title>Run a Capable LLM on Your Own Machine</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Mon, 02 Nov 2026 17:29:14 +0000</pubDate>
      <link>https://dev.to/mkarytka/run-a-capable-llm-on-your-own-machine-2pfk</link>
      <guid>https://dev.to/mkarytka/run-a-capable-llm-on-your-own-machine-2pfk</guid>
      <description>&lt;p&gt;&lt;em&gt;Updated 2026-11-03: expanded the setup for all three runners (install, concrete models, a working server) and added a Troubleshooting section, based on reader feedback.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Running a model locally sounds like a weekend project. The setup is actually ten minutes, plus however long the model download takes on your connection. This is the copy-paste version: install the tool, pull a model, serve it over an OpenAI-compatible endpoint, and make your first tool call, with no hand-waving.&lt;/p&gt;

&lt;p&gt;Treat this as a starting point for getting a model running, not a fine-tuning guide. The aim is a working endpoint in ten minutes; the deeper performance knobs (sampler settings, speculative decoding, GPU offload splits) are their own rabbit hole, and a separate post.&lt;/p&gt;

&lt;p&gt;Why local, when hosted models are right there and genuinely good? Privacy is the obvious one: nothing leaves the machine. Then cost, because a long or repetitive job stops metering you by the token. And control, which matters more than it sounds. No rate limits, no refusal out of nowhere, and the version stays pinned instead of shifting under you one morning. You pay for all of it in quality and speed, and that price is real. The last section is about when it's worth paying.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsb31v606w0lmj23i9r7x.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsb31v606w0lmj23i9r7x.png" alt="This is fine: quant, context length, KV cache, VRAM math. The ten-minute setup has a few knobs" width="800" height="476"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  First decision: which runner
&lt;/h2&gt;

&lt;p&gt;Three tools cover almost everyone. Pick by how you work:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Best for&lt;/th&gt;
&lt;th&gt;Interface&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Ollama&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;simplest CLI, scripting&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;ollama run&lt;/code&gt;, HTTP API&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;LM Studio&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;GUI + a great CLI (&lt;code&gt;lms&lt;/code&gt;), easy model management&lt;/td&gt;
&lt;td&gt;app + &lt;code&gt;lms&lt;/code&gt; + OpenAI API&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;llama.cpp&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;maximum control, headless servers&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;llama-server&lt;/code&gt;, raw flags&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;I'll use LM Studio's CLI (&lt;code&gt;lms&lt;/code&gt;) as the main path, because it gives you a clean OpenAI-compatible server and stays out of your way on model management, then show the Ollama and llama.cpp equivalents.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuoph4u0owhhw8ljd1tgi.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuoph4u0owhhw8ljd1tgi.png" alt="One mental model: each runner serves an OpenAI-compatible endpoint on localhost that any OpenAI client can call" width="800" height="372"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Sizing: will it even fit?
&lt;/h2&gt;

&lt;p&gt;Before pulling anything, do the memory math. A quantized model's file size is roughly its RAM/VRAM footprint, plus headroom for the context (KV cache).&lt;/p&gt;

&lt;p&gt;Rule of thumb: &lt;strong&gt;model file size + ~20% ≤ your available RAM/VRAM.&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;8 GB → a 7-8B model at Q4 (≈4-5 GB).&lt;/li&gt;
&lt;li&gt;16 GB → a 13-14B at Q4, or an 8B comfortably.&lt;/li&gt;
&lt;li&gt;32 GB → a ~27-34B at Q4.&lt;/li&gt;
&lt;li&gt;64 GB → a 70B at Q4 starts to be realistic.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Quantization (Q4/Q5/Q8) trades quality for size. Q4_K_M is the usual sweet spot; go Q8 only if you have the memory to spare and want the extra fidelity.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiy3o1jwimnzyb5bf6qq0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiy3o1jwimnzyb5bf6qq0.png" alt="Will it fit? Biggest comfortable model at Q4 per RAM tier: 8 GB fits 7-8B, 16 GB fits 13-14B, 32 GB fits 27-34B, 64 GB fits 70B" width="800" height="307"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F03huq5wehdw5pu0pchtz.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F03huq5wehdw5pu0pchtz.png" alt="Buff Doge vs Cheems: 64 GB RAM runs a 70B at Q4, 8 GB RAM barely fits a 7B" width="800" height="615"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  LM Studio (via the &lt;code&gt;lms&lt;/code&gt; CLI)
&lt;/h2&gt;

&lt;p&gt;Install the LM Studio app from &lt;a href="https://lmstudio.ai" rel="noopener noreferrer"&gt;lmstudio.ai&lt;/a&gt;, launch it once, then put the bundled &lt;code&gt;lms&lt;/code&gt; CLI on your PATH:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# macOS / Linux: bootstrap the CLI that ships with the app&lt;/span&gt;
~/.lmstudio/bin/lms bootstrap
&lt;span class="c"&gt;# Windows (PowerShell), from that same bin folder: lms.exe bootstrap&lt;/span&gt;

&lt;span class="c"&gt;# open a NEW terminal, then confirm it's on PATH&lt;/span&gt;
lms --version
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now download a concrete model, load it, and start the server:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Download a model. Most reliable: the LM Studio app's search/download tab, or&lt;/span&gt;
&lt;span class="c"&gt;# import a GGUF you grabbed from Hugging Face. The `lms get` CLI also works, but&lt;/span&gt;
&lt;span class="c"&gt;# is flaky on some builds:&lt;/span&gt;
lms get llama-3.1-8b --yes        &lt;span class="c"&gt;# or pin a quant: lms get llama-3.1-8b@q4_k_m&lt;/span&gt;
&lt;span class="c"&gt;# multi-GB download; can take well over ten minutes on a slow link (the model, not the setup).&lt;/span&gt;
&lt;span class="c"&gt;# If `lms get` errors out (known on some versions), download the GGUF from Hugging&lt;/span&gt;
&lt;span class="c"&gt;# Face and import it in the app, then continue below.&lt;/span&gt;

&lt;span class="c"&gt;# load it, with an explicit context length for headroom&lt;/span&gt;
lms load llama-3.1-8b --context-length 16384 --yes

&lt;span class="c"&gt;# start the server, pinned to a known port (the default can land on 1235, etc.)&lt;/span&gt;
lms server start --port 1234
lms server status                 &lt;span class="c"&gt;# confirms the actual port and the loaded model&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Housekeeping, when you need it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;lms ls                      &lt;span class="c"&gt;# models on disk&lt;/span&gt;
lms ps                      &lt;span class="c"&gt;# what's loaded right now&lt;/span&gt;
lms unload llama-3.1-8b     &lt;span class="c"&gt;# free the memory&lt;/span&gt;
lms server stop             &lt;span class="c"&gt;# stop the API server&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With the server running, LM Studio serves an &lt;strong&gt;OpenAI-compatible&lt;/strong&gt; API at &lt;code&gt;http://localhost:1234/v1&lt;/code&gt; (if you didn't pin &lt;code&gt;--port&lt;/code&gt;, use whatever port &lt;code&gt;lms server status&lt;/code&gt; reports; it is not always 1234). That compatibility is the whole point: anything that speaks the OpenAI API (your scripts, LiteLLM, an agent framework) points at the endpoint with a dummy key and works unchanged.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# confirm the server and see loaded models (needs jq: brew install jq / apt install jq)&lt;/span&gt;
curl -s http://localhost:1234/v1/models &lt;span class="o"&gt;|&lt;/span&gt; jq &lt;span class="s1"&gt;'.data[].id'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Use whatever id that prints as the &lt;code&gt;model&lt;/code&gt; value below, and make sure a model is actually loaded (&lt;code&gt;lms ps&lt;/code&gt;). A first chat completion:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -s http://localhost:1234/v1/chat/completions \
  -H &lt;span class="s2"&gt;"Authorization: Bearer lm-studio"&lt;/span&gt; \
  -H &lt;span class="s2"&gt;"Content-Type: application/json"&lt;/span&gt; \
  -d &lt;span class="s1"&gt;'{
    "model": "llama-3.1-8b",
    "messages": [{"role":"user","content":"Say hi in five words."}]
  }'&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; jq -r &lt;span class="s1"&gt;'.choices[0].message.content'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The same thing in Ollama
&lt;/h2&gt;

&lt;p&gt;Install Ollama, then pull a model and start the server:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# install: macOS `brew install ollama` (or the app); Linux:&lt;/span&gt;
curl -fsSL https://ollama.com/install.sh &lt;span class="o"&gt;|&lt;/span&gt; sh

&lt;span class="c"&gt;# download a model (same multi-GB caveat as above)&lt;/span&gt;
ollama pull llama3.1:8b

&lt;span class="c"&gt;# start the API server on :11434 (the desktop app also runs it)&lt;/span&gt;
ollama serve
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Ollama exposes an &lt;strong&gt;OpenAI-compatible&lt;/strong&gt; endpoint at &lt;code&gt;http://localhost:11434/v1&lt;/code&gt;, so the same &lt;code&gt;curl&lt;/code&gt; calls as above work with the port swapped and the &lt;code&gt;model&lt;/code&gt; set to &lt;code&gt;llama3.1:8b&lt;/code&gt; (Ollama's tag, not the LM Studio key). If you just want to poke at the model, &lt;code&gt;ollama run llama3.1:8b&lt;/code&gt; drops you straight into an interactive chat.&lt;/p&gt;

&lt;h2&gt;
  
  
  The same thing in llama.cpp
&lt;/h2&gt;

&lt;p&gt;For headless servers or maximum control. Install it (macOS &lt;code&gt;brew install llama.cpp&lt;/code&gt;; other platforms build from the repo), then let &lt;code&gt;llama-server&lt;/code&gt; pull a real GGUF straight from Hugging Face and serve it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# auto-download + serve a concrete model (the -hf flag fetches from Hugging Face)&lt;/span&gt;
llama-server -hf bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M \
  -c 16384 --host 127.0.0.1 --port 8080   &lt;span class="c"&gt;# localhost only; use 0.0.0.0 only to expose on your LAN&lt;/span&gt;

&lt;span class="c"&gt;# prefer to manage the file yourself? download it, then point -m at the path:&lt;/span&gt;
&lt;span class="c"&gt;#   huggingface-cli download bartowski/Meta-Llama-3.1-8B-Instruct-GGUF \&lt;/span&gt;
&lt;span class="c"&gt;#     Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf --local-dir ./models&lt;/span&gt;
&lt;span class="c"&gt;#   llama-server -m ./models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -c 16384 --port 8080&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;llama-server&lt;/code&gt; also speaks the OpenAI API (&lt;code&gt;/v1/chat/completions&lt;/code&gt;), on port 8080 here. One thing to watch on long sessions: the KV cache grows with context and RSS climbs over time; if latency degrades, restart the server to reset it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Tool calling (the part most local models fumble)
&lt;/h2&gt;

&lt;p&gt;If you want the model to &lt;em&gt;do&lt;/em&gt; things (call functions, drive tools), you need tool-calling, and local models vary wildly here. Send the OpenAI &lt;code&gt;tools&lt;/code&gt; array and see if it responds with a structured &lt;code&gt;tool_calls&lt;/code&gt; (the call below targets LM Studio on :1234; swap the port and &lt;code&gt;model&lt;/code&gt; for Ollama or llama.cpp):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -s http://localhost:1234/v1/chat/completions \
  -H &lt;span class="s2"&gt;"Authorization: Bearer lm-studio"&lt;/span&gt; -H &lt;span class="s2"&gt;"Content-Type: application/json"&lt;/span&gt; \
  -d &lt;span class="s1"&gt;'{
    "model": "llama-3.1-8b",
    "messages": [{"role":"user","content":"What time is it in UTC?"}],
    "tools": [{
      "type":"function",
      "function":{
        "name":"get_time",
        "description":"Return the current time for a timezone",
        "parameters":{"type":"object","properties":{"tz":{"type":"string"}}}
      }
    }],
    "tool_choice":"auto"
  }'&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; jq &lt;span class="s1"&gt;'.choices[0].message.tool_calls'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you get a clean &lt;code&gt;tool_calls&lt;/code&gt; array back, the model can drive tools. If you get prose describing the call instead, that model (or that quant) isn't reliable for agentic work; pick another, or keep the tool schema small and simple. This is the single biggest gotcha with local models, and it's worth its own article.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2lhgkez4acwm4kwvs2za.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2lhgkez4acwm4kwvs2za.png" alt="Anakin and Padme: my local model does tool calling, so it returns a real tool_calls array, right?" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Choosing honestly
&lt;/h2&gt;

&lt;p&gt;Local is not the default answer. Here's how I'd actually decide:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Go local when the data cannot leave the machine, when the job is high-volume or repetitive, or when you need a pinned model that nothing rate-limits.&lt;/li&gt;
&lt;li&gt;Stay hosted when you need top-tier reasoning, reliability across long chains of steps, or you simply don't want to babysit memory and quantization.&lt;/li&gt;
&lt;li&gt;Most real setups land in between: local for the bulk, a hosted model for the handful of genuinely hard steps.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk1x4gaq03gx21s1m62zd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk1x4gaq03gx21s1m62zd.png" alt="Drake: no to a per-token bill and rate limits for a repetitive job, yes to local for the bulk and hosted for the hard parts" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Troubleshooting
&lt;/h2&gt;

&lt;p&gt;A few things that bite people (several surfaced from readers, thank you):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;lms get&lt;/code&gt; fails to download.&lt;/strong&gt; The CLI downloader is flaky on some LM Studio builds. Download the model in the LM Studio app's search/download tab instead, or import a GGUF you pulled from Hugging Face, then &lt;code&gt;lms load&lt;/code&gt; it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The server isn't on &lt;code&gt;:1234&lt;/code&gt;.&lt;/strong&gt; LM Studio falls back to the next free port (often &lt;code&gt;:1235&lt;/code&gt;). Pin it with &lt;code&gt;lms server start --port 1234&lt;/code&gt;, or run &lt;code&gt;lms server status&lt;/code&gt; to see the real port, then use that port in every request.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;/v1/models&lt;/code&gt; works but &lt;code&gt;/v1/chat/completions&lt;/code&gt; errors.&lt;/strong&gt; Almost always one of: no model is loaded (&lt;code&gt;lms load …&lt;/code&gt;, confirm with &lt;code&gt;lms ps&lt;/code&gt;); the &lt;code&gt;model&lt;/code&gt; field doesn't match an id exactly as &lt;code&gt;/v1/models&lt;/code&gt; prints it; or you're on the wrong port.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ollama: &lt;code&gt;ollama serve&lt;/code&gt; says the address is already in use.&lt;/strong&gt; The desktop app already runs the server on &lt;code&gt;:11434&lt;/code&gt;. Skip &lt;code&gt;ollama serve&lt;/code&gt;, or quit the app first.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;curl&lt;/code&gt; errors with &lt;code&gt;command not found: jq&lt;/code&gt;.&lt;/strong&gt; Install &lt;code&gt;jq&lt;/code&gt; (&lt;code&gt;brew install jq&lt;/code&gt; / &lt;code&gt;apt install jq&lt;/code&gt;); the snippets pipe through it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tool-calling returns prose instead of &lt;code&gt;tool_calls&lt;/code&gt;.&lt;/strong&gt; That model or quant can't drive tools reliably. Pick another, or keep the tool schema small and simple.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;llama.cpp slows down over a long session.&lt;/strong&gt; The KV cache grows and RSS climbs; restart &lt;code&gt;llama-server&lt;/code&gt; to reset it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Out of memory, or it crashes on load.&lt;/strong&gt; The model plus its KV cache overran your RAM/VRAM. Drop to a smaller quant (Q4_K_M), lower &lt;code&gt;--context-length&lt;/code&gt;, or pick a smaller model (see the sizing table above).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Generation is painfully slow.&lt;/strong&gt; Usually the model spilled out of RAM/VRAM to CPU or swap. Make it fit (smaller quant or model, lower context) and close other memory-hungry apps. A long first-token delay on big prompts is normal.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The model downloaded but won't load.&lt;/strong&gt; Re-download in case it was truncated, confirm it's a GGUF (for llama.cpp), and update LM Studio and its runtime so the format is supported.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Calling the endpoint from a browser app fails (CORS).&lt;/strong&gt; Local servers usually don't send CORS headers. Call it from your backend or a small proxy, not straight from front-end &lt;code&gt;fetch()&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;401&lt;/code&gt; / auth errors.&lt;/strong&gt; These servers accept any dummy key. If a client insists on one, pass any non-empty string (&lt;code&gt;lm-studio&lt;/code&gt;, &lt;code&gt;ollama&lt;/code&gt;, whatever).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A Hugging Face model is gated (download or &lt;code&gt;-hf&lt;/code&gt; fails with 401/403).&lt;/strong&gt; Plenty of models are free but still require you to accept a usage agreement before you can download them. Being logged in is not enough; you have to click through the form:&lt;/li&gt;
&lt;li&gt;Open the model's page on huggingface.co while signed in and accept the license / usage agreement shown at the top of the page. Access is usually granted instantly.&lt;/li&gt;
&lt;li&gt;Create a token at &lt;strong&gt;huggingface.co → Settings → Access Tokens&lt;/strong&gt; (a &lt;strong&gt;Read&lt;/strong&gt; token is enough). Install the CLI if needed: &lt;code&gt;pip install -U "huggingface_hub[cli]"&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Log in locally: &lt;code&gt;huggingface-cli login&lt;/code&gt; (paste the token when prompted), or on newer versions &lt;code&gt;hf auth login&lt;/code&gt;. As an alternative, export &lt;code&gt;HF_TOKEN=&amp;lt;token&amp;gt;&lt;/code&gt;. After that, &lt;code&gt;huggingface-cli download …&lt;/code&gt; and &lt;code&gt;llama-server -hf …&lt;/code&gt; work for that repo. The community GGUF repos used above are ungated, so you can skip all of this for them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ollama: the API can't find the model.&lt;/strong&gt; The &lt;code&gt;model&lt;/code&gt; field must be the exact Ollama tag (&lt;code&gt;llama3.1:8b&lt;/code&gt;), and you must &lt;code&gt;ollama pull&lt;/code&gt; it first.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Takeaway
&lt;/h2&gt;

&lt;p&gt;Pick a runner, do the memory math, load a model, hit the endpoint. That part really is ten minutes. The decisions that matter come after: how far you quantize, and whether the model can hold tool-calling, because that is what makes or breaks anything agentic you put on top of it.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Next: why local models fail at tool-calling, and how to design around it.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>llm</category>
      <category>ai</category>
      <category>tutorial</category>
      <category>localai</category>
    </item>
    <item>
      <title>Lab Tool or Loaded Weapon? The Dual-Use Reality of Agentic Pentest Frameworks</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Fri, 30 Oct 2026 16:51:11 +0000</pubDate>
      <link>https://dev.to/mkarytka/lab-tool-or-loaded-weapon-the-dual-use-reality-of-agentic-pentest-frameworks-2c15</link>
      <guid>https://dev.to/mkarytka/lab-tool-or-loaded-weapon-the-dual-use-reality-of-agentic-pentest-frameworks-2c15</guid>
      <description>&lt;p&gt;Every tool in my last two posts can find real vulnerabilities in systems you're allowed to test. Some of them can also &lt;em&gt;exploit&lt;/em&gt; those vulnerabilities, pivot, and keep going, autonomously, at machine speed, against whatever you point them at. That second sentence is the whole problem.&lt;/p&gt;

&lt;p&gt;This isn't a "these tools are dangerous, be scared" post. It's a map of where each one sits on the spectrum from &lt;strong&gt;lab assistant&lt;/strong&gt; to &lt;strong&gt;loaded weapon&lt;/strong&gt;, which ones deserve extra caution, and the guardrails that keep an authorized test from becoming an incident. No weaponization recipes here, just the judgment I wish more write-ups included.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; Every tool here finds real bugs; some also exploit, pivot, and keep going on their own. Rank them by autonomy of action, breadth of offense, and built-in guardrails. Be most careful with autonomous post-exploitation, no-validation arsenals, and exposed control surfaces like an open MCP server. The encouraging flip side: some open a remediation PR automatically, as long as a human reviews and merges it. Capability is not permission.&lt;/p&gt;

&lt;h2&gt;
  
  
  The dual-use problem is not hypothetical
&lt;/h2&gt;

&lt;p&gt;When HexStrike AI shipped, Check Point &lt;a href="https://blog.checkpoint.com/executive-insights/hexstrike-ai-when-llms-meet-zero-day-exploitation/" rel="noopener noreferrer"&gt;documented&lt;/a&gt; threat actors discussing it for real-world exploitation of freshly disclosed Citrix NetScaler CVEs within &lt;em&gt;days&lt;/em&gt;. (That report leans on forum chatter and the actors' own claims; independent forensic confirmation of the tool's role in actual breaches is still thin.) The tool itself is legitimate security software. The capability ("point an LLM at a target and let it drive 150+ offensive tools") doesn't care about your intent. That's dual-use in one sentence.&lt;/p&gt;

&lt;p&gt;The uncomfortable truth: the same properties that make these tools &lt;em&gt;good&lt;/em&gt; (autonomy, breadth, speed, low skill floor) are exactly what make them &lt;em&gt;risky&lt;/em&gt; in the wrong hands or pointed at the wrong target.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three dimensions of risk
&lt;/h2&gt;

&lt;p&gt;Forget a single "danger score." What actually matters:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Autonomy of action&lt;/strong&gt;: does it only &lt;em&gt;observe&lt;/em&gt; (scan, fingerprint), or does it &lt;em&gt;act&lt;/em&gt; (exploit, post-exploit, pivot) without a human in the loop? Observation is recoverable; autonomous exploitation is intrusion.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Breadth of raw offense&lt;/strong&gt;: a focused web scanner vs. a 150-tool arsenal that includes real exploitation and C2-adjacent capability.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Guardrails&lt;/strong&gt;: built-in PoC validation, sandboxing, human-in-the-loop gates, allow-lists, scope pinning. Their presence is the difference between a tool that resists misuse and one where your intent is the only brake.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  The spectrum
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz9qf6v57m52ja2du3svu.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz9qf6v57m52ja2du3svu.png" alt="Dual-use spectrum: lab/assistant to autonomous offense, colored by built-in guardrails" width="800" height="495"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;(Placement is my judgment from building and running these, not a benchmark.)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Lower risk: assistants, builders, passive tools.&lt;/strong&gt; PentestGPT (assistant heritage), AI-OPS (allow-list-guarded, built for modest models), hackingBuddyGPT (a research construction kit), and Reaper (a passive MITM proxy, not an agent at all). These either keep a human central, ship guardrails, or simply don't act on their own. Good places to learn.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Moderate: capable autonomous agents with brakes.&lt;/strong&gt; Strix validates findings with working PoCs, runs in a sandbox, and has a CI mode; PentAGI runs tools in isolated sandboxes and offers a human-in-the-loop mode; Shannon is PoC-gated ("no exploit, no report") but white-box and genuinely autonomous. Powerful, but each ships real guardrails. Use on authorized scope, in isolation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Higher risk: autonomous offense, thin brakes.&lt;/strong&gt; HexStrike (a raw arsenal, 150-plus tools by its own count, with &lt;em&gt;no&lt;/em&gt; built-in finding validation, where the external model's judgment is the only scope gate), RedAmon (a recon → exploit → &lt;strong&gt;post-exploitation&lt;/strong&gt; pipeline whose reach runs all the way through post-ex, though it does ship human approval gates on high-impact tools), and Pentest Copilot (runs commands directly on the attack box and also exposes an MCP server, so whoever can reach that server runs code there). These are real capability. Treat them like live ammunition.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A different kind of risk: archived.&lt;/strong&gt; CAI has ~10k stars but the repo is archived. Unmaintained &lt;em&gt;offensive&lt;/em&gt; tooling is its own hazard: dependencies rot, nothing gets patched, and you're running attack code nobody is securing. Reference the patterns; don't run it in anger.&lt;/p&gt;

&lt;h2&gt;
  
  
  The other side of dual-use: find → fix → PR
&lt;/h2&gt;

&lt;p&gt;Dual-use cuts both ways, and the most encouraging development is tools that don't stop at finding: they propose the fix and open a pull request.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;RedAmon&lt;/strong&gt; is the clearest example: its pipeline runs recon → exploit → triage, then a &lt;strong&gt;CodeFix&lt;/strong&gt; agent clones the repo, works through the code with code-aware tools, and opens a &lt;strong&gt;GitHub PR&lt;/strong&gt; with a remediation. It literally closes the offense → defense loop.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Strix&lt;/strong&gt; validates findings with working PoCs and can ship &lt;strong&gt;auto-fix suggestions&lt;/strong&gt; and reports alongside them, so remediation arrives with the finding instead of weeks later.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is the defensive promise of the whole category: the same autonomy that makes an agent dangerous on offense makes it tireless on remediation. But keep one guardrail non-negotiable: &lt;strong&gt;a human reviews and merges the PR.&lt;/strong&gt; An LLM-authored fix can be wrong, incomplete, or quietly change behavior; the pull request &lt;em&gt;is&lt;/em&gt; the review gate, so never auto-merge it. Used that way, auto-remediation is arguably the most valuable, and one of the safest, things in the field.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to be &lt;em&gt;very&lt;/em&gt; careful with
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Autonomous post-exploitation.&lt;/strong&gt; "Find" is a test; "exploit, pivot, persist" is an intrusion. Any pipeline that chains past exploitation without a human gate can turn a scope mistake into a breach. Keep a human approval step before anything acts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Arsenals with no built-in validation.&lt;/strong&gt; When the only thing standing between a scan and a destructive action is the model's judgment, a prompt-injected page or a confused agent is a real risk. Add your own validation and dry-run defaults.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Exposed control surfaces.&lt;/strong&gt; Some tools expose an MCP server or control endpoint that can run commands on the attack box. Anyone who reaches it effectively runs code there, so it's now part of your attack surface: bind it to localhost, put it behind auth, never expose it to the network.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Local, uncensored "cyber" models.&lt;/strong&gt; Hosted models often refuse to synthesize a full offensive plan, an annoying but real safety brake. A local uncensored model removes that brake entirely. That's sometimes exactly what an authorized engagement needs, but the ethics then live &lt;em&gt;entirely&lt;/em&gt; with the operator. Know which side of that line you're on.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Scope drift.&lt;/strong&gt; Agents wander. Hard-pin the target, lock egress to it, and prefer read-only defaults so a wrong turn can't reach something it shouldn't. A tool's own scope check rarely catches a redirect off-target; in practice the sandbox's egress lock is what stops it, so make that boundary real, not assumed.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  A responsible-use checklist
&lt;/h2&gt;

&lt;p&gt;Before you run any of these:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Authorization in writing&lt;/strong&gt; for the exact scope. Agentic tools blur "scan" and "exploit," so your authorization must cover the latter.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Isolation.&lt;/strong&gt; Run in a sandbox or microVM, egress locked to the authorized target. (I run offensive tooling in a localhost-bound container inside a microVM.)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read-only by default&lt;/strong&gt;, with an explicit, logged step to enable any action that changes state.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Human-in-the-loop&lt;/strong&gt; before exploitation/post-exploitation, not after.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Full logging&lt;/strong&gt; of every action, and a kill switch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Data handling&lt;/strong&gt;: these tools can pull real data. Decide up front what you store, where, and for how long.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Takeaway
&lt;/h2&gt;

&lt;p&gt;Capability is not permission. The agentic-pentest field crossed from "assistant" to "can autonomously compromise a system" sometime in the last year, and most write-ups still talk about it like it's a smarter linter. Pick the tool whose autonomy and guardrails match the job, keep a human on the trigger for anything that &lt;em&gt;acts&lt;/em&gt;, and isolate everything. Used that way, these are the best defensive-testing tools we've ever had. Used carelessly, or by the wrong person, they're exactly what the threat reports say they are.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Authorized targets only. If a tool can exploit, your authorization has to say so.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>ai</category>
      <category>pentesting</category>
      <category>ethics</category>
    </item>
    <item>
      <title>Agentic Pentest Frameworks (2026): The Full Field Guide</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Wed, 28 Oct 2026 07:39:12 +0000</pubDate>
      <link>https://dev.to/mkarytka/agentic-pentest-frameworks-2026-the-full-field-guide-4ka0</link>
      <guid>https://dev.to/mkarytka/agentic-pentest-frameworks-2026-the-full-field-guide-4ka0</guid>
      <description>&lt;p&gt;A few days ago I published a short map of the LLM-driven pentest landscape. I promised a detailed follow-up. This is it. Full comparison table, a taxonomy that makes the field make sense, deep profiles of all twelve projects, quick-start commands for the top three, and where Claude fits in each.&lt;/p&gt;

&lt;p&gt;It's a tooling survey built from public repos and docs. Nothing here is an attack guide, and nothing is tied to a specific target. Stars and last-push dates are a snapshot from &lt;strong&gt;2026-10-26&lt;/strong&gt;, verified via the GitHub API; treat them as a moment in time.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; Sort the field on two axes (where the reasoning lives, how much product wraps it) and twelve repos collapse into four buckets. For most work it's one of three: Strix (fastest to a running autonomous agent), HexStrike (the widest tool arsenal, you supply the brain), or PentAGI (a standing platform with memory and a UI). Shannon is the white-box specialist; RedAmon closes the loop with an auto-fix PR. The real bottleneck everywhere is tool-calling discipline, and a strong model removes it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The mistake everyone makes
&lt;/h2&gt;

&lt;p&gt;People line these projects up and compare star counts. That's comparing a library to a product to a protocol server. The field only makes sense once you place each tool on &lt;strong&gt;two axes&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Where does the reasoning live?&lt;/strong&gt; External client ↔ built-in.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;How much product/infrastructure wraps it?&lt;/strong&gt; Library ↔ full platform.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvb919lhjzq9poafkq0ak.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvb919lhjzq9poafkq0ak.png" alt="Taxonomy: where the brain lives vs how much product wraps it" width="800" height="495"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That gives four categories:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Tool layers&lt;/strong&gt;: hands, no brain. Reasoning is an external client/LLM; no agent loop and no built-in finding validation. → &lt;em&gt;HexStrike AI, Reaper.&lt;/em&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Builder frameworks&lt;/strong&gt;: SDKs to assemble your own agent. They ship example use-cases, but the logic is yours. → &lt;em&gt;hackingBuddyGPT, CAI (archived).&lt;/em&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Autonomous agents&lt;/strong&gt;: the loop (reason → tool-call → observe → decide) ships in the box; many self-validate findings. → &lt;em&gt;Strix, Shannon, PentestGPT, Pentest Copilot, Nebula, AI-OPS.&lt;/em&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Platforms&lt;/strong&gt;: an autonomous agent plus a product: web UI, persistent memory, Automation + human-in-the-loop, observability. → &lt;em&gt;PentAGI, RedAmon.&lt;/em&gt;
&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Boundaries blur (RedAmon is a pipeline shipped as a platform; Pentest Copilot is an agent that also exposes a tool layer over MCP), but the four buckets are the right mental model.&lt;/p&gt;

&lt;h2&gt;
  
  
  The full comparison
&lt;/h2&gt;

&lt;p&gt;Maintenance: 🟢 active (push &amp;lt; 3 mo) · 🟡 slowing · 🔴 archived. Snapshot 2026-10-26.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Project&lt;/th&gt;
&lt;th&gt;★&lt;/th&gt;
&lt;th&gt;Push&lt;/th&gt;
&lt;th&gt;Status&lt;/th&gt;
&lt;th&gt;License&lt;/th&gt;
&lt;th&gt;Type&lt;/th&gt;
&lt;th&gt;Architecture (short)&lt;/th&gt;
&lt;th&gt;Claude&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/usestrix/strix" rel="noopener noreferrer"&gt;Strix&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;72.0k&lt;/td&gt;
&lt;td&gt;10-25&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;Apache-2.0&lt;/td&gt;
&lt;td&gt;autonomous multi-agent&lt;/td&gt;
&lt;td&gt;Graph of Agents (OpenAI Agents SDK), every turn = tool call&lt;/td&gt;
&lt;td&gt;✅ first-class&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/vxcontrol/pentagi" rel="noopener noreferrer"&gt;PentAGI&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;32.5k&lt;/td&gt;
&lt;td&gt;10-22&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;platform + multi-agent&lt;/td&gt;
&lt;td&gt;orchestrator → specialists, Postgres+pgvector, opt. Neo4j&lt;/td&gt;
&lt;td&gt;✅ env/WIF, per-agent&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;HexStrike&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;13.1k&lt;/td&gt;
&lt;td&gt;08-03&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;MCP tool layer&lt;/td&gt;
&lt;td&gt;FastMCP server (&lt;code&gt;:8888&lt;/code&gt;) + bridge, brain external&lt;/td&gt;
&lt;td&gt;✅ main path&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/KeygraphHQ/shannon" rel="noopener noreferrer"&gt;Shannon&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;49.4k&lt;/td&gt;
&lt;td&gt;10-15&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;AGPL-3.0&lt;/td&gt;
&lt;td&gt;autonomous agent (web/API)&lt;/td&gt;
&lt;td&gt;white-box: source analysis + browser/CLI → PoC&lt;/td&gt;
&lt;td&gt;✅ provider-agnostic&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/samugit83/redamon" rel="noopener noreferrer"&gt;RedAmon&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;3.2k&lt;/td&gt;
&lt;td&gt;10-22&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;autonomous pipeline&lt;/td&gt;
&lt;td&gt;recon→exploit→post-ex→triage→codefix→PR, Neo4j, 7 containers&lt;/td&gt;
&lt;td&gt;✅ via harness&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/GreyDGL/PentestGPT" rel="noopener noreferrer"&gt;PentestGPT&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;16.1k&lt;/td&gt;
&lt;td&gt;07-14&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;agent + assistant&lt;/td&gt;
&lt;td&gt;multi-stage pipeline, drives Claude Code/Codex&lt;/td&gt;
&lt;td&gt;✅ backend&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/bugbasesecurity/pentest-copilot" rel="noopener noreferrer"&gt;Pentest Copilot&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;1.5k&lt;/td&gt;
&lt;td&gt;08-14&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;agent (browser)&lt;/td&gt;
&lt;td&gt;loop ≤25 iters, 16 tools, Burp, subagents, exposes MCP&lt;/td&gt;
&lt;td&gt;✅ provider/MCP&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/berylliumsec/nebula" rel="noopener noreferrer"&gt;Nebula&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;1.1k&lt;/td&gt;
&lt;td&gt;10-25&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;BSD-2&lt;/td&gt;
&lt;td&gt;harness + agents&lt;/td&gt;
&lt;td&gt;Butler → agents → subagents, SQLite+Chroma memory&lt;/td&gt;
&lt;td&gt;✅ connect&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/antoninoLorenzo/AI-OPS" rel="noopener noreferrer"&gt;AI-OPS&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;168&lt;/td&gt;
&lt;td&gt;10-25&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;agent behind HTTP API&lt;/td&gt;
&lt;td&gt;API container + CLI, litellm, for mid-size LLMs&lt;/td&gt;
&lt;td&gt;✅ via litellm&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/ipa-lab/hackingBuddyGPT" rel="noopener noreferrer"&gt;hackingBuddyGPT&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;1.3k&lt;/td&gt;
&lt;td&gt;10-24&lt;/td&gt;
&lt;td&gt;🟢&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;builder framework&lt;/td&gt;
&lt;td&gt;use-cases, planner/executor, SSH/shell connectors, RAG&lt;/td&gt;
&lt;td&gt;✅ via provider&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/ghostsecurity/reaper" rel="noopener noreferrer"&gt;Reaper&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;0.9k&lt;/td&gt;
&lt;td&gt;03-24&lt;/td&gt;
&lt;td&gt;🟡&lt;/td&gt;
&lt;td&gt;Apache-2.0&lt;/td&gt;
&lt;td&gt;MITM proxy (AppSec)&lt;/td&gt;
&lt;td&gt;traffic capture to DB + CLI, agent-friendly&lt;/td&gt;
&lt;td&gt;⚠️ via skills&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/aliasrobotics/cai" rel="noopener noreferrer"&gt;CAI&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;9.8k&lt;/td&gt;
&lt;td&gt;08-22&lt;/td&gt;
&lt;td&gt;🔴&lt;/td&gt;
&lt;td&gt;archived&lt;/td&gt;
&lt;td&gt;builder framework&lt;/td&gt;
&lt;td&gt;agent handoffs/tracing, 300+ backends (LiteLLM)&lt;/td&gt;
&lt;td&gt;✅ (archived)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flwn0dyrigq9en4z52aab.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flwn0dyrigq9en4z52aab.png" alt="Popularity vs maintenance: stars (log) against last commit" width="800" height="495"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Read that chart as a story, not a ranking. The most-starred projects (Strix, Shannon, PentAGI) are also the most actively maintained; top-right is where you want to be. CAI sits at ~10k stars but is &lt;strong&gt;archived&lt;/strong&gt; (gray): popularity is not maintenance, and an unmaintained offensive framework is a liability, not a win.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where scope is enforced
&lt;/h2&gt;

&lt;p&gt;One axis the big table hides: when an agent decides a target is in scope, is that enforced &lt;em&gt;in the prompt&lt;/em&gt;, checked &lt;em&gt;in code&lt;/em&gt; before each tool call, or backstopped by the &lt;em&gt;sandbox&lt;/em&gt; it runs in? It's easy to overlook when a run goes well. It matters the moment one goes sideways, a prompt-injected page or a confused agent reaching for something out of bounds, which is exactly when a prompt-level rule folds.&lt;/p&gt;

&lt;p&gt;Three mechanisms, weakest to strongest:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Prompt only.&lt;/strong&gt; The instructions say "stay in scope" and the model's judgment is the single gate. HexStrike (brain is external, no built-in guard), Pentest Copilot (commands run straight on the attack box), and the builder kits (hackingBuddyGPT, CAI, where scope is whatever you code) live here.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sandbox / egress.&lt;/strong&gt; Scope becomes "what the box can reach." Strix, PentAGI, Shannon (repo mounted read-only), RedAmon (a socket-proxy broker), and Nebula (optional OpenVPN egress) contain the blast radius even when the agent misjudges. Strong backstop, but it's containment, not a per-call scope check.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Code, pre-call.&lt;/strong&gt; A command allow-list checked in code before the tool fires, default-deny. AI-OPS is the clearest example, allow-list-guarded by design precisely because it targets modest local models and can't trust the model to police itself.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The gap worth noticing: almost nobody does an explicit in-code scope check &lt;em&gt;and&lt;/em&gt; a sandbox. Most pick one, and much of the field still leans on the prompt alone. A pre-call allow-list plus egress lockdown is largely open ground if you're building in this space. (Thanks to a reader building exactly that for the nudge to spell this out.)&lt;/p&gt;

&lt;h2&gt;
  
  
  The three you'll actually reach for
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Strix: autonomous agent, batteries included
&lt;/h3&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/usestrix" rel="noopener noreferrer"&gt;
        usestrix
      &lt;/a&gt; / &lt;a href="https://github.com/usestrix/strix" rel="noopener noreferrer"&gt;
        strix
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;p&gt;
  &lt;a href="https://strix.ai/" rel="nofollow noopener noreferrer"&gt;
    &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fgithub.com%2Fusestrix%2F.github%2Fraw%2Fmain%2Fimgs%2Fcover.png" alt="Strix Banner" width="100%"&gt;
  &lt;/a&gt;
&lt;/p&gt;

&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;Strix&lt;/h1&gt;
&lt;/div&gt;

&lt;div class="markdown-heading"&gt;
&lt;h3 class="heading-element"&gt;The open-source AI pentesting tool. Autonomous AI hackers that find and fix your app’s vulnerabilities.&lt;/h3&gt;
&lt;/div&gt;



&lt;p&gt;&lt;a href="https://docs.strix.ai" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/3b29f0dbefd60a2e8efe2c5708b4f08a948a3779b1f885bd528e7cf4b9ca4dd8/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f446f63732d646f63732e73747269782e61692d3262393234363f7374796c653d666f722d7468652d6261646765266c6f676f3d676974626f6f6b266c6f676f436f6c6f723d7768697465" alt="Docs"&gt;&lt;/a&gt;
&lt;a href="https://strix.ai" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/fcb355d3297cbef1ea9cb5707902eaf75998b4d2a0be47170c4e764c2e8cdd48/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f576562736974652d73747269782e61692d6630663066303f7374796c653d666f722d7468652d6261646765266c6f676f436f6c6f723d303030303030" alt="Website"&gt;&lt;/a&gt;
&lt;a href="https://discord.gg/strix-ai" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/56dd9f9923cd4068b6867376f9a6f39875be480d9469a1771a1a718628312131/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f73747269782d6169" alt=""&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://app.strix.ai?utm_source=github&amp;amp;utm_medium=readme&amp;amp;utm_content=badge_cloud" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/2c8db6d550e2dba0d5939348f8f456aeed5938afd774fa2d4247a4eaab3b80bc/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5374726978253230436c6f75642d6170702e73747269782e61692d3262393234363f7374796c653d666f722d7468652d6261646765266c6f676f436f6c6f723d7768697465" alt="Strix Cloud"&gt;&lt;/a&gt;
&lt;a href="https://strix.ai/demo?utm_source=github&amp;amp;utm_medium=readme&amp;amp;utm_content=badge_demo" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/26506dc9b6cf381a65e390f1f05165d1562cbef19d6d2bd5d90e328435b98ffe/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5472792532305374726978253230456e74657270726973652d3535353535353f7374796c653d666f722d7468652d6261646765266c6f676f436f6c6f723d7768697465" alt="Try Strix Enterprise"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://github.com/usestrix/strix" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/b227469b02f6fd459ad3037c371944a99b0d0dceacb1fbc80d092db2f48e371d/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f73746172732f75736573747269782f73747269783f7374796c653d666c61742d737175617265" alt="GitHub Stars"&gt;&lt;/a&gt;
&lt;a href="https://github.com/usestrix/strix/LICENSE" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/3f06f12cb48aae71cbee9ceb22c689e0db93f45128d8ab6e09660e0962e8b874/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d417061636865253230322e302d3362383266363f7374796c653d666c61742d737175617265" alt="License"&gt;&lt;/a&gt;
&lt;a href="https://pypi.org/project/strix-agent/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/77587de0ac0e2da4453ac3b5936d08c68f8474cc09abf785c63657977ce7458e/68747470733a2f2f696d672e736869656c64732e696f2f707970692f762f73747269782d6167656e743f7374796c653d666c61742d737175617265" alt="PyPI Version"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/strix-ai" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fgithub.com%2Fusestrix%2F.github%2Fraw%2Fmain%2Fimgs%2FDiscord.png" height="40" alt="Join Discord"&gt;&lt;/a&gt;
&lt;a href="https://x.com/strix_ai" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fgithub.com%2Fusestrix%2F.github%2Fraw%2Fmain%2Fimgs%2FX.png" height="40" alt="Follow on X"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://trendshift.io/repositories/15362?utm_source=trendshift-badge&amp;amp;utm_medium=badge&amp;amp;utm_campaign=badge-trendshift-15362" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/7a64e23cce334247b89ace56000e9acf33f429b49d33f7f1ddbee01e1194a96b/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7472656e6473686966742f7265706f7369746f726965732f31353336322f7765656b6c79" alt="usestrix%2Fstrix | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt;
&lt;a href="https://trendshift.io/repositories/15362" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/203612372d9583089cc6bd80e3ea46197dd43c504417b9a1660a111c9f208e72/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7265706f7369746f726965732f3135333632" alt="usestrix/strix | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-alert markdown-alert-tip"&gt;
&lt;p class="markdown-alert-title"&gt;Tip&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;New!&lt;/strong&gt; Strix integrates seamlessly with GitHub Actions and CI/CD pipelines. Automatically scan for vulnerabilities on every pull request and block insecure code before it reaches production - &lt;a href="https://app.strix.ai?utm_source=github&amp;amp;utm_medium=readme&amp;amp;utm_content=tip_ci" rel="nofollow noopener noreferrer"&gt;Get started with no setup required&lt;/a&gt;.&lt;/p&gt;
&lt;/div&gt;

&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Strix Overview&lt;/h2&gt;
&lt;/div&gt;
&lt;p&gt;Strix are autonomous AI penetration testing agents that act just like real hackers - they run your code dynamically, find vulnerabilities, and validate them through actual proofs-of-concept. Built for developers and security teams who need fast, accurate security testing without the overhead of manual pentesting or the false positives of static analysis tools.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Key Capabilities:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Full pentesting toolkit&lt;/strong&gt; - reconnaissance, exploitation, and validation out of the box&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Multi-agent orchestration&lt;/strong&gt; - teams of AI pentesters that collaborate and scale&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Real exploit validation&lt;/strong&gt; - working PoCs, not false positives like legacy vulnerability scanners&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Developer‑first CLI&lt;/strong&gt; - actionable findings with…&lt;/li&gt;
&lt;/ul&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/usestrix/strix" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;p&gt;A &lt;em&gt;Graph of Agents&lt;/em&gt; on the OpenAI Agents SDK: a root agent delegates to sub-agents (recon, injection, auth…) via &lt;code&gt;create_agent&lt;/code&gt;, and every turn must end in a tool call, which keeps reasoning from drifting into prose. Findings are validated with working PoCs before they hit the report. Execution runs in a sandbox. It's mainly an MCP client, though a hosted service also exposes an MCP server over its API.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tools:&lt;/strong&gt; HTTP intercept (Caido), browser testing, shell, a Python runtime for exploits, recon/OSINT, SAST+DAST, a findings KB with CVSS/OWASP tags.&lt;br&gt;
&lt;strong&gt;Pros:&lt;/strong&gt; ready agent; PoC validation + auto-fix + reports; CI mode; LiteLLM routing; minimal infra.&lt;br&gt;
&lt;strong&gt;Cons:&lt;/strong&gt; smaller arsenal than HexStrike; quality tracks the model hard; no rich UI/HITL.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# representative: check the repo README for current flags&lt;/span&gt;
pipx install strix-agent
&lt;span class="kd"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;STRIX_LLM&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"anthropic/claude-sonnet-4-x"&lt;/span&gt;
&lt;span class="kd"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;LLM_API_KEY&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"sk-ant-..."&lt;/span&gt;
strix --target https://your-authorized-target.example
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  HexStrike AI: the arsenal, brain sold separately
&lt;/h3&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/0x4m4" rel="noopener noreferrer"&gt;
        0x4m4
      &lt;/a&gt; / &lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;
        hexstrike-ai
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      HexStrike AI MCP Agents is an advanced MCP server that lets AI agents (Claude, GPT, Copilot, etc.) autonomously run 150+ cybersecurity tools for automated pentesting, vulnerability discovery, bug bounty automation, and security research. Seamlessly bridge LLMs with real-world offensive security capabilities.
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;a rel="noopener noreferrer" href="https://github.com/0x4m4/hexstrike-ai/assets/hexstrike-logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2F0x4m4%2Fhexstrike-ai%2FHEAD%2Fassets%2Fhexstrike-logo.png" alt="HexStrike AI Logo" width="220"&gt;&lt;/a&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;HexStrike AI MCP Agents v6.0&lt;/h1&gt;
&lt;/div&gt;

&lt;div class="markdown-heading"&gt;
&lt;h3 class="heading-element"&gt;AI-Powered MCP Cybersecurity Automation Platform&lt;/h3&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://www.python.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/eba6a76390a355e795edc24e3446b2834272ae646026e609f36f1805d6036535/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f507974686f6e2d332e382532422d626c75652e737667" alt="Python"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai/LICENSE" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/c23127b34e5bdde22436e60aa41ec5fd4410967d31caefaa1ab8227d2af8dfe0/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4d49542d677265656e2e737667" alt="License"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/7523c993cc3b7b9bfcf4867cf6f6738e75124ef40c374d0419fda50ae6c18820/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f53656375726974792d50656e6574726174696f6e25323054657374696e672d7265642e737667" alt="Security"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/ef3ff7dbfa7c37e4cbfe2a9e4cfc17072d6507dfb1acc7b58fc708f300b7d16e/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d43502d436f6d70617469626c652d707572706c652e737667" alt="MCP"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai/releases" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/068edbb040313007051e18f514535ae804e66fc7c650caac54f30200bb5081c6/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f56657273696f6e2d362e302e302d6f72616e67652e737667" alt="Version"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a52a89f2361f50d56f0d15c7c3882343c32e751ef8b6ee3705e57f4d7da1cb13/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5365637572697479253230546f6f6c732d3135302532422d627269676874677265656e2e737667" alt="Tools"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/99d417730788bd1d49b4332b5247453a477810eccba1804df9bb954485ea2092/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f41492532304167656e74732d31322532422d707572706c652e737667" alt="Agents"&gt;&lt;/a&gt;
&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a9d6410b37f1cc6e68e709fd28225573ab02b621e4b3bc045d279499670ef36e/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f73746172732f3078346d342f686578737472696b652d61693f7374796c653d736f6369616c" alt="Stars"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Advanced AI-powered penetration testing MCP framework with 150+ security tools and 12+ autonomous AI agents&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Owned &amp;amp; developed by &lt;a href="https://overthetop.ae/" rel="nofollow noopener noreferrer"&gt;OTT Cybersecurity LLC&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://github.com/0x4m4/hexstrike-ai#whats-new-in-v60" rel="noopener noreferrer"&gt;📋 What's New&lt;/a&gt; • &lt;a href="https://github.com/0x4m4/hexstrike-ai#architecture-overview" rel="noopener noreferrer"&gt;🏗️ Architecture&lt;/a&gt; • &lt;a href="https://github.com/0x4m4/hexstrike-ai#installation" rel="noopener noreferrer"&gt;🚀 Installation&lt;/a&gt; • &lt;a href="https://github.com/0x4m4/hexstrike-ai#features" rel="noopener noreferrer"&gt;🛠️ Features&lt;/a&gt; • &lt;a href="https://github.com/0x4m4/hexstrike-ai#ai-agents" rel="noopener noreferrer"&gt;🤖 AI Agents&lt;/a&gt; • &lt;a href="https://github.com/0x4m4/hexstrike-ai#api-reference" rel="noopener noreferrer"&gt;📡 API Reference&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;

&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Follow Our Social Accounts&lt;/h2&gt;
&lt;/div&gt;
&lt;p&gt;
  &lt;a href="https://discord.gg/BWnmrrSHbA" rel="nofollow noopener noreferrer"&gt;
    &lt;img src="https://camo.githubusercontent.com/6cd1eb77b1a2e0ac104b7877859d6d5fb1f7ef8641cb3acefd015c1befdc61a4/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f446973636f72642d4a6f696e2d3732383944413f6c6f676f3d646973636f7264266c6f676f436f6c6f723d7768697465267374796c653d666f722d7468652d6261646765" alt="Join our Discord"&gt;
  &lt;/a&gt;
  &amp;nbsp;&amp;nbsp;
  &lt;a href="https://www.linkedin.com/company/hexstrike-ai" rel="nofollow noopener noreferrer"&gt;
    &lt;img src="https://camo.githubusercontent.com/fdfb1c4e772d3bb2f396125b7b804bf3accd4bde9515d3d15e0fbb98e5d38194/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c696e6b6564496e2d466f6c6c6f7725323075732d3041363643323f6c6f676f3d6c696e6b6564696e266c6f676f436f6c6f723d7768697465267374796c653d666f722d7468652d6261646765" alt="Follow us on LinkedIn"&gt;
  &lt;/a&gt;
&lt;/p&gt;


&lt;/div&gt;
&lt;br&gt;


&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Architecture Overview&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;HexStrike AI MCP v6.0 features a multi-agent architecture with autonomous AI agents, intelligent decision-making, and vulnerability intelligence.&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;&lt;br&gt;
  &amp;lt;div class="js-render-enrichment-target" data-json='{"data":"%%{init: {\"themeVariables\": {\n  \"primaryColor\": \"#b71c1c\",\n  \"secondaryColor\": \"#ff5252\",\n  \"tertiaryColor\": \"#ff8a80\",\n  \"background\": \"#2d0000\",\n  \"edgeLabelBackground\":\"#b71c1c\",\n  \"fontFamily\": \"monospace\",\n  \"fontSize\": \"16px\",\n  \"fontColor\": \"#fffde7\",\n  \"nodeTextColor\": \"#fffde7\"\n}}}%%\ngraph TD\n    A[AI Agent - Claude/GPT/Copilot] --&amp;gt;|MCP Protocol| B[HexStrike MCP Server v6.0]\n    \n    B --&amp;gt; C[Intelligent Decision Engine]\n    B --&amp;gt; D[12+ Autonomous AI Agents]\n    B --&amp;gt; E[Modern Visual Engine]\n    \n    C --&amp;gt; F[Tool Selection AI]\n    C --&amp;gt; G[Parameter Optimization]\n    C --&amp;gt; H[Attack Chain Discovery]\n    \n    D --&amp;gt; I[BugBounty Agent]\n    D --&amp;gt; J[CTF Solver Agent]\n    D --&amp;gt; K[CVE Intelligence Agent]\n    D --&amp;gt; L[Exploit Generator Agent]\n    \n    E --&amp;gt; M[Real-time Dashboards]\n    E --&amp;gt; N[Progress Visualization]\n    E --&amp;gt; O[Vulnerability Cards]\n    \n    B --&amp;gt; P[150+ Security Tools]\n    P --&amp;gt; Q[Network Tools - 25+]\n    P --&amp;gt; R[Web App Tools - 40+]\n    P --&amp;gt; S[Cloud Tools - 20+]\n    P --&amp;gt; T[Binary Tools - 25+]\n    P --&amp;gt; U[CTF Tools - 20+]\n    P --&amp;gt; V[OSINT Tools - 20+]\n    \n    B --&amp;gt; W[Advanced Process Management]\n    W --&amp;gt; X[Smart Caching]\n    W --&amp;gt; Y[Resource Optimization]\n    W --&amp;gt; Z[Error Recovery]\n    \n    style A fill:#b71c1c,stroke:#ff5252,stroke-width:3px,color:#fffde7\n    style B fill:#ff5252,stroke:#b71c1c,stroke-width:4px,color:#fffde7\n    style C fill:#ff8a80,stroke:#b71c1c,stroke-width:2px,color:#fffde7\n    style D fill:#ff8a80,stroke:#b71c1c,stroke-width:2px,color:#fffde7\n    style E fill:#ff8a80,stroke:#b71c1c,stroke-width:2px,color:#fffde7\n"}' data-plain='%%{init: {"themeVariables": {&lt;br&gt;
  "primaryColor": "#b71c1c"&lt;br&gt;
  "secondaryColor": "#ff5252",&lt;br&gt;
  "tertiaryColor": "#ff8a80",&lt;br&gt;
  "background": "#2d0000",&lt;br&gt;
  "edgeLabelBackground":"#b71c1c",&lt;br&gt;
  "fontFamily": "monospace",&lt;br&gt;
  "fontSize": "16px",&lt;br&gt;
  "fontColor": "#fffde7",&lt;br&gt;
  "nodeTextColor": "#fffde7"&lt;br&gt;
}}}%%&lt;br&gt;
graph TD&lt;br&gt;
    A[AI Agent - Claude/GPT/Copilot] --&amp;gt;|MCP Protocol| B[HexStrike MCP Server v6.0]&lt;p&gt;&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;B --&amp;amp;gt; C[Intelligent Decision Engine]
B --&amp;amp;gt; D[12+ Autonomous AI Agents]
B --&amp;amp;gt; E[Modern Visual Engine]

C --&amp;amp;gt; F[Tool Selection AI]
C --&amp;amp;gt; G[Parameter Optimization]
C --&amp;amp;gt; H[Attack Chain Discovery]

D --&amp;amp;gt; I[BugBounty Agent]
D --&amp;amp;gt; J[CTF Solver Agent]
D --&amp;amp;gt; K[CVE Intelligence Agent]
D --&amp;amp;gt; L[Exploit Generator Agent]

E --&amp;amp;gt; M[Real-time Dashboards]
E --&amp;amp;gt; N[Progress Visualization]
E --&amp;amp;gt; O[Vulnerability Cards]

B --&amp;amp;gt; P[150+ Security Tools]
P --&amp;amp;gt; Q[Network Tools - 25+]
P --&amp;amp;gt; R[Web App Tools - 40+]
P --&amp;amp;gt; S[Cloud Tools - 20+]
P --&amp;amp;gt; T[Binary Tools - 25+]
P --&amp;amp;gt; U[CTF Tools - 20+]
P --&amp;amp;gt; V[OSINT Tools - 20+]

B --&amp;amp;gt; W[Advanced Process Management]
W --&amp;amp;gt; X[Smart Caching]
W --&amp;amp;gt; Y[Resource Optimization]
W --&amp;amp;gt; Z[Error Recovery]

style A fill:#b71c1c,stroke:#ff5252,stroke-width:3px,color:#fffde7
style B fill:#ff5252,stroke:#b71c1c,stroke-width:4px,color:#fffde7
style C fill:#ff8a80,stroke:#b71c1c,stroke-width:2px,color:#fffde7
style D fill:#ff8a80,stroke:#b71c1c,stroke-width:2px,color:#fffde7
style E fill:#ff8a80,stroke:#b71c1c,stroke-width:2px,color:#fffde7
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;
&lt;p&gt;' dir="auto"&amp;gt;&lt;br&gt;
    &lt;/p&gt;
&lt;div class="render-plaintext-hidden"&gt;
&lt;br&gt;
      &lt;pre&gt;%%{init: {"themeVariables": {&lt;br&gt;
  "primaryColor": "#b71c1c"&lt;br&gt;
  "secondaryColor": "#ff5252"&lt;br&gt;
  "tertiaryColor": "#ff8a80",&lt;br&gt;
  "background": "#2d0000",&lt;br&gt;
  "edgeLabelBackground":"#b71c1c",&lt;br&gt;
  "fontFamily": "monospace",&lt;br&gt;
  "fontSize": "16px",&lt;br&gt;
  "fontColor": "#fffde7",&lt;br&gt;
  "nodeTextColor": "#fffde7"&lt;br&gt;
}}}%%&lt;br&gt;
graph TD&lt;br&gt;
    A[AI Agent - Claude/GPT/Copilot] --&amp;gt;|MCP Protocol| B[HexStrike MCP Server v6.0]
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;B --&amp;amp;gt; C[Intelligent Decision Engine]
B --&amp;amp;gt; D[12+ Autonomous AI Agents]
B --&amp;amp;gt; E[Modern Visual Engine]

C --&amp;amp;gt; F[Tool Selection AI]
C --&amp;amp;gt; G[Parameter Optimization]
C --&amp;amp;gt; H[Attack Chain Discovery]

D --&amp;amp;gt; I[BugBounty Agent]
D --&amp;amp;gt; J[CTF Solver Agent]
D --&amp;amp;gt; K[CVE&amp;lt;/pre&amp;gt;…&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;
&lt;/pre&gt;
&lt;/div&gt;&lt;/div&gt;
&lt;br&gt;
  &lt;/div&gt;
&lt;br&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;br&gt;
&lt;/div&gt;
&lt;br&gt;


&lt;p&gt;A server (&lt;code&gt;hexstrike_server.py&lt;/code&gt; on &lt;code&gt;:8888&lt;/code&gt;) wrapping its tools (150-plus by the project's own count) as MCP functions, plus a REST API (&lt;code&gt;/api/intelligence/*&lt;/code&gt;, &lt;code&gt;/api/command&lt;/code&gt;). Helper components exist (a decision engine, workflow managers), but the real reasoning is the attached MCP client. &lt;strong&gt;Tools:&lt;/strong&gt; that 150-plus span Network/Web/Cloud/Binary/CTF/OSINT (nmap, nuclei, sqlmap, Ghidra, Prowler, Trivy…).&lt;br&gt;
&lt;strong&gt;Pros:&lt;/strong&gt; widest ready arsenal; clean brain/hands split; REST for custom pipelines.&lt;br&gt;
&lt;strong&gt;Cons:&lt;/strong&gt; not self-sufficient; no built-in finding validation (reporting is basic); dual-use, so isolation is on you.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# start the tool server (ideally inside an isolated container)&lt;/span&gt;
python3 hexstrike_server.py           &lt;span class="c"&gt;# serves :8888&lt;/span&gt;

&lt;span class="c"&gt;# wire it into Claude Code as an MCP server&lt;/span&gt;
&lt;span class="c"&gt;# (the README also documents a JSON config block for Claude Desktop / VS Code)&lt;/span&gt;
claude mcp add hexstrike -- \
  python3 /path/hexstrike_mcp.py --server http://localhost:8888
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  PentAGI: the platform
&lt;/h3&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/vxcontrol" rel="noopener noreferrer"&gt;
        vxcontrol
      &lt;/a&gt; / &lt;a href="https://github.com/vxcontrol/pentagi" rel="noopener noreferrer"&gt;
        pentagi
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      Fully autonomous AI Agents system capable of performing complex penetration testing tasks
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;PentAGI&lt;/h1&gt;
&lt;/div&gt;

&lt;div&gt;
    &lt;strong&gt;P&lt;/strong&gt;enetration testing &lt;strong&gt;A&lt;/strong&gt;rtificial &lt;strong&gt;G&lt;/strong&gt;eneral &lt;strong&gt;I&lt;/strong&gt;ntelligence
&lt;/div&gt;



&lt;div&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Join the Community!&lt;/strong&gt; Connect with security researchers, AI enthusiasts, and fellow ethical hackers. Get support, share insights, and stay updated with the latest PentAGI developments.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;a href="https://discord.gg/2xrMh7qX6m" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/23ac37b99e02a564616ff9825b3f9a43cdf6eda49802f5d89a0945e761fe9f0b/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f446973636f72642d3732383944413f6c6f676f3d646973636f7264266c6f676f436f6c6f723d7768697465" alt="Discord"&gt;&lt;/a&gt;⠀&lt;a href="https://t.me/+Ka9i6CNwe71hMWQy" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a5d70c480a157ea632b418f117d13fb5d14803ec4458c539ccbef22cb20bdb3f/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f54656c656772616d2d3243413545303f6c6f676f3d74656c656772616d266c6f676f436f6c6f723d7768697465" alt="Telegram"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://trendshift.io/repositories/15161?utm_source=repository-badge&amp;amp;utm_medium=badge&amp;amp;utm_campaign=badge-repository-15161" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/519bade9296640b234c9fa1668a5b179a7ad00e9a9edfd000ad749cbeb0bd13f/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7265706f7369746f726965732f3135313631" alt="vxcontrol%2Fpentagi | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt; &lt;a href="https://trendshift.io/repositories/15161?utm_source=trendshift-badge&amp;amp;utm_medium=badge&amp;amp;utm_campaign=badge-trendshift-15161" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/7ad5fa8981c8ac43c338928deff3fb7f62a5e726f896dcf1cb9ed2a7664008f7/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7472656e6473686966742f7265706f7369746f726965732f31353136312f6461696c79" alt="vxcontrol%2Fpentagi | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://trendshift.io/repositories/15161?utm_source=trendshift-badge&amp;amp;utm_medium=badge&amp;amp;utm_campaign=badge-trendshift-15161" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/4bf09d59d5910cce89d3ea6d42e15549ba203cea73c83c38de456b8e9db612d8/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7472656e6473686966742f7265706f7369746f726965732f31353136312f6461696c793f6c616e67756167653d476f" alt="vxcontrol%2Fpentagi | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt; &lt;a href="https://trendshift.io/repositories/15161?utm_source=trendshift-badge&amp;amp;utm_medium=badge&amp;amp;utm_campaign=badge-trendshift-15161" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/12fb618e9756839de121a39bd966d9ff64474e203c1188dc6b1c6f2367276d91/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7472656e6473686966742f7265706f7369746f726965732f31353136312f7765656b6c793f6c616e67756167653d476f" alt="vxcontrol%2Fpentagi | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt; &lt;a href="https://trendshift.io/repositories/15161?utm_source=trendshift-badge&amp;amp;utm_medium=badge&amp;amp;utm_campaign=badge-trendshift-15161" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/fc7a82385052b9b6bb3782879cd3de92094b8545b127a5a2dd73929c8083f0a9/68747470733a2f2f7472656e6473686966742e696f2f6170692f62616467652f7472656e6473686966742f7265706f7369746f726965732f31353136312f6d6f6e74686c793f6c616e67756167653d476f" alt="vxcontrol%2Fpentagi | Trendshift" width="250" height="55" class="js-gh-image-fallback"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;

&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Table of Contents&lt;/h2&gt;
&lt;/div&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#overview" rel="noopener noreferrer"&gt;Overview&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#features" rel="noopener noreferrer"&gt;Features&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/vxcontrol/pentagi#architecture" rel="noopener noreferrer"&gt;Architecture&lt;/a&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#advanced-agent-supervision" rel="noopener noreferrer"&gt;Agent Supervision&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;


&lt;/li&gt;

&lt;li&gt;

&lt;a href="https://github.com/vxcontrol/pentagi#quick-start" rel="noopener noreferrer"&gt;Quick Start&lt;/a&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#giving-agents-docker-without-giving-away-the-host" rel="noopener noreferrer"&gt;Agent Docker Access&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#running-several-instances-tenant_id" rel="noopener noreferrer"&gt;Running Several Instances&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;


&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#how-to-use-pentagi-after-login" rel="noopener noreferrer"&gt;How to Use PentAGI After Login&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;

&lt;a href="https://github.com/vxcontrol/pentagi#api-access" rel="noopener noreferrer"&gt;API Access&lt;/a&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://github.com/vxcontrol/pentagi#custom-llm-provider-configuration" rel="noopener noreferrer"&gt;LLM Provider Configuration&lt;/a&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#using-azure-openai" rel="noopener noreferrer"&gt;Azure OpenAI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#ollama-provider-configuration" rel="noopener noreferrer"&gt;Ollama&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#openai-provider-configuration" rel="noopener noreferrer"&gt;OpenAI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#anthropic-provider-configuration" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#google-ai-gemini-provider-configuration" rel="noopener noreferrer"&gt;Google AI (Gemini)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#aws-bedrock-provider-configuration" rel="noopener noreferrer"&gt;AWS Bedrock&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#deepseek-provider-configuration" rel="noopener noreferrer"&gt;DeepSeek&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#glm-provider-configuration" rel="noopener noreferrer"&gt;GLM&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#kimi-provider-configuration" rel="noopener noreferrer"&gt;Kimi&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#qwen-provider-configuration" rel="noopener noreferrer"&gt;Qwen&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#minimax-provider-configuration" rel="noopener noreferrer"&gt;MiniMax&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#mistral-provider-configuration" rel="noopener noreferrer"&gt;Mistral&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#xai-grok-provider-configuration" rel="noopener noreferrer"&gt;xAI (Grok)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;


&lt;/li&gt;

&lt;/ul&gt;

&lt;/li&gt;

&lt;li&gt;

&lt;a href="https://github.com/vxcontrol/pentagi#advanced-setup" rel="noopener noreferrer"&gt;Advanced Setup&lt;/a&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#langfuse-integration" rel="noopener noreferrer"&gt;Langfuse Integration&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#monitoring-and-observability" rel="noopener noreferrer"&gt;Monitoring and Observability&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#knowledge-graph-integration-graphiti" rel="noopener noreferrer"&gt;Knowledge Graph (Graphiti)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#github-and-google-oauth-integration" rel="noopener noreferrer"&gt;OAuth Integration&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#docker-image-configuration" rel="noopener noreferrer"&gt;Docker Image Configuration&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;


&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#development" rel="noopener noreferrer"&gt;Development&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#testing-llm-agents" rel="noopener noreferrer"&gt;Testing LLM Agents&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#embedding-configuration-and-testing" rel="noopener noreferrer"&gt;Embedding Configuration and Testing&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#function-testing-with-ftester" rel="noopener noreferrer"&gt;Function Testing with ftester&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#building" rel="noopener noreferrer"&gt;Building&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#credits" rel="noopener noreferrer"&gt;Credits&lt;/a&gt;&lt;/li&gt;

&lt;li&gt;&lt;a href="https://github.com/vxcontrol/pentagi#license" rel="noopener noreferrer"&gt;License&lt;/a&gt;&lt;/li&gt;

&lt;/ul&gt;

&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Overview&lt;/h2&gt;
&lt;/div&gt;

&lt;p&gt;PentAGI is an open-source, self-hosted multi-agent system for autonomous penetration testing. You describe a target and a goal in plain language; a team of specialized AI agents plans the work, runs 20+ professional tools such as nmap, Metasploit…&lt;/p&gt;&lt;/div&gt;


&lt;/div&gt;
&lt;br&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/vxcontrol/pentagi" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;br&gt;
&lt;/div&gt;
&lt;br&gt;


&lt;p&gt;An orchestrator analyzes the target and spawns specialists (researcher, developer, executor) plus helpers (searcher, memorist, reporter, reflector…). Tools run in isolated Docker sandboxes. &lt;strong&gt;Memory:&lt;/strong&gt; Postgres + pgvector, optional Neo4j graph via Graphiti. &lt;strong&gt;Observability:&lt;/strong&gt; Grafana/Prometheus, optional Langfuse. &lt;strong&gt;LLM:&lt;/strong&gt; 10+ providers, &lt;strong&gt;model choice per agent&lt;/strong&gt;.&lt;br&gt;
&lt;strong&gt;Pros:&lt;/strong&gt; most product-like (web console, Automation + Assistant HITL, MD/PDF reports), long-term memory, per-agent models.&lt;br&gt;
&lt;strong&gt;Cons:&lt;/strong&gt; heaviest to deploy; fewer tools than HexStrike.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# representative: see the repo for the current compose setup&lt;/span&gt;
git clone https://github.com/vxcontrol/pentagi &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="nb"&gt;cd&lt;/span&gt; pentagi
cp .env.example .env         &lt;span class="c"&gt;# set ANTHROPIC_API_KEY and friends&lt;/span&gt;
docker compose up -d         &lt;span class="c"&gt;# web UI, Postgres, (optional) Neo4j&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The rest of the field
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Shannon&lt;/strong&gt;: white-box &lt;em&gt;by design&lt;/em&gt;. It starts from the target's &lt;em&gt;source&lt;/em&gt; to map attack vectors, then proves them with real exploits ("no exploit, no report"), with the repo mounted read-only in an ephemeral Docker worker. Others touch code too (Strix runs SAST as one tool in a mostly black-box agent, RedAmon clones the repo to triage and fix), but Shannon is the one built source-first rather than bolting static analysis onto a black-box loop. &lt;strong&gt;AGPL-3.0&lt;/strong&gt; matters if you're commercial; needs source access; and provider-side safeguards can interrupt a run, so clear the Anthropic/OpenAI legitimate-tester verification first.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;RedAmon&lt;/strong&gt;: recon → exploit → post-exploit → triage → &lt;strong&gt;code-fix → GitHub PR&lt;/strong&gt;, with a Neo4j attack graph, a &lt;code&gt;docker-broker&lt;/code&gt; socket proxy, and human approval gates on high-impact tools. Heavy (~200 to 250 GB for a real server) but closes the offense→defense loop.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PentestGPT&lt;/strong&gt;: USENIX-2024 pedigree; multi-stage pipeline; its agentic mode &lt;strong&gt;drives Claude Code or Codex&lt;/strong&gt; as the execution backend.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pentest Copilot&lt;/strong&gt;: browser-driven agent, 16 tools incl. Burp, subagent parallelism, and it exposes an MCP server that clients like Claude Code drive. Its MCP token is effectively local admin, so mind the risk.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Nebula&lt;/strong&gt;: a desktop "harness" with a Butler oversight layer, selective memory, Docker/Podman or host mode, optional OpenVPN egress.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AI-OPS&lt;/strong&gt;: built for mid-size/local models. An API container (agent+tools) + CLI, litellm, with a default-deny command allow-list enforced in code. Works with any OpenAI-compatible or self-hosted endpoint via litellm.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;hackingBuddyGPT&lt;/strong&gt;: a builder kit. Express a new experiment in a few dozen lines; explicit planner/executor and RAG patterns; a Docker-fleet launcher for regression runs.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Don't build on archived offensive tooling.&lt;/strong&gt; CAI has 9.8k stars but the repo is archived; unmaintained attack tooling rots as dependencies age. Patterns only. Reaper isn't an agent at all; it's a MITM proxy, good "hands," not a brain.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pick by what you need
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;If you need…&lt;/th&gt;
&lt;th&gt;Reach for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;An autonomous agent working in minutes&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Strix&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;The widest tool arsenal under your own model&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;HexStrike AI&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;A platform with UI, memory, human-in-the-loop&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;PentAGI&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Source-first white-box, exploit-proven&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Shannon&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Offense → defense with an auto-fix PR&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;RedAmon&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;An assistant that drives Claude Code / Codex&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;PentestGPT&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;To run on local / mid-size open models&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;AI-OPS&lt;/strong&gt;, &lt;strong&gt;hackingBuddyGPT&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Where Claude fits
&lt;/h2&gt;

&lt;p&gt;The recurring lesson: tool-calling is the bottleneck, and a strong model removes it. That makes every one of these markedly more stable on Claude than on a small local model.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Claude integration&lt;/th&gt;
&lt;th&gt;Ease&lt;/th&gt;
&lt;th&gt;Note&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Strix&lt;/td&gt;
&lt;td&gt;&lt;code&gt;STRIX_LLM=anthropic/...&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;⭐⭐⭐&lt;/td&gt;
&lt;td&gt;drop-in&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HexStrike&lt;/td&gt;
&lt;td&gt;MCP in Claude Desktop/Code&lt;/td&gt;
&lt;td&gt;⭐⭐&lt;/td&gt;
&lt;td&gt;Claude is the whole brain&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentAGI&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;ANTHROPIC_API_KEY&lt;/code&gt; / WIF&lt;/td&gt;
&lt;td&gt;⭐⭐&lt;/td&gt;
&lt;td&gt;per-agent models; WIF needs no static key&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Shannon&lt;/td&gt;
&lt;td&gt;BYO key (harness)&lt;/td&gt;
&lt;td&gt;⭐⭐&lt;/td&gt;
&lt;td&gt;white-box; provider cyber-verify advised&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestGPT&lt;/td&gt;
&lt;td&gt;Claude Code as backend&lt;/td&gt;
&lt;td&gt;⭐⭐&lt;/td&gt;
&lt;td&gt;drives your Claude Code&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pentest Copilot&lt;/td&gt;
&lt;td&gt;Claude Code / MCP&lt;/td&gt;
&lt;td&gt;⭐⭐&lt;/td&gt;
&lt;td&gt;exposes MCP server&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AI-OPS&lt;/td&gt;
&lt;td&gt;litellm&lt;/td&gt;
&lt;td&gt;⭐⭐&lt;/td&gt;
&lt;td&gt;built for local LLMs&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  If I were starting today
&lt;/h2&gt;

&lt;p&gt;Shortest path to a working autonomous agent: &lt;strong&gt;Strix + a strong model.&lt;/strong&gt; Keep &lt;strong&gt;HexStrike&lt;/strong&gt; as the arsenal you drive from your own client when you need breadth. Stand up &lt;strong&gt;PentAGI&lt;/strong&gt; when a one-off run becomes a standing service. Pull &lt;strong&gt;Shannon&lt;/strong&gt; in for the white-box view your black-box agent can't see. Everything else is a specialist: know it exists, reach for it when the job fits.&lt;/p&gt;

&lt;p&gt;And whatever you run: &lt;strong&gt;authorized targets only, in isolation.&lt;/strong&gt; A sandboxed microVM, egress locked to the target. The capability is real now; so is the responsibility.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Sources: each project's GitHub and docs (linked above), plus the Check Point writeup on HexStrike, and the curated lists &lt;a href="https://github.com/insidetrust/awesome-ai-pentest" rel="noopener noreferrer"&gt;awesome-ai-pentest&lt;/a&gt; and &lt;a href="https://github.com/JoasASantos/Offensive-Security-AI-Models" rel="noopener noreferrer"&gt;Offensive-Security-AI-Models&lt;/a&gt;. Stars/dates verified via the GitHub API on 2026-10-26.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>ai</category>
      <category>pentesting</category>
      <category>llm</category>
    </item>
    <item>
      <title>The Agentic Pentest-Framework Landscape (2026)</title>
      <dc:creator>Mikalai Karytka</dc:creator>
      <pubDate>Mon, 26 Oct 2026 20:34:00 +0000</pubDate>
      <link>https://dev.to/mkarytka/the-agentic-pentest-framework-landscape-2026-5e37</link>
      <guid>https://dev.to/mkarytka/the-agentic-pentest-framework-landscape-2026-5e37</guid>
      <description>&lt;p&gt;I spent a few weeks living inside LLM-driven pentest tools, building and breaking them and running them against a web app I was authorized to test. Twelve projects later, here's the map I wish I'd had on day one: which ones matter, how they differ under the hood, and when to reach for each.&lt;/p&gt;

&lt;p&gt;This is a tooling survey, not a how-to attack guide. Everything below is about open-source projects and public documentation.&lt;/p&gt;

&lt;h2&gt;
  
  
  What "agentic pentest" even means now
&lt;/h2&gt;

&lt;p&gt;A year ago "AI pentesting" mostly meant pasting output into a chat window. In 2026 the serious tools are &lt;em&gt;agentic&lt;/em&gt;: an LLM reasons about a target, calls real tools (nmap, nuclei, sqlmap, a browser, a shell), reads the results, and decides what to do next, looping with little or no human in between.&lt;/p&gt;

&lt;p&gt;That shift splits the field along one axis that matters more than any feature list: &lt;strong&gt;where the brain lives.&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Self-contained agents&lt;/strong&gt; ship the reasoning loop &lt;em&gt;and&lt;/em&gt; the tools. You give them a target and a model; they do the rest.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tool layers&lt;/strong&gt; ship only the hands: a big arsenal exposed over a protocol (usually MCP). The brain is an external client you plug in.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Platforms&lt;/strong&gt; wrap an agent in a product: web UI, memory, multiple models per role, reporting.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Keep that axis in mind and the field stops looking like a pile of repos.&lt;/p&gt;

&lt;h2&gt;
  
  
  The three that matter
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Strix: the batteries-included agent
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/usestrix/strix" rel="noopener noreferrer"&gt;Strix&lt;/a&gt; is an autonomous multi-agent pentester on the OpenAI Agents SDK. A root agent delegates to sub-agents (recon, injection, auth, and so on); every turn must end in a tool call, which keeps the reasoning honest. Findings are validated with working proof-of-concept before they reach the report, and everything runs in a sandbox.&lt;/p&gt;

&lt;p&gt;Why it stands out: it's the smallest distance from "nothing" to "a running autonomous agent": &lt;code&gt;pip&lt;/code&gt;, a sandbox, a model, go. Provider routing is through LiteLLM, so OpenAI, Anthropic, Google, Bedrock, or a local model all work. It has a CI mode (headless, non-zero exit on findings) and can itself act as an MCP server.&lt;/p&gt;

&lt;p&gt;The catch: the arsenal is smaller than a dedicated tool layer, and quality tracks the model hard. Weak local models fall apart on tool-calling discipline (more on that below).&lt;/p&gt;

&lt;h3&gt;
  
  
  HexStrike AI: the arsenal with no brain
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/0x4m4/hexstrike-ai" rel="noopener noreferrer"&gt;HexStrike AI&lt;/a&gt; is the opposite design: a server that wraps 150+ classic security tools as MCP functions, plus a REST API. It does &lt;strong&gt;not&lt;/strong&gt; think on its own. The reasoning comes from whatever MCP client you attach: Claude Code, Claude Desktop, Cursor, or your own loop.&lt;/p&gt;

&lt;p&gt;Why it stands out: it's the widest ready-made toolset I've seen, and the clean separation ("brain separate from hands") means you can swap models freely and even drive it from your own pipeline over REST.&lt;/p&gt;

&lt;p&gt;The catch: without a smart client it's just a tool wrapper, quality equals the external LLM, and there's no built-in finding validation or reporting. It's also dual-use with a reputation to match, so operational hygiene and isolation are on you.&lt;/p&gt;

&lt;h3&gt;
  
  
  PentAGI: the platform
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/vxcontrol/pentagi" rel="noopener noreferrer"&gt;PentAGI&lt;/a&gt; is the most product-like of the three: a web UI, Automation and Assistant (human-in-the-loop) modes, Postgres + pgvector memory, an optional Neo4j knowledge graph, per-agent model choice, and REST + GraphQL. A coordinator analyzes the target and spawns specialist agents.&lt;/p&gt;

&lt;p&gt;Why it stands out: long-running engagements with memory, observability, and human oversight; you can assign a cheap model to grunt roles and a strong one to hard roles.&lt;/p&gt;

&lt;p&gt;The catch: it's the heaviest to stand up (Docker Compose + Postgres, optionally Neo4j and monitoring), and it has fewer tools than HexStrike.&lt;/p&gt;

&lt;h2&gt;
  
  
  The comparison, at a glance
&lt;/h2&gt;

&lt;p&gt;Snapshot as of 2026-10 (stars and last-push dates move; treat as a moment in time).&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Project&lt;/th&gt;
&lt;th&gt;Type&lt;/th&gt;
&lt;th&gt;Brain lives…&lt;/th&gt;
&lt;th&gt;Notable&lt;/th&gt;
&lt;th&gt;Setup cost&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Strix&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;autonomous multi-agent&lt;/td&gt;
&lt;td&gt;inside&lt;/td&gt;
&lt;td&gt;PoC-validated findings, CI mode, LiteLLM routing&lt;/td&gt;
&lt;td&gt;low&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;HexStrike AI&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;MCP tool layer&lt;/td&gt;
&lt;td&gt;external client&lt;/td&gt;
&lt;td&gt;150+ tools, REST over MCP&lt;/td&gt;
&lt;td&gt;medium&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;PentAGI&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;platform + agents&lt;/td&gt;
&lt;td&gt;inside, per-role&lt;/td&gt;
&lt;td&gt;UI, memory, Neo4j, human-in-the-loop&lt;/td&gt;
&lt;td&gt;high&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  The rest of the field, briefly
&lt;/h2&gt;

&lt;p&gt;The long tail is worth knowing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Shannon&lt;/strong&gt; is white-box: it reads the target's &lt;em&gt;source&lt;/em&gt; to map attack vectors, then proves them with real exploits. It finds classes black-box testing misses. Note the AGPL-3.0 license if you're commercial.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;RedAmon&lt;/strong&gt; is a self-hosted pipeline that doesn't stop at finding: recon → exploit → triage → code-fix → pull request, with a Neo4j attack graph.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PentestGPT&lt;/strong&gt; is the academic reference assistant; its agentic mode drives Claude Code or Codex as the execution backend.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AI-OPS&lt;/strong&gt; and &lt;strong&gt;hackingBuddyGPT&lt;/strong&gt; are built for mid-size / local models and for prototyping your own agent ideas, respectively.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Avoid building on &lt;strong&gt;archived&lt;/strong&gt; offensive frameworks (e.g. CAI): unmaintained attack tooling rots as dependencies age. Reference the patterns, don't run the code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pick by what you actually need
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;If you need…&lt;/th&gt;
&lt;th&gt;Reach for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;An autonomous agent working in minutes&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Strix&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;The widest tool arsenal under your own model&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;HexStrike AI&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;A standing platform with UI, memory, human oversight&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;PentAGI&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;To find bugs from source code and prove them&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Shannon&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Offense → defense with an auto-fix PR&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;RedAmon&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;To run on local / mid-size open models&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;AI-OPS&lt;/strong&gt;, &lt;strong&gt;hackingBuddyGPT&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Where the LLM fits, and the wall nobody mentions
&lt;/h2&gt;

&lt;p&gt;Across all of these, the bottleneck isn't security knowledge. It's &lt;strong&gt;tool-calling discipline&lt;/strong&gt;: can the model reliably emit a valid tool call, read the result, and decide the next step, turn after turn, without drifting into prose?&lt;/p&gt;

&lt;p&gt;Strong models clear that wall easily, which is why every one of these tools feels dramatically more stable on a frontier model than on a small local one. But "small local model" isn't a dead end. The shape of the toolset matters as much as the model. That's its own article (coming next in this series), and the result surprised me.&lt;/p&gt;

&lt;h2&gt;
  
  
  Takeaway
&lt;/h2&gt;

&lt;p&gt;If you're starting today: &lt;strong&gt;Strix + a strong model&lt;/strong&gt; is the shortest path to a working autonomous agent. Keep &lt;strong&gt;HexStrike&lt;/strong&gt; in your back pocket as the arsenal to drive from your own client, and look at &lt;strong&gt;PentAGI&lt;/strong&gt; when you need a standing platform rather than a one-off run. Everything else on the list is a specialist: know it exists, reach for it when the job fits.&lt;/p&gt;

&lt;p&gt;This was the quick map. &lt;strong&gt;Tomorrow I'll publish the full field guide&lt;/strong&gt;: the complete comparison table, deep profiles of all twelve projects, quick-start commands for the top three, and the diagrams that make the taxonomy click. Follow if you want it in your feed. &lt;em&gt;(Link goes here once it's live.)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;And later in the series: what happened when I pitted a local "cyber" model against a frontier model as the brain for the same tool arsenal.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Only ever run these against systems you're authorized to test.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>ai</category>
      <category>pentesting</category>
      <category>llm</category>
    </item>
  </channel>
</rss>
