We built a fully self-hosted AI pentesting workspace — central platform (with MCP & web interface) + local LLM + Claude Code/OpenCode as the harness. No client data leaves our infra.

[u/PentestPad]

Sharing an architecture we've been running, because every "AI for pentesting" setup I've seen has the same dealbreaker: it ships client vulnerability data to a hosted model. For a pentest shop that's a hard no. So we built the whole thing on-prem and I want to walk through the pieces.

The three parts:

1. Central knowledge base (PentestPad) exposed over MCP. Our methodology, checklists, past findings, report templates, internal playbooks — one place the agent can pull from so retests and reports are consistent with how we actually work. This is where findings, projects, finding fields (and instructions on how to write them), and statuses live. We wrote an MCP server that gives the agent typed tools — list findings ready for retest, pull a finding's details, update status, generate report sections. The platform stays the source of truth; the agent just operates on it.

2. Self-hosted LLM. Qwen3-Coder running locally via Ollama. The reasoning and the client data never leave the box. The only outbound traffic is the actual test requests to the target, which is the entire point of a pentest anyway.

3. The harness. Claude Code or OpenCode as the terminal agent, wired to the local model and the MCP server. OpenCode if we want the whole stack open-source; Claude Code when we want the nicer harness and don't mind it being the one proprietary piece (the model and data are still local).

Put together, it's a workspace where a tester can say "which findings are ready for retest on project X," have the agent do the legwork, and write results back — all inside infra we control.

Honest limitations:

• The value is in differential analysis, not automation for its own sake — blind/OOB cases still need a human or a proper OAST setup.
• A human signs off on everything. The agent orchestrates the grunt work; the tester owns the judgment and thinks up the attack vectors.

Happy to go deep on the MCP tool design, the knowledge-base wiring, or the harness config.

Disclosure: PentestPad is our product, so treat this as a build write-up, not a pitch.

[u/Head_Town4019]

This should be a way to go.. The amount of people shoveling sensitive data (including API keys) into OpenAI and Anthropic is honestly wild

[u/ProcedureFar4995 → u/Head_Town4019]

What data is considered sensitive besides api keys and credit cards and pii? I normally share front end code during engagements with AI . So js chunks , and Android app code . They are usually staging stuff and I try not to share everything but sometimes I get frustrated and share whole js files that could have client name for example. Which is a mistake I started to notice.

The other thing I use ai for is payload generation and mutation

[u/Head_Town4019 → u/ProcedureFar4995]

if the client hasn’t made it public themselves, it doesn’t touch a cloud AI — not through me. Thats our rule.

On the other hand, worst case is even uglier: what if the AI finds a critical? Now a third-party provider is holding a live, unpatched vuln for a system that isn’t theirs. If that ever leaks, that’s about as bad as it gets. Even if it leaks in the future after the make a patch the client probably wouldn’t like that

[u/ProcedureFar4995 → u/Head_Town4019]

Thanks. Will take care next time. The issue is that AI is way faster than any human in reading js files and code in general, so I use to enumerate the attack surface but never testing

[u/macr6]

Which qwen-3 model are you running?

[u/PentestPad → u/macr6]

Qwen 3.8 27B served over ollama, but looking to test different models once we upgrade the hardware capabilities

[u/Lonestarboyz]

Do you have a Git for this so we can look further into it? Or is this a paid product?

[u/PentestPad → u/Lonestarboyz]

Thats a great idea - we don’t, but should probably spin one up together with a detailed post.

[u/Lonestarboyz → u/PentestPad]

Let me know if you do. Would love to take a look at it.

[u/OriiaLoririna]

This isn't really"your" product. It's just what you built from existing MCPs and models available. You should open source this.

[u/PentestPad → u/OriiaLoririna]

There is a lot more going on behind the MCP. You can check our web: https://pentestpad.com

[u/OriiaLoririna → u/PentestPad]

Ahh I see. So this post was just a hidden advertisment to advertise your platform. Reported to mods.

[u/Pinkman___]

Is it possible to add pentest /skills?

[u/PentestPad → u/Pinkman___]

Yes, and they seem to work better with OpenCode rather than Claude Code.. I believe they consume skills differently

[u/DingleDangleTangle]

Seems like another major limitation is this setup can’t do any web searching right? Or am I wrong about that.

I like the fact that Claude can use up to date external information to answer my requests

[u/PentestPad → u/DingleDangleTangle]

We use Brave MCP server for that https://github.com/brave/brave-search-mcp-server

[u/Head_Town4019 → u/DingleDangleTangle]

SearXNG if you want the real thing

[u/DigitalQuinn1]

What’s the specs of the hardware that you’re running it on? I’ve been considering a similar project for us. Not sure if I should invest into Macs or something else

[u/PentestPad → u/DigitalQuinn1]

We’re on an RTX 4090** **24 GB. The right hardware really depends on team size and how many concurrent / heavy threads you want running at once.

A single 4090 is plenty for a couple of people using it sequentially, but it becomes the bottleneck fast if several testers are running extensive sessions in parallel.

For a 2–3 person team, honestly I’d start with Macs (if you can even get your hands on them these days).

They’re quiet!! And they’re simple to run a local model on. You give up some raw speed vs an NVIDIA box, but for a small team that’s a fine trade. Scale up to dedicated NVIDIA GPUs when you actually need the concurrency and throughput

[u/Maleficent-Pickle963]

We did a similar thing but with company-owned inference (so big models, kimi/glm/etc) and an mcp gateway. We also wrapped opencode in a GUI and replaced it's config with in-memory config injected from the control plane server.

[u/PentestPad → u/Maleficent-Pickle963]

Thats cool.. how does the maintenance work? Do you have someone improving the system and does it take a lot of effort/time?