Which open-source LLM red teaming tool fits your team
Before release, a team testing an LLM application needs a shortlist that matches who will run the tests. Choose garak if a security team wants broad probe scans across hallucination, data leakage, prompt injection, misinformation, toxicity and jailbreaks. Choose PyRIT if the team wants to script multi-turn attacks in Python and keep conversation memory for analysis. Choose promptfoo if a product team wants evaluation and red team checks that run in CI/CD alongside its regular test suite. The three are not mutually exclusive, and the practical question is which one owns the release gate and which one supports deeper investigation.
The licenses do not separate these tools. garak is Apache-2.0, PyRIT is MIT and promptfoo is MIT, so each can be run inside your own infrastructure without a license fee for the open-source tier. Promptfoo is now part of OpenAI, and its README states that it remains open source and MIT licensed. Ask whether that ownership change affects your roadmap, provider coverage or data handling expectations, and confirm the current terms in the repository rather than relying on the acquisition announcement alone.
A common split is a security team running garak or PyRIT for deep, adversarial coverage, while a product team runs promptfoo checks on every pull request to catch regressions early. Before committing, confirm which team owns the findings, where reports are stored and who triages failures. The security team will need reports it can audit, and the product team will need pass or fail results that fit its pipeline. Those requirements, more than attack counts, should decide the combination.
Which tool fits which scenario
This table maps common red teaming situations to the tool most likely to fit, with the condition that makes each choice hold. Read it against your team's skills, your release process and whether you need a shared review interface. Most teams end up combining two tools rather than choosing only one.
| Scenario | Best fit | Why |
|---|---|---|
| Security team running a broad vulnerability sweep on a model endpoint | garak | Ships a large set of probes for hallucination, data leakage, prompt injection, toxicity and jailbreaks, and writes JSONL and hit logs. Fits when breadth of coverage matters more than custom multi-turn logic. |
| Security team doing scripted multi-turn attacks (Crescendo, TAP, Skeleton Key) | PyRIT | Provides named multi-turn strategies, converters and scorers in Python. Fits when your testers can write code and need attack chains tailored to a specific application. |
| Product team gating releases in CI/CD | promptfoo | Runs from declarative configs on your machine and can run checks in pipelines. Fits when developers own the test suite and failures must block a merge or deploy. |
| Team testing a web app through its UI with Playwright-driven targets | PyRIT | Documents web app targets driven through Playwright, which the other two tools do not present as a core target type. Confirm the setup against your own application before committing. |
| Team wanting a shared self-hosted review UI | promptfoo (Enterprise or On-Premise) | The free self-hosted app uses local SQLite, has no RBAC or SSO and is not recommended for production. Shared review with access control needs the paid Enterprise or On-Premise editions, so confirm terms and cost in writing. |
| Team with mixed needs | garak for sweeps plus promptfoo for CI gates | Splits the work: garak finds broad weaknesses during security review, while promptfoo keeps regressions out of releases. Works when security and product teams agree who owns triage of findings. |
How garak, PyRIT and promptfoo differ in architecture
garak is a command-line scanner assembled from five kinds of plugin. Probes generate attacks, detectors judge whether the model produced undesirable output, generators connect to the target (Hugging Face Hub models, OpenAI, AWS Bedrock, llama.cpp models, or any REST endpoint described in a short YAML file), evaluators and harnesses run the combination. The default probewise harness runs each probe with its recommended detectors, and garak makes 5 generations per prompt by default, so a probe is marked FAIL with a failure rate when any attempt produces undesirable output. Each run writes a JSONL report of every attempt and its evaluation, plus a garak.log file that continues across runs. Your team should check which probes and detectors apply to your target before trusting a clean run, and confirm the generation count you want in the configuration.
PyRIT is a Python framework rather than a finished scanner. Its building blocks are targets, converters, scorers, attacks, memory and datasets. Targets include OpenAI, Azure, Anthropic, Google and Hugging Face models, custom HTTP or WebSocket endpoints, and web applications driven through Playwright. Scorers can use an LLM, Azure AI Content Safety or custom logic, and memory stores conversations and results in SQLite or Azure SQL. You can run it through the pyrit_scan command, through CoPyRIT for human-led testing, or by writing custom attacks in Python. That flexibility suits a security engineering team that wants to script multi-turn attacks, but it also means someone must own the code, the scoring logic and the storage decisions. Confirm which Python version your environment uses, since the documentation recommends Python 3.13.
promptfoo takes a configuration-first approach. You describe the application, providers, test cases and red team settings in declarative config files and run them locally as a CLI, from a Node.js library, or as a step in a CI/CD pipeline. The documentation states that evals run on your machine and talk directly with the model. The self-hosted web app is an Express server with a database, but its own documentation says the bundled SQLite store cannot be shared across replicas and lacks RBAC and SSO, so it is not recommended for production use. If you plan to share results across a team, plan for the Enterprise or On-Premise tier or a different storage design, and confirm those terms with the vendor.
Capability comparison across garak, PyRIT and promptfoo
This table sets garak, PyRIT and promptfoo side by side on licensing, runtime requirements, attack coverage, multi-turn support, scoring, CI fit, reporting and storage. Cells marked as items to confirm are not settled by published facts, so check them in each project's documentation before you commit. LLM Guard is archived and not compared here.
| Capability | garak | PyRIT | promptfoo |
|---|---|---|---|
| License and maintainer | Apache-2.0, maintained in NVIDIA's GitHub organization | MIT, developed by Microsoft at microsoft/PyRIT after the Azure/PyRIT archive | MIT, part of OpenAI, remains open source per its README |
| Latest version and date | v0.17.1, 16 October 2026 | v1.1.0, 4 September 2026 | 0.124.1, 8 October 2026 |
| Python or Node.js requirement | Python 3.11 or newer | Python 3.10 up to but not including 3.15; 3.13 recommended | Node.js 22.22.0 or newer |
| Attack and probe coverage | Hallucination, data leakage, prompt injection, misinformation, toxicity and jailbreaks | Datasets for content harms, psychosocial risks and data leakage | Red team plugins and strategies aligned with the OWASP LLM Top 10 and NIST AI RMF |
| Multi-turn attacks | Item to confirm: whether probes cover multi-turn attacks in the user guide | Crescendo, TAP and Skeleton Key strategies | Item to confirm: which multi-turn strategies the red teaming docs list for your version |
| Scoring method | Detectors judge each attempt; a probe fails when any default generation is undesirable | Scorers use LLMs, Azure AI Content Safety or custom logic | Item to confirm: grader types used for red team results in the docs |
| CI/CD fit | Command-line scanner; item to confirm a documented CI pattern | Run through the pyrit_scan command or as a Python framework; item to confirm CI setup | Runs from declarative configs in CI/CD pipelines |
| Reporting | JSONL report of every attempt plus a hit log of failed attempts | Memory records conversations, scores and results; item to confirm export formats | Item to confirm report formats and dashboards for your version |
| Self-hosted UI and storage | Command-line only; item to confirm any web interface. Writes JSONL and garak.log files | CoPyRIT web GUI for team-led testing; memory in SQLite or Azure SQL | Self-hosted web UI; default SQLite storage is not recommended for production |
Security team versus product team: which tool to start with
Security teams usually start with garak or PyRIT because they want broad probing, custom attack logic and room for human judgment. garak fits a scanner-style sweep: you pick probes for hallucination, data leakage, prompt injection, misinformation, toxicity and jailbreaks, run them against a target, and read the JSONL report and hit log. PyRIT fits work that needs scripting, since its targets, converters, scorers and multi-turn strategies such as Crescendo, TAP and Skeleton Key can be composed in Python. This tab is the right choice when a named security or research function owns the test plan and the findings.
- Scanner-style coverage: garak runs a default probewise harness that applies each probe's recommended detectors, which suits a first broad pass against a new model or endpoint.
- Scripted multi-turn attacks: PyRIT's memory layer records conversations, scores and results in SQLite or Azure SQL, which helps analysts reconstruct how an attack progressed.
- Human-led testing: CoPyRIT, the web GUI for human-led red teaming and team collaboration, lets testers work interactively alongside the framework.
- Licensing and maintenance: garak is Apache-2.0 and PyRIT is MIT. Confirm the current repository location before you pin a version, since the original Azure/PyRIT repository is archived.
The team still owns the threat model, the attack taxonomy, detector tuning, triage of false positives, and the decision on which findings block a release. Confirm with your own security function which of these two tools fits the skills already on the team.
Product and platform teams usually start with promptfoo because it is driven by declarative configuration files and runs from the command line or inside a CI/CD pipeline. Developers can keep test cases, providers and red team settings in the same repository as the application, review changes in pull requests, and fail a build when a check does not pass. Promptfoo runs locally and talks directly to the model, so evaluations stay on the machine that runs them. This tab is the right choice when developers own the release gate and need security checks to run on every change.
- Declarative configs: Test suites and red team settings live in version-controlled files, so changes to prompts or model providers are reviewed like other code.
- CI gating: Promptfoo can run checks in CI/CD pipelines, which makes it a practical way to block a release on a regression in a known attack category.
- Framework alignment: Red team plugins and strategies are aligned with the OWASP LLM Top 10 and the NIST AI Risk Management Framework, which gives product owners a shared vocabulary.
- Ownership and licensing: Promptfoo is MIT licensed and is part of OpenAI, with the founders stating it will remain open source. Ask whether your roadmap depends on any feature that sits in a paid edition.
- Self-hosting limits: The self-hosted app stores data in a local SQLite database that cannot be shared across replicas, has no RBAC, horizontal scaling, built-in authentication or SSO, and is not recommended for production. Teams needing shared, governed use should check the Enterprise and On-Premise editions.
The product team still owns the choice of test cases, the policy for which failures block a merge, the handling of model updates, and the evidence kept for reviewers. Confirm with your security function which findings must reach them before a release is approved.
Each tool in brief, with license and maintainer
garak, PyRIT and promptfoo cover most open-source LLM red teaming shortlists, but they differ in license, ownership and how much code you write. The license named on each card is the only licensing claim made here, and no tool carries an additional OSI or other certification label beyond it. Check the maintainer and release history before you standardize on one.
garak, the NVIDIA scanner
garak is a command-line scanner licensed under Apache-2.0 and developed in the NVIDIA GitHub organization. It runs probes for hallucination, data leakage, prompt injection, misinformation, toxicity and jailbreaks, then writes a JSONL report of every attempt and a hit log of failures. Its strength is broad probe coverage that starts from a single command. Its limitation is that it is a scanner first, so custom multi-turn logic takes extra work. Check each detector against your own definition of a failure before you trust a FAIL result.
PyRIT, the Microsoft framework
PyRIT is a Python framework licensed under MIT and developed at microsoft/PyRIT. It provides targets, converters, scorers and multi-turn attacks such as Crescendo, TAP and Skeleton Key, with a memory layer that stores results in SQLite or Azure SQL. Its strength is scripted multi-turn attack logic that your team can version and extend. Its limitation is that the original Azure/PyRIT repository was archived on 27 March 2026 and is read-only, so older links and references need checking. Confirm that your pinned version comes from the maintained repository.
promptfoo, now part of OpenAI
promptfoo is an eval and red teaming CLI and library licensed under MIT, and its README states that it remains open source after OpenAI agreed to acquire it, announced 9 March 2026. Its strength is declarative configs that run locally and fit CI/CD pipelines. Its limitation is the self-hosted app: it stores data in a local SQLite database that cannot be shared across replicas, has no RBAC, horizontal scaling, built-in authentication or SSO, and is not recommended for production. Enterprise and On-Premise are commercial editions with custom pricing, so ask for written terms.
What the licenses and paid editions change for your team
All three core tools carry permissive open-source licenses. garak is Apache-2.0, PyRIT is MIT and promptfoo is MIT, so none of them requires a commercial agreement to run probes against your own applications. The license question that matters more here is who maintains the project. PyRIT development moved from the archived Azure/PyRIT repository to microsoft/PyRIT, and promptfoo is now part of OpenAI, although its README states it remains open source and MIT licensed. Ask your security team to confirm that the version you pin is the one the maintainers still ship, and to record the release you tested against in your change log.
promptfoo is the only one of the three with a paid tier on the same product. Its Community edition is free, includes all evaluation features and all model providers, and allows red teaming at 10k probes per month with community support. Enterprise adds team sharing, access control through teams and SSO, custom roles and permissions, continuous monitoring, a centralized guardrail dashboard, remediation recommendations and priority support with SLAs, priced on request. On-Premise runs that Enterprise functionality on your own infrastructure, with complete data isolation and a dedicated deployment engineer. Pricing for both is custom, so the quote should state the seat model, probe volume, support tier and whether On-Premise installation and upgrades are included.
Be careful with a shared self-hosted deployment on the free path. The self-hosting documentation says the promptfoo app stores data in a local SQLite database that cannot be shared across replicas, and that it has no RBAC, no horizontal scaling and no built-in authentication or SSO, and is not recommended for production. If several red teamers or a product team will share results, treat that setup as a review item: either accept single-user operation, put access control in front of it under your own controls, or confirm with promptfoo whether the Enterprise or On-Premise tier covers your requirement. Check the current details on the promptfoo pricing page before you decide.
How to choose and pilot one or more tools
This sequence moves a team from an undefined goal to a tested, CI-gated red teaming setup, and it shows which tool covers which gap before anyone commits to a license, an edition or a runbook. Each step ends with a check you can record, so the pilot produces evidence a security lead and a product lead can both review.
Define the target and endpoint type
Name the application under test and how it is reached: a hosted model API, a self-hosted model, a REST or WebSocket endpoint, or a web app that only a browser can drive. Match that to the tool's connectors. Check the garak generators list, the PyRIT target types and the promptfoo provider list in each vendor's documentation, and confirm your endpoint is supported or can be reached through a custom REST configuration. Done when you have a one-page target note that names the endpoint, the authentication method and the data classes the model can see.
Decide who owns the results
Assign one owner for findings from the security team and one for fixes from the product team, and agree who can accept a residual risk. Decide where raw attempt data is stored, since each tool writes its own record: a JSONL report and hit log for garak, a memory database for PyRIT, and local output or the self-hosted app for promptfoo. Confirm retention and access rules with your data protection owner before the first run. Done when both owners have signed the target note and the storage location is written down.
Run one tool against a staging endpoint
Start with a single tool on a non-production endpoint that uses test credentials and no real customer data. Use the tool's default probes or scan configuration first, and record the exact version you ran, such as the garak release or the promptfoo npm version, so results can be reproduced. Read the tool's install requirements, including the Python or Node.js version in its documentation, before you install it on the runner. Done when the run completes and you can name the probes or plugins that were executed.
Review the report and its evidence
Open the output that the tool produced and check what it records for each attempt. In garak, review the JSONL report and the hit log; in PyRIT, query the conversation and score records in memory; in promptfoo, review the eval output or the self-hosted results view. Confirm that a failed attempt can be traced back to the prompt, the response and the detector or scorer that judged it. Done when one finding can be reproduced by hand from the saved record.
Wire the chosen tool into CI
Add the scan to your pipeline as a job that runs against the staging endpoint on each change to prompts, models or retrieval settings. Check your CI platform's secrets handling and the vendor's documented CI/CD usage before you store model credentials. Set a fail threshold that your owners agreed in step two, and confirm the job exits with a non-zero status when it is breached. Done when a deliberately weakened test configuration fails the pipeline and the normal configuration passes.
Decide whether a second tool closes a gap
Compare the pilot results with the coverage you need: attack families such as prompt injection, multi-turn strategies, data leakage or custom business rules. If one tool does not reach a required area, check the documented probes, plugins or attack strategies of the other candidates, and confirm each one's license and maintenance status in its repository before adding it. Do not add a second tool to duplicate coverage. Done when the gap list is written, each gap has a named tool or a documented reason it stays open, and the owners approve the final toolset.
Questions buyers ask before hiring outside help
What does it cost to license garak, PyRIT and promptfoo?
garak (Apache-2.0), PyRIT (MIT) and the promptfoo CLI (MIT) carry no license fee to use. The cost you do pay is the people and infrastructure around them: an engineer to wire targets and detectors, compute for test runs, and any model API usage the probes trigger against your endpoint. promptfoo also sells paid tiers. Its Community edition is free and includes red teaming with 10k probes per month, while Enterprise and On-Premise carry custom pricing for SSO, team sharing, continuous monitoring and priority support with SLAs. Ask for the edition and the probe volume you expect before comparing totals.
What drives the effort of an LLM red teaming project?
Effort follows the number of moving parts, not the license. The main drivers are:
- Target integration: connecting to your model, retrieval layer or chat flow, including authentication and session handling for multi-turn attacks.
- Detector tuning: deciding what counts as a failure for your use case and reducing false positives.
- CI wiring: setting pass and fail thresholds and keeping runs stable as prompts and models change.
- Reporting: mapping findings to your risk register and the OWASP LLM Top 10 or NIST AI RMF categories you report against.
- Team access: shared dashboards, roles and who can see results.
Ask any provider to break its quote along these lines.
How long does a pilot red teaming project take?
No fixed duration applies across environments, so confirm it against your own systems. The length depends on how many targets you test, how hard they are to reach from a test network, whether you have a staging endpoint that behaves like production, and how quickly your team can review findings. A narrow pilot against one staging endpoint with one tool is usually much shorter than a multi-application program with several tools and shared reporting. DeployOpen agrees timelines in writing as part of a fixed-scope engagement, so ask for the milestones and the dependencies on your side in the proposal.
Can our team run these tools without outside help?
A single tool pointed at a staging endpoint is a reasonable first project for an engineer who knows Python and CI. garak can be installed from PyPI, and promptfoo runs locally from declarative configs, so one person can produce useful results. The work gets harder when several teams need shared runs, access control and retained history. The self-hosted promptfoo app stores data in a local SQLite database that cannot be shared across replicas and has no RBAC or built-in SSO, and the vendor does not recommend it for production. Shared multi-user deployments need design work for storage, authentication and upkeep.
What does our team need in place before starting?
Each tool sets its own runtime requirements, so check them before you pick one:
- garak: Python 3.11 or newer, installed from PyPI, developed on Linux and macOS.
- PyRIT: Python 3.10 up to but not including 3.15, with the documentation recommending Python 3.13.
- promptfoo: Node.js 22.22.0 or newer for the 0.124.1 release.
Beyond runtimes, you need credentials and a permitted test endpoint for every model you probe, a place to store reports, and a named owner who reviews failures. Confirm that your security policy allows sending test prompts to the providers you use.
What should we ask for in a DeployOpen quote?
DeployOpen does not publish a price list. A quote follows from written scope, so ask for a statement covering the target systems and endpoints in scope, the tools to be used, the attack categories tested, how CI integration will work, the reporting format and who receives it, the access model for your team, and what your staff must provide. Ask which items are one-time work, such as setup and detector tuning, and which recur, such as retainers for upgrades and continuous testing. Ask how a change in scope is handled before work starts.
Do open-source red teaming results satisfy an auditor?
Red teaming output is evidence for your own risk program, not a certificate. DeployOpen prepares systems, controls and evidence for compliance assessments, but it does not issue audit reports, attestations or certifications, and independent auditors make that determination. Ask your auditor early which evidence format they expect, such as dated test records, scope documents and remediation tracking. The promptfoo documentation references the OWASP LLM Top 10, the NIST AI Risk Management Framework and the EU AI Act as frameworks for systematic testing before deployment, which can help you organize the evidence.
What to confirm before you commit
Before you commit to garak, PyRIT or promptfoo, confirm that the probes you run match the risks in your application. garak ships probes for hallucination, data leakage, prompt injection, misinformation, toxicity and jailbreaks, and PyRIT ships multi-turn strategies such as Crescendo, TAP and Skeleton Key, but neither list is a statement that your application's specific workflows, tools or data paths are covered. Map each risk your team has agreed to test (for example, whether a retrieval step can leak documents across users) to a named probe, converter or plugin, and mark any risk with no match as a gap to test manually. Then confirm that the generator or connector you need actually reaches your target. garak's REST generator depends on a YAML description of your endpoint, PyRIT needs a custom HTTP or WebSocket target or a Playwright-driven web app target, and promptfoo needs a configured provider. Check authentication, network paths and response formats in a staging environment before you plan a test schedule around any of them.
Next, decide where results will live and who may read them. garak writes a JSONL report of every attempt and a hit log, and PyRIT stores conversations and scores in SQLite or Azure SQL, so both produce sensitive records that may contain the prompts and outputs that broke your application. Ask who owns those files, how long they are kept, and how they reach a ticketing or risk system. For promptfoo, the self-hosted app stores data in a local SQLite database that cannot be shared across replicas and lacks RBAC and SSO, and its documentation says it is not recommended for production. If several teams must review results from one deployment, confirm with promptfoo whether Enterprise, with team sharing, access control and SSO, is required, and get that answer in writing. Finally, ask each maintainer how security fixes are published and how quickly they are handled. Check release notes and repository security policies, and record the current versions you have tested, since the maintainers' own release pages are the authoritative source for what changed.
How DeployOpen scopes and delivers a red teaming tool selection
DeployOpen is a Chainscore Labs company that plans, implements, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For LLM red teaming, that means choosing and running probing tools such as garak, PyRIT or promptfoo against your own applications, with the results kept in your environment and the scope agreed in writing first.
How we scope
- Agree in writing which LLM applications, endpoints and model providers the testing will cover.
- Confirm whether the team needs a scanner, a scripted multi-turn framework, a CI eval gate or a mix of them.
- Record licensing, edition and hosting constraints, including whether any paid promptfoo tier is in scope.
How we build
- Install and configure the chosen tools inside your cloud account, data center or air-gapped network.
- Connect generators or targets to your applications and set up detectors and probe selections you approve.
- Wire test runs into your CI/CD pipeline and store JSONL reports and logs where your team can review them.
How we hand over
- Deliver runbooks, configuration files and a written record of the probes, detectors and thresholds used.
- Document how findings are triaged, who owns each report and how results map to your chosen framework references.
- Provide a walkthrough so your security and product teams can rerun the tests without DeployOpen present.
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer after the fixed-scope delivery ends.
- Track tool releases and changes in maintainers or licenses, and flag them to your team for review.
- Confirm with your team how often to rerun testing as applications, models and tool versions change.

