Strix is an open-source, AI-powered penetration testing tool that orchestrates multiple LLM-driven agents to autonomously discover and validate security vulnerabilities in web applications, APIs, source code, and infrastructure. The system operates as a CLI application with three interface surfaces: a headless/non-interactive mode for CI/CD pipelines, a feature-rich Go Bubble Tea TUI for interactive scanning, and a local React web viewer for reviewing results. Scans run inside Docker sandboxes with a Caido interception proxy sidecar, allowing agents to execute shell commands, browse applications, modify requests, and apply patches. The architecture follows a multi-agent coordination pattern where a root agent delegates tasks to child agents, tracks coverage, manages budgets, and produces comprehensive reports including CVSS-scored vulnerabilities, proof-of-concept exploits, and fix recommendations. The codebase demonstrates strong engineering practices with extensive test coverage, atomic file operations, output bounding, MCP tool integration, and a sophisticated IPC protocol between the Python backend and Go TUI. Key features include: multi-agent orchestration with parent/child messaging and budget enforcement; Docker sandboxed execution with Caido proxy integration; support for multiple LLM providers (OpenAI, Anthropic, LiteLLM, Bedrock, etc.); MCP (Model Context Protocol) tool integration; SARIF and PDF report generation; cloud platform integration for managed scans; and a local web viewer with live transcript and vulnerability triage. The repository is primarily an application but includes data-oriented components like LLM cost tracking, coverage ledgers, and vulnerability deduplication using LLM-based comparison.
The OWASP AI Security Verification Standard (AISVS) is a community-driven, open-source framework providing a comprehensive set of verifiable security requirements for AI-enabled systems. Modeled after the OWASP Application Security Verification Standard (ASVS), it defines 12 control families (C01-C12) covering the entire AI lifecycle, from training data integrity and model lifecycle management to adversarial robustness and monitoring/logging. The repository is structured as a living standard with two parallel tracks: a locked, stable release (1.0/) and an active development version (1.01-dev/). Each requirement is backed by an extensive research wiki that details the threat landscape, notable incidents, tooling maturity, verification approaches, and open research questions. This makes the AISVS not just a checklist, but a deeply researched knowledge base for engineers, auditors, and security architects building and evaluating AI systems. It also includes appendices for a glossary, a controls inventory, and AI-assisted secure coding practices. Note: This is a documentation/specification repository, not a software application or data science project. Its quality is measured by the rigor of its research, the clarity of its requirements, and the maintainability of its structure.
garak is a CLI tool and Python library for automated red-teaming and vulnerability scanning of large language models (LLMs). It systematically probes models with adversarial inputs (jailbreaks, prompt injections, encoding attacks, etc.) and uses detectors to classify model responses for safety failures. It supports multiple model backends (OpenAI, Anthropic, HuggingFace, etc.) and generates structured reports with severity scoring. The system follows a modular plugin architecture with base classes for probes, detectors, generators, harnesses, evaluators, and buffs. Plugins are dynamically loaded and configured via a hierarchical config system. The default harness runs probes with their associated detectors, while a cross-product harness allows all probes against all detectors. Results are logged as JSONL and can be visualized via a React-based web UI (garak-report) that displays DEFCON-level severity, calibration Z-scores, and technique-intent matrices. While primarily an application, garak incorporates significant research elements: it implements state-of-the-art attack techniques (GCG, AutoDAN, BEAST, TAP) and includes curated datasets of adversarial prompts and calibration data. The codebase serves both as a practical security tool and as a research platform for LLM vulnerability assessment.
This repository is a collection of deployable templates and educational cookbooks for building real-time LLM applications using the Pathway framework. It provides ready-to-deploy RAG (Retrieval-Augmented Generation) solutions with live data synchronization from various sources (files, Google Drive, SharePoint, etc.), built-in vector and hybrid search, and integration with LangGraph for agentic workflows. The templates are production-oriented with Docker support, while the cookbooks demonstrate advanced patterns like Self-RAG with self-reflection and query rewriting. The codebase is well-structured but exhibits some duplication across templates, and the core logic relies heavily on the external Pathway library.
ClawScan is a Go-based CLI tool for composable security scanning of AI agent skills and plugins. It orchestrates multiple external scanners (e.g., Snyk, VirusTotal, Socket, AIG, Cisco, SkillSpector) against skill directories, collects raw evidence, and optionally feeds results to an LLM judge for evaluation. The tool supports profile-based configuration (built-in profiles like `clawhub` and `openclaw-install-policy`), Docker sandboxing, declarative gate rules for automated policy enforcement, and benchmark execution against datasets like SkillTrustBench and clawhub-security-signals. It is distributed via npm (`@openclaw/clawscan`) and GitHub Releases, with a rich CI/CD pipeline including automated runtime image builds, dependency updates, and a Hugging Face leaderboard for security signals research. While primarily an application, it has strong data/research elements through its benchmark infrastructure and leaderboard submission validation.
ThinkWatch is a Rust workspace implementing an AI gateway platform that fronts multiple model providers and MCP (Model Context Protocol) servers. It exposes OpenAI-compatible chat/completion endpoints, streaming, MCP tool-call routing, content filtering, and provider failover. The backend is split into crates: `common` (shared lifecycle/limits/access), `auth` (PoW login, API keys), `gateway` (model routing), `mcp-gateway` (MCP server proxying), `server` (REST admin/audit/trace endpoints), and `test-support` (integration test client). A React/TypeScript frontend in `web/` provides an admin console, setup wizard, limits panels, and MCP server management. Data flows: requests enter the gateway, pass through `check_limits`, `check_budget`, `check_access`, then `run_post_invoke`; `trace_id` is propagated across gateway, MCP, audit, and app logs stored in ClickHouse; Postgres holds users, API keys, budgets, and MCP server configs; Redis/Lua scripts enforce rate limits.
OASIS is a CLI-first security analysis tool written in Python. It orchestrates a multi-phase LangGraph pipeline (Discover → Scan → Expand → Deep → Verify → Report) to detect vulnerabilities in source code using local LLMs via Ollama or OpenAI-compatible servers. The tool supports 25+ vulnerability types across multiple languages, produces deterministic verdicts without LLM reliance, and integrates with CI via severity-gated exit codes, suppression registries, and report diffing. It is installed via pipx or Docker and run as `oasis -i /path --models ...`.
Agentic Security is an open-source LLM vulnerability scanner that probes AI endpoints for security weaknesses such as jailbreaks, prompt injection, data leakage, and sandbox escapes. It provides both a FastAPI web server (port 8718) with a Vue.js frontend and a Fire-based CLI (server, ci, init, ls, scan). The core scan engine sends adversarial prompts (text, image, audio) to target LLMs via configurable HTTP specs, classifies responses using a multi-layered refusal detection system (phrase-based, OneClassSVM, PII detector, LLM-as-judge, hybrid voting), and generates detailed reports with failure rates and cost metrics. The architecture is modular: LLM provider abstraction (OpenAI, Anthropic, LiteLLM), resilience primitives (rate limiter, circuit breaker, concurrent executor), plugin-based refusal classifiers, and a dataset registry supporting HuggingFace, CSV, Google Sheets, and dynamic transformations (stenography, encoding). It also integrates external red-teaming tools (Garak, Inspect AI) and includes reinforcement learning and Bayesian optimization for adaptive prompt selection. While primarily an application, it contains significant data/research components (ML models, datasets, refusal classification research) that support its scanning mission.
DeepTeam is a production-oriented Python library and CLI for red-teaming LLM applications. It does not merely document vulnerabilities; it executes automated adversarial campaigns against a user-supplied model callback, generating attack prompts through LLM-driven templates (single-turn, multi-turn, tree/crescendo jailbreaks), scoring target responses with LLM-as-judge metrics, and aggregating outcomes into risk assessments with CVSS scoring. It also ships a code scanner for static AI-security review, a trace scanner for agent executions, and deployable input/output guardrails. Main entry points are the red_team() Python API and the deepteam CLI (login, run, scan), with YAML configuration driving model selection, vulnerability types, and attack budgets. Architecturally, the repo is a modular Python package built on deepeval: vulnerabilities inherit from BaseVulnerability, all metrics inherit from BaseRedTeamingMetric, attacks implement configurable templates and schemas, and frameworks (OWASP, MITRE ATLAS, NIST, EU AI Act, BeaverTails, Aegis) map risks to pre-built categories. Results flow through RTTestCase objects and can be saved locally as JSON or pushed to the Confident AI platform. The library is dual sync/async and includes progress reporting, cost accumulation, and retry logic. Although it embeds research-style synthetic data generation and dataset-driven framework integrations, the dominant character is an application library/CLI rather than a data research project. Strengths include broad vulnerability and attack coverage, clear base-class contracts, a substantial test suite, and active CI. Weaknesses include heavy copy-paste duplication across 30+ vulnerability, metric, and template modules, tight coupling to deepeval internals, reliance on hardcoded model defaults such as gpt-3.5-turbo-0125, and a known logic bug where is_successful in the metric base class compares instead of assigns, always returning False unless an error is set. Telemetry code also contains hardcoded service keys. Overall, it is a functional, well-documented framework with real reuse value, but it would benefit from deduplication and dependency hardening.
The repository is a comprehensive platform for AI red teaming education, hosting a series of Capture the Flag (CTF) challenges that target LLM vulnerabilities such as prompt injection, metaprompt extraction, and safety filter bypass. It is built as a modified version of Microsoft's Chat Copilot, integrating a multi-service architecture: a .NET Core chat backend with Semantic Kernel, a React frontend, a load balancer (Go), a scoring service (Flask/Celery), a picture submission service, and a challenge home page. The system is designed to be deployed via Docker Compose or Kubernetes, with each challenge running its own configured chat instance. While primarily an application, the repository also includes Jupyter notebooks using PyRIT for automated red teaming, blending application and research elements. The architecture is modular, with clear separation between services. The chat copilot backend provides real-time chat via SignalR, supports OpenAPI plugins, and integrates with Azure services (CosmosDB, Redis, Blob Storage, Content Safety). The scoring system supports both automatic (regex/LLM) and manual review, with CTFd flag submission. The platform is highly configurable through challenge JSON files, allowing different metaprompts, scorers, RAG inputs, and security settings. This makes it a flexible testbed for red teaming exercises. The repository demonstrates strong engineering practices with reusable components such as a generic repository pattern, authentication handlers, telemetry services, and a load balancer. However, it is tightly coupled to Azure and Semantic Kernel, and some features are intentionally insecure for educational purposes. The codebase is actively maintained and well-documented, making it suitable for both learning and running red teaming events.
LLMMap is a CLI-based automated prompt injection testing framework for LLM-integrated applications, modeled after sqlmap. It systematically discovers injection points (query parameters, headers, body, cookies, path), generates goal-aware adversarial prompts using a dual-LLM architecture (Generator + Judge), and evaluates responses through pattern matching, semantic similarity, and out-of-band callbacks. The tool supports 227 injection techniques across 18 attack families, multiple LLM providers (Ollama, OpenAI, Anthropic, Google), and provides reliability confirmation via Wilson confidence intervals. It includes comprehensive reporting, data-flow tracing, and Burp Suite integration. The codebase is well-structured with clean abstractions, extensive tests, and reusable components, though some modules are reserved for future development and external dependencies like interactsh-client introduce fragility.