PentAGI: An AI-Driven Penetration Testing Platform

[Image: PentAGI Overview] Image: Discord badge Image: Telegram badge Image: Trendshift badge Image: PentAGI Overview Video

PentAGI, short for Penetration Testing Artificial General Intelligence, is an ambitious, autonomous security testing platform that blends cutting-edge AI with a robust ecosystem of tools and data. The goal is simple in description, powerful in practice: give security professionals, researchers, and enthusiasts a flexible, scalable system that can design, execute, and report penetration testing engagements with minimal manual intervention. The architecture is modular, sandboxed, and designed for production-grade deployments, including features such as a persistent memory system, a knowledge graph, multi-LLM support, and a comprehensive tooling suite.

This blog post walks you through what PentAGI is, how it works, and how you can get started. It’s written to give you a sense of the system’s capabilities, the components that power it, and the practical steps to deploy and operate it in real-world environments. Where helpful, we’ll point to the input material that informs the design, including the architecture diagrams, security considerations, and deployment guidance that underpin PentAGI’s capabilities.

Table of contents

• Overview
• Features that redefine automated pentesting
• Architecture and core components
• Advanced supervision and planning
• Quick start and system requirements
• Using PentAGI after login
• API access and provider configuration
• LLM providers and integration landscape
• Advanced setup: Langfuse, Graphiti, OAuth, and Docker
• Development, testing, and memory management
• Embeddings, testing utilities, and function testing
• Building, packaging, and deployment
• Credits and license

Overview: what PentAGI is and why it matters PentAGI positions itself as a secure, fully autonomous, AI-assisted penetration testing platform. It brings together a suite of professional tools (nmap, metasploit, sqlmap, and more), a memory system that stores research results for future use, and a knowledge graph to track relationships and outcomes. A built-in web intelligence layer allows the system to gather up-to-date information from the web, while external search integrations pull data from advanced search engines. The result is a programmable, intelligent assistant that can drive an engagement end-to-end, or act as a collaborative partner for a security team.

Key features at a glance

• Secure and isolated operations: All activities run inside sandboxed Docker containers, ensuring isolation and repeatable environments.
• Fully autonomous operation: An AI-driven agent orchestrates penetration testing steps with optional supervision and planning for reliability.
• Professional toolset: A built-in suite of more than 20 professional pentesting tools, ensuring real-world capability out of the box.
• Smart memory: Long-term storage of research results, patterns, and successful approaches to accelerate future engagements.
• Knowledge graph integration: Graphiti-powered semantics with Neo4j for contextual understanding and advanced querying.
• Web intelligence: A built-in browser/scraper to collect the latest information from the web.
• External search integration: Tavily, Traversaal, Perplexity, DuckDuckGo, Google Custom Search, Sploitus, and Searxng to enrich information gathering.
• Multi-agent specialization: A delegation system with specialized agents for research, development, and infrastructure tasks.
• Observability and reporting: Integration with Grafana/Prometheus for real-time monitoring and thorough vulnerability reporting.
• Flexible LLM provider configuration: Support for OpenAI, Anthropic, Google Gemini, AWS Bedrock, Ollama, DeepSeek, GLM, Kimi, Qwen, and more.
• Self-hosted and secure: Deploy on-premises with complete control over data and deployment boundaries.

Architecture at a high level: how the pieces fit together PentAGI is designed as a modular microservices ecosystem. Core services provide the UI, API gateway, and data orchestration, while specialized stacks handle knowledge, monitoring, analytics, and security tooling. The system relies on a persistent vector store (PostgreSQL with pgvector) for memory, a graph database (Neo4j) for the knowledge graph, and a set of dashboards for observability.

• Core Services

• Frontend UI: A modern, responsive interface built with React and TypeScript for system management and monitoring.

• Backend API: Go-based REST and GraphQL endpoints with Bearer token authentication for automation and integration.

• Vector store and memory: Long-term and working memory components backed by PostgreSQL + pgvector, enabling semantic search and memory recall.

• Task queue and agents: Async processing system with a multi-agent AI system that can assign and coordinate tasks across specialized roles.

• Knowledge Graph

• Graphiti: Knowledge graph API that unleashes semantic memory of tools, targets, vulnerabilities, and attack patterns.

• Neo4j: The graph database that stores relationships, with automatic capture of agent responses and tool executions to enrich the knowledge base.

• Monitoring and Analytics

• Grafana and VictoriaMetrics: Real-time dashboards and time-series storage for system health and performance metrics.

• Jaeger and Loki: Distributed tracing and log aggregation for debugging and incident response.

• OpenTelemetry (OTEL): Instrumentation and data collection to connect traces, metrics, and logs across the stack.

• Langfuse and ClickHouse: Advanced LLM observability and analytics for model performance and decision quality.

• Security Tools

• Web Scraper: Isolated browser for safe web interactions.

• PenTest tools: A comprehensive set of 20+ professional tools for offensive testing.

• Sandboxed Execution: All actions performed inside isolated containers to prevent cross-environment contamination.

• Memory and context management

• Long-term Memory: A persistent store of knowledge and experiences that can be indexed and retrieved later.

• Working Memory: The current context and task-state for ongoing engagements.

• Episodic Memory: Historical actions and outcomes that support pattern recognition and reuse.

• Memory management: Chain summarization to keep prompts within token limits while maintaining context.

• LLM and provider abstraction

• A variety of providers and aggregators enable flexible routing to the underlying models (OpenAI, Anthropic, Gemini, Bedrock, Ollama, DeepSeek, GLM, Kimi, Qwen, and more).

Advanced agent supervision: making autonomous testing safer and more effective PentAGI introduces sophisticated supervisory mechanisms to guide agents, prevent loops, and recover from stuck states. The system emphasizes a combination of execution monitoring, intelligent task planning, and robust tool usage governance.

• Execution Monitoring (Beta)

• Automatic mentor intervention when patterns suggest trouble

• Pattern detection for frequent identical tool calls or excessive tool usage

• Progress analysis to determine if the agent is advancing toward subtask objectives

• Alternatives and strategy shifts when the current approach stalls

• Guidance on information retrieval rather than reinventing the wheel

• Enhanced response formats that provide both structured and narrative sections

• Configurable thresholds and enabling flags for different model classes

• Intelligent Task Planning (Beta)

• Automated decomposition into 3–7 actionable steps before execution

• Context-aware planning via an enricher that analyzes the full context

• Structured task plans that include critical actions, pitfalls, and verification

• Scope management to prevent creep

• Use of enhanced adviser configurations for stronger reasoning on smaller models

• Tool Call Limits and Reflector Integration

• Hard limits to prevent runaway executions, with agent-type-specific thresholds

• Reflector: automatic correction and recovery guidance when tool calls fail or hit limits

• Recommendations and safe defaults to ensure graceful termination when needed

• Global and assistant-level summarization

• Chain summarization to manage growing context without losing essential information

• Configurable thresholds for preserving recent QA sections and per-conversation history

A practical note: for smaller open-source models, enabling both execution monitoring and task planning yields substantial improvements in quality and reliability, albeit with higher token usage and longer runtime. The guidance includes practical example configurations and recommended model pairings to maximize performance within resource constraints.

Quick start: what you need to begin System readiness

• Docker and Docker Compose (or Podman)
• At least 2 vCPU and 4 GB RAM
• 20 GB free disk space
• Internet access for image pulls

Installer route (recommended)

• An interactive terminal installer guides you through system checks, provider configuration, search engines, and hardening steps.
• Supported platforms include Linux, Windows, and macOS.
• The installer creates a secure environment and configures providers (OpenAI, Anthropic, Gemini, Bedrock, Ollama, Custom) and search engines (DuckDuckGo, Google, Tavily, Traversal, Perplexity, Sploitus, Searxng).

Manual installation path

• Clone or download the repo, copy environment templates, and fill in credentials for LLMs and search providers.
• Start the stack with docker-compose and access the web UI at a secure URL (default port 8443).

External access and security

• PentAGI binds to localhost by default for security, with instructions for enabling external access via careful network binding and CORS configuration.
• For production deployments, a two-node architecture is strongly recommended to isolate worker execution from the main system, providing robust security boundaries.

OAuth and authentication

• GitHub and Google OAuth options enable convenient, secure sign-in with familiar credentials.
• Public URL must be configured accurately to ensure successful redirects.

Docker image configuration and customization

• PentAGI auto-selects images for most tasks, but you can constrain image choices for security and consistency.
• You can route container pulls through proxies if needed and configure image mirrors in your Docker daemon.

Deployment and orchestration tips

• Langfuse for LLM observability and performance metrics
• Graphiti for knowledge graph and semantic querying (beta; with caveats)
• Observability stacks (Grafana, Prometheus) for monitoring
• Two-node production guidance includes isolated worker nodes, TLS-protected containers, and safe port management

How to use PentAGI after login: starting a flow

• Flows are the primary workflow unit. Create a new flow and choose between Automation (fully autonomous) or Assistant (human-guided).
• Pick an LLM provider, define the target, and describe the engagement constraints. A good prompt usually includes the target URL, the testing scope, and the expected deliverable (for example, a vulnerability report with reproduction steps).
• Templates help with repeatable workflows; you can start from a baseline prompt or a saved template.
• After submission, monitor the flow through the Flow view. You’ll see agent activity, task progress, tool usage, and outputs.
• The Report menu enables web-view reports, copy-to-clipboard, Markdown, and PDF exports.
• The Assistant view provides a steerable control path to intervene or re-prioritize pending subtasks.

API access: token-based automation and client libraries PentAGI exposes REST and GraphQL APIs to integrate pentesting workflows into CI/CD pipelines and custom apps.

• Generate and manage API tokens via the web UI (Settings -> API Tokens).
• Use Bearer tokens in Authorization headers for REST and GraphQL calls.
• GraphQL Playground and Swagger UI provide interactive API exploration and testing.

A few practical provider configurations (high level)

• Ollama: Local and cloud options, with a cloud API key for Ollama Cloud and flexible server URLs.
• OpenAI: OpenAI API key, server URL, and the option to proxy through a gateway if needed.
• Anthropic: Claude-based configurations with Claude models and optional proxy routing.
• Gemini (Google AI): Gemini API key and server URL for advanced multimodal thinking.
• AWS Bedrock: Region-aware setup with a choice of authentication methods, including default AWS credentials or bearer tokens.
• DeepSeek: Deep reasoning models with a compact price/performance mix and lite-LLM proxy options.
• GLM (Zhipu AI): Multimodal and agentic capabilities with MoE architectures and a range of models suited for agentic workflows.
• Kimi (Moonshot AI): Ultra-long context, multimodal support, and a family of models that balance cost and capability.
• Qwen (Alibaba Cloud): A wide family of models including flagship and fast-flash variants, with 1M+ token contexts and multilingual capabilities.

Advanced setup: Langfuse, Graphiti, OAuth, and Docker Langfuse

• Integrates with Langfuse for advanced LLM analytics, tracing, and performance dashboards.
• Requires dedicated environment variables for database, encryption, and admin credentials. Graphiti
• A beta knowledge graph integration leveraging Neo4j for semantic memory and relationships across tools, targets, and findings.
• Requires an OpenAI-compatible endpoint for extraction and a single fixed model per deployment.

OAuth

• GitHub and Google OAuth simplify authentication against public or enterprise accounts.
• Ensure the PUBLIC_URL in your environment matches the external address used for redirects.

Docker image configuration

• You can constrain the main PentAGI image or default to a standard image for general tasks and a separate one for pentest tasks.
• If you operate in restricted networks, consider image mirrors and proxies to maintain reliable pulls.

Embedding configuration and testing

• PentAGI supports multiple embedding providers (OpenAI, Ollama, Mistral, Jina, HuggingFace, GoogleAI, VoyageAI).
• Embedding management and testing are supported via a dedicated etester utility to verify provider compatibility, indexing, and search accuracy.
• Consistent embedding providers matter for semantic search and memory integrity; if you switch providers, reindexing the knowledge base is recommended.

Function testing and agent validation (ftester and cteter)

• cteter tests LLM agent capabilities across provider configurations and agent types, with parallel testing and detailed reporting.
• ftester enables direct function calls and context-aware testing of individual system components, useful for debugging and development.

Building and developing PentAGI

• The project emphasizes a robust development workflow with Go for the backend, frontend tooling, and Docker for containerized deployments.
• Build scripts provide versioning information and multi-arch image creation to support diverse ecosystems.

Security and best practices

• Token hygiene: keep API keys and tokens out of version control; rotate tokens regularly.
• Use HTTPS; avoid exposing tokens in plaintext channels.
• In production, adopt a two-node architecture with hardened security boundaries to prevent cross-host contamination and to isolate execution from main control planes.

What you can expect in practice

• PentAGI provides a powerful framework to automate, supervise, and document penetration testing engagements.
• Expect a balance between autonomous operation and configurable human-in-the-loop control to handle escalation and scope changes.
• The architecture is designed to scale horizontally, tolerate failures, and provide rich observability data to operators.

Credits, license, and further reading

• PentAGI is built with a foundation of open research and community-driven innovation in autonomous LLM agents and security tooling.
• The project is MIT-licensed, with third-party dependencies aligned to MIT-compatible licenses.
• For extended context, refer to the input documents that inspired design choices around architecture, memory systems, and agent supervision.

Closing thoughts PentAGI represents a compelling synthesis of AI-driven autonomy and professional security tooling. By combining sandboxed execution, a persistent memory system, a semantic knowledge graph, and a diverse provider ecosystem, PentAGI aims to accelerate and improve the depth of penetration testing engagements. Whether you are a security researcher seeking a powerful autonomous workflow, a developer exploring large-scale agent orchestration, or a security operations professional looking to scale testing across environments, PentAGI offers a flexible platform to orchestrate, observe, and learn from security engagements in a principled, auditable way.

If you’re curious to explore further, watch the PentAGI overview video to see the system in action, and consider joining the community for updates, support, and shared insights. The community channels and the trend-tracking badge included at the top of this post are a small doorway into a broader ecosystem of researchers and practitioners who are shaping the future of safe, autonomous security testing.