LLM Guard replacements compared

LLM Guard was archived on July 9, 2026 and receives no security fixes. This page shows which maintained open-source option fits each scanner need, the license terms behind each one, and what it takes to run it in your own infrastructure.

On this page

Which LLM Guard replacement fits your situation

If your team still runs LLM Guard after its archive on July 9, 2026, the likely fit depends on what you need to control. NeMo Guardrails suits teams that want rails written in Colang across input, dialog, retrieval, execution and output flows, especially where dialog control matters. Guardrails AI suits teams that want validators from Guardrails Hub and structured output shaped by Pydantic models. LlamaFirewall, paired with Prompt Guard 2, suits teams whose first concern is prompt injection and jailbreak attempts, including agent workflows. DeepTeam's guardrails are a lighter option, but this page makes no claims about their license, maintenance or feature set, so confirm those directly with the project before you shortlist them.

No option is a one-to-one drop-in for LLM Guard's scanner set, so plan mapping work before any cutover. Export the list of input and output scanners your deployment calls today, then map each one to a validator, a Colang rail or a LlamaFirewall scanner, and mark every scanner with no direct equivalent. Expect those gaps to need custom validators, custom actions or a documented decision to accept the risk. Also test Prompt Guard 2 on your own traffic. Its context window is 512 tokens, so long prompts need a chunking plan, and the model card describes the 86M version as multilingual and the 22M version as a lower-latency option with minimal performance trade-offs.

Before you commit, settle three checks with your security and platform teams. First, confirm the licenses you will accept: NeMo Guardrails and Guardrails AI are Apache-2.0, LlamaFirewall is MIT, and Prompt Guard 2 ships under the Llama 4 Community License Agreement, which your legal team should review. Second, if you choose NeMo Guardrails, budget time for Colang migration. The Colang 2 migration guide describes the nemoguardrails convert tool, but NVIDIA says converted configurations still need manual review. Third, if you use LlamaFirewall's AlignmentCheck, note that it requires a Together API key, which adds an external dependency to your architecture review.

Which option to shortlist for each scenario

This table maps common LLM Guard replacement scenarios to the option that fits best and the condition under which that fit holds. Read each row against your own architecture, since the right choice depends on whether you guard a chat model, a dialog flow, a Python app or an agent.

ScenarioBest fitWhy, and when it holds
Prompt injection screening in front of a chat modelMeta Prompt Guard 2 inside LlamaFirewallPrompt Guard 2 is built to label prompts benign or malicious for injection and jailbreak attempts. This holds if you can run a classifier with a 512-token context window and confirm the Llama 4 Community License terms suit your use.
Policy layer for dialog flows and topic controlNeMo GuardrailsIt configures input, dialog, output, retrieval and execution rails in Colang. This holds if your team can maintain Colang 1.0 or 2.x configurations and budget for manual review after any migration.
Chained validators in a Python app with structured outputGuardrails AIGuards are built from Guardrails Hub validators that chain together and output can match Pydantic models. This holds if your application code is Python and you can review each validator you install.
Code and tool-call scanning for an agent platformLlamaFirewallIt layers PromptGuard 2, AlignmentCheck for agent reasoning, CodeShield for generated code and custom regex or scanners. This holds only if you can supply the Together API key that AlignmentCheck requires or replace that scanner.
Lighter option to startDeployOpen-listed DeepTeam guardrails (review before adopting)A smaller footprint suits a pilot or a single application. This holds only after you confirm its license, maintenance status and attack coverage in your own environment, since no supplied fact covers those details.

Maintained options that replace LLM Guard's role

LLM Guard is archived, so teams still running it need a maintained path for runtime protection. These options differ in design: NeMo Guardrails centers on rails written in Colang, Guardrails AI on validators, and LlamaFirewall on layered scanners. Use the license and maintenance notes on each card to narrow the list before comparing scanners.

NeMo Guardrails

NVIDIA's Apache-2.0 toolkit configures input, dialog, output, retrieval and execution rails in Colang, with a config.yml file and optional Python actions. Its server exposes a /v1/chat/completions endpoint, which suits teams that want one guarded entry point for existing clients. Check that your runtime uses Python 3.10 to 3.13. If you run Colang 1.0 configurations, plan review time for migration, since NVIDIA says converted configurations still need manual review.

Guardrails AI

An Apache-2.0 library of input and output guards built from validators published on Guardrails Hub, such as regex matching or toxicity detection. Validators are installed separately and can be chained, so each one needs its own review for maintainer, scope and false positives. The library also generates structured output that matches Pydantic models and can run as a Flask REST service started with guardrails start. Confirm which validators you need and whether the anonymous metrics prompt in guardrails configure is acceptable in your environment.

LlamaFirewall

Meta's MIT-licensed framework layers scanners across chat models and agents: PromptGuard 2 for direct prompt injection, AlignmentCheck for auditing agent reasoning, CodeShield for insecure generated code, and regex or custom scanners. Install it with pip install llamafirewall on Python 3.10 or later. Version 1.0.3 is the latest on PyPI. AlignmentCheck requires a Together API key, so confirm that external dependency before you plan a fully self-hosted deployment.

Llama 4 Community License models

Prompt Guard 2 comes in 86M and 22M parameter versions that label prompts benign or malicious to detect injection and jailbreak attempts, with a 512-token context window. Llama Guard 4 is a 12-billion-parameter classifier that checks both prompts and responses. Both ship under the Llama 4 Community License Agreement, which is not an OSI open-source license, so have legal review its terms before you embed either model in a product.

DeepTeam guardrails as a lighter option

Consider DeepTeam's guardrails when you want a smaller runtime control than a full framework. The sources gathered for this comparison do not establish its license, maintenance status or feature set, so confirm all three directly with the project before you shortlist it. Ask how its guards map to your input and output risks, and test them against prompts drawn from your own application before relying on them.

How the options compare across capability and license

This table compares NeMo Guardrails, Guardrails AI and LlamaFirewall across license, deployment form, screening coverage, structured output, code scanning and Python requirements. Where the researched facts do not establish a capability, the cell says to confirm with the project, so treat those cells as proof-of-concept questions. The main takeaway is that LlamaFirewall is the only option here with built-in code scanning, while NeMo Guardrails is the only one with a dialog control layer.

CapabilityNeMo GuardrailsGuardrails AILlamaFirewall
License and maintainerApache-2.0, NVIDIA-NeMo repositoryApache-2.0, guardrails-ai repositoryMIT framework from Meta. *Prompt Guard 2 and Llama Guard 4 carry Llama 4 Community License terms.
Deployment formPython library, guardrails server with HTTP API, Dockerfile; separate NVIDIA microservice on KubernetesPython library with validators; standalone Flask REST service via guardrails startPython framework installed with pip; scanners run inside your application or agent
Input screeningInput rails and self-check input moderationInput guards built from Guardrails Hub validatorsPromptGuard 2 scans direct prompt injection; regex or custom scanners for other checks
Output screeningOutput rails and self-check output moderationOutput guards built from Guardrails Hub validatorsRegex or custom scanners; AlignmentCheck audits agent reasoning and needs a Together API key
Prompt injection and jailbreak detectionJailbreak and injection detection included in the libraryConfirm with the project which Hub validators cover injectionPromptGuard 2 for direct prompt injection; confirm coverage of indirect injection
Dialog or policy controlDialog rails configured in Colang 1.0 or 2.0Confirm with the projectConfirm with the project
Structured outputConfirm with the projectGenerates output matching Pydantic models via function calling or prompt optimizationConfirm with the project
Code security scanningConfirm with the projectConfirm with the projectCodeShield scans generated code in 8 languages using Semgrep and regex rules
Python and latest releasePython 3.10 to 3.13; v0.24.1 published September 16, 2026v0.11.0 published August 14, 2026; confirm supported Python versionsPython 3.10 or later; version 1.0.3 is the latest on PyPI

How to map each LLM Guard scanner to a replacement

Start by building a scanner inventory before choosing any replacement. List every input and output scanner your application enables in its LLM Guard configuration today. For each one, record the side it runs on (prompt or response), the threshold or settings it uses, and what the application does on a hit: block, redact, log or escalate. Then assign each scanner to one of four destinations: a LlamaFirewall component, a Guardrails AI validator, a NeMo Guardrails rail, or custom code you own. Keep the result as one row per scanner in a table the security and platform teams both sign off. Because LLM Guard is archived and receives no security fixes, this table is also the record you will need when you retire it.

Each candidate has a different mapping shape. LlamaFirewall layers PromptGuard 2 for direct prompt injection, AlignmentCheck for auditing agent reasoning, and CodeShield for insecure generated code, with regex or custom scanners for the rest. AlignmentCheck requires a Together API key, so confirm with your data owners whether agent reasoning may be sent to that service before you map a scanner to it. CodeShield statically analyzes generated code in 8 languages using Semgrep and regex rules, so check that your application's languages are among them. Guardrails AI maps validators from Guardrails Hub, which you install separately and chain. NeMo Guardrails maps to input and output rails and Colang flows, with built-in moderation and jailbreak and injection detection. Confirm each built-in against your own scanner settings.

Any scanner without a direct equivalent must be rebuilt, tested and documented as a custom validator, Colang action or scanner. Test the rebuilt control against your own prompts and responses, not only the vendor examples, and record both the attacks it should block and the benign inputs it must allow. Write down its false positive handling and who approves changes to it. Treat these gaps as a planned risk with an owner and a date, not as a detail to fix after cutover. An illustrative case: if a team's LLM Guard output scanner has no match in the candidate tools, the team builds a custom check, runs it against recent logged responses, and documents the result before retiring the original scanner.

What the license terms mean for a replacement you run yourself

The licenses in this comparison are not interchangeable, and the difference matters once you run a replacement inside your own infrastructure. NeMo Guardrails and Guardrails AI are both Apache-2.0, which is an OSI-approved license that permits commercial use, modification and redistribution with conditions that are mainly about keeping notices intact and passing the license along. LlamaFirewall is MIT-licensed, which is also OSI-approved and has a shorter notice requirement. The Llama 4 Community License that covers Llama Guard 4 and Llama Prompt Guard 2 is a different kind of document. It is a custom license from Meta, it is not an OSI open-source license, and it carries its own use terms. Your legal team should treat the model weights as governed by Meta's terms, not as open source in the sense the other two tools are.

Your legal review should cover three things. First, attribution and notice duties: confirm what each license requires you to ship with your application or container image, such as copies of license texts or a NOTICE file, and where your build pipeline will place them. Second, use restrictions in the model license: read the Llama 4 Community License LICENSE file in the PurpleLlama repository for acceptable use and any conditions tied to scale or redistribution, and check whether your intended deployment falls inside them. Third, the license of each Guardrails Hub validator: validators are installed separately and may carry their own license, so list every validator your guards depend on and confirm each one's terms individually rather than assuming the Apache-2.0 license of the core library covers them.

Separately, the Guardrails AI quickstart says that guardrails configure asks whether to enable anonymous metrics reporting. Decide this setting deliberately before the tool is installed on a production or regulated host, and record the decision in your configuration baseline. Ask your security team whether outbound telemetry is permitted from that network segment, and confirm with the maintainers exactly what the anonymous metrics contain. In an air-gapped or tightly egress-filtered environment, the safe default is to disable it and verify that no unexpected outbound connections occur during a test run.

What running each option in your own environment involves

NeMo Guardrails puts most of the ongoing ownership in your configuration. A deployment is a config.yml file, Colang files that define the rails and any optional Python actions that call your own systems. You can call the library through its Python API or run the guardrails server, which loads configurations from a folder and exposes an HTTP API. NVIDIA also provides a Dockerfile for building a server image, and a separate NeMo Guardrails microservice, a production container image built on the same configuration model and deployed on Kubernetes with Helm. Your team owns:

  • Configuration and rails: the config.yml, Colang files and custom actions, which encode your policies and must be reviewed whenever the application changes.
  • Language choice: Colang 1.0 is the default. Moving to Colang 2.x uses the nemoguardrails convert tool, and NVIDIA says converted configurations still need manual review, so budget reviewer time per rail.
  • Container and cluster: the server image build, registry, and, if you choose the microservice, the Helm release and Kubernetes operations.
  • Version tracking: NeMo Guardrails releases move quickly (v0.24.1 was published on September 16, 2026), so pin versions and test each upgrade against your rails.
  • Model dependencies: self-check, fact-checking and content safety features depend on the models you select, which need their own evaluation after changes.

Effort rises with the number of rails, the amount of Colang migration and the number of model-backed checks. Confirm with NVIDIA which features your chosen deployment model supports before you commit to a design.

How to pilot a replacement before cutting over from LLM Guard

This sequence moves a team from LLM Guard to a maintained replacement with evidence at each stage. It produces a frozen baseline, a per-scanner comparison of false positives and misses on a labeled test set, a license and maintenance record, and a tested rollback path before enforcement changes.

  1. Freeze the current scanner configuration

    The application team and the platform owner export the LLM Guard configuration the application loads, including which input and output scanners are enabled, their thresholds, and every code path that calls them. LLM Guard was archived on July 9, 2026 and receives no security fixes, so record the exact version in use. Store the configuration and call-site list in version control and agree that no scanner changes will be made during the pilot. Done when a versioned copy of both exists and the owners have signed off on the baseline.

  2. Map each scanner to a candidate

    For every enabled scanner, security and the application owner identify the closest candidate: a NeMo Guardrails rail, a Guardrails AI validator from Guardrails Hub, a LlamaFirewall scanner such as PromptGuard 2 or a regex scanner, or a custom check. Mark any scanner with no equivalent as a gap that needs custom code or a different control. Treat each mapping as a hypothesis to be tested in later steps. Done when a table lists each scanner, its direction (input or output), its candidate, and its gap status, and the owners have reviewed it.

  3. Build a labeled test set from production traffic

    Sample prompts and responses from production logs, remove sensitive data under your data handling rules, and label each item as benign or malicious with the action each scanner should take. Add attack prompts from a red teaming tool such as garak, which probes for prompt injection, jailbreaks, data leakage and hallucination and writes a JSONL report of every attempt, or promptfoo, which runs red team checks in CI/CD from declarative configs. Done when the labeled set covers every mapped scanner and a second reviewer has checked a sample of the benign labels.

  4. Run candidates in shadow mode

    Send a copy of production traffic to each candidate configuration without blocking users, and log each candidate verdict beside the LLM Guard verdict for the same input. Check data flows before enabling anything: LlamaFirewall's AlignmentCheck scanner requires a Together API key, which sends data to a third party. NeMo Guardrails defaults to Colang 1.0, and NVIDIA says converted configurations need manual review after migration. Measure latency and resource use on your own infrastructure, since these depend on model choice and traffic. Done when every labeled item has a verdict from each candidate and the latency figures are recorded.

  5. Compare false positives and misses per scanner

    Score each candidate against the labels, counting false positives (benign inputs or outputs blocked) and misses (malicious items allowed) separately for each scanner rather than as one overall score. Review every disagreement with the baseline by hand to decide whether the label or the scanner was wrong. Adjust thresholds only within the candidate's documented options and rerun the set. Done when a per-scanner results sheet shows both error types for each candidate, and the owners have agreed which trade-offs are acceptable for each control.

  6. Review license and maintenance status

    Record the license and latest release of each candidate. NeMo Guardrails is Apache-2.0 with v0.24.1 released on September 16, 2026. Guardrails AI is Apache-2.0 with v0.11.0 released on August 14, 2026. LlamaFirewall is MIT-licensed, and its latest PyPI version is 1.0.3. Llama Guard 4 and Llama Prompt Guard 2 ship under the Llama 4 Community License Agreement, so ask counsel to review that license separately from the code. Confirm release cadence and open security issue handling with each maintainer before deciding. Done when legal and security have signed off on code, model and service licenses for each candidate that stays in the shortlist.

  7. Cut over with a tested rollback path

    Move enforcement one scanner group at a time, using a configuration switch or feature flag that can return traffic to the previous LLM Guard setup or to a stored configuration for the replacement. Keep the LLM Guard deployment pinned for rollback only, and note that it no longer gets fixes, so it should be retired once the replacement is stable. Set alerts on block rates and review them for the first stretch after each change. Done when a rollback has been exercised in staging, the runbook names an owner for each switch, and the team has written down the decision to retire LLM Guard.

Questions teams ask before replacing LLM Guard

Does LLM Guard still receive security fixes?

No. LLM Guard, Protect AI's MIT-licensed prompt and response scanner, was archived on GitHub on July 9, 2026 and is no longer maintained, so it receives no security fixes. Any vulnerability disclosed after that date stays open in your deployment unless your team patches it, and no upstream fix will arrive. That makes the move a security task as well as a feature change. Start by listing every place LLM Guard runs, including staging, CI jobs and developer tools, and record the exact version in use. Then decide how long the current version can stay in production while the replacement is tested. Review the LLM Guard repository to see which scanners depend on its code, since those need an explicit replacement first.

Does one tool replace all of LLM Guard's scanners?

No single option covers every LLM Guard scanner, so you need a scanner-by-scanner mapping before you choose. Write one row per scanner you enable, the risk it addresses and the replacement that covers it. The options in this comparison cover different ground:

  • NeMo Guardrails provides input, dialog, output, retrieval and execution rails, plus self-check moderation and jailbreak and injection detection.
  • Guardrails AI runs validators from Guardrails Hub, such as regex matching and toxicity detection, and can chain them.
  • Meta's Prompt Guard 2 labels prompts as benign or malicious for injection and jailbreak attempts.
  • LlamaFirewall layers Prompt Guard 2, AlignmentCheck, CodeShield and custom scanners.

Scanners with no direct equivalent will need custom code or a documented decision to drop them. Confirm each mapping against vendor documentation and your own test results before you retire a scanner.

What drives the cost and effort of replacing LLM Guard?

The main cost is staff time for inventory, design, custom code, migration and testing, plus the infrastructure needed to host any classifier models. Most of this is one-time work. Hosting, model upgrades and monitoring recur. The drivers are the number of scanners enabled, how many custom validators or rails you must write, and how much traffic the test set needs to cover. Model choice matters too: Llama Guard 4 is a 12-billion-parameter model, while Prompt Guard 2 comes in 86M and 22M versions, and the Prompt Guard 2 model card says the 22M version cuts latency and compute costs by 75% with minimal performance trade-offs. If you use NeMo Guardrails with Colang 1.0 configurations, NVIDIA's migration guide says converted configurations still need manual review. License review also takes time, since Llama Guard 4 and Prompt Guard 2 ship under the Llama 4 Community License.

What should a replacement quote include?

A useful quote follows from a written scope and lists every item the price covers. Ask for the scanner inventory and mapping, the named replacement options and their versions, the custom validators or rails to be built, and the integration points, such as CI, the API gateway and the application. The quote should also name the model hosting assumptions, the test set and acceptance criteria, the documentation and handover, the license review, and anything explicitly out of scope. Ask whether the work is phased, which steps depend on others, and what changes would trigger a new quote. Separate one-time implementation from any recurring support, upgrade or continuous testing retainer. DeployOpen plans and implements these replacements in the client's own infrastructure under fixed-scope agreements, with scope, deliverables and timelines agreed in writing before work starts. It does not publish a price list, so a quote follows from that written scope.

How long does a replacement take?

The duration depends on the written scope, and no fixed figure applies to every LLM Guard deployment. The biggest variables are the number of scanners, how much custom code is needed, how quickly model hosting and license decisions are approved, and how large the test set must be. A deployment with a few well-mapped scanners and no custom validators will move faster than one that depends on bespoke detection logic. Ask for a phased plan with milestones, a staging pilot before production cutover, and an explicit point where the old version is retired. Also ask who approves each milestone on your side. Because the team cannot retire LLM Guard until replacements are tested, the timeline should include the period when both systems run in parallel. DeployOpen's engagements are fixed-scope, so the timeline is agreed in writing before work begins.

Can our team replace LLM Guard without outside help?

Yes, if the team has Python and platform engineering skills and a test set that reflects its real traffic. Most of the work is inventory, mapping, configuration and testing, which an internal team can do with good records. Plan for the points where people usually get stuck. NeMo Guardrails configurations that move to Colang 2.x need manual review after conversion, according to NVIDIA's migration guide. LlamaFirewall's AlignmentCheck scanner requires a Together API key, so check that your data handling and vendor approvals allow it before you enable it. Model licenses also need an owner, because Llama Guard 4 and Prompt Guard 2 use the Llama 4 Community License. If internal capacity is limited for some of these steps, DeployOpen can take on defined parts of the work under a fixed-scope agreement.

What does a replacement need from our team?

The work needs three things from your side: data, records and decisions. Provide a sanitized traffic sample so the test set reflects real prompts and responses, along with the current LLM Guard configuration for every application that uses it. Provide a scanner inventory that lists each input and output scanner, the threshold settings and the risk each one addresses. Name an owner who makes decisions on models, licenses and acceptable risk, and who can approve scanner mappings and exceptions. You also need access to staging, CI pipelines and the application teams who will test changes. Without a named owner, model and license questions tend to stall the project, so settle that role before scoping starts. A written scope should state which of these inputs the vendor expects and which the client provides.

How do we confirm DeepTeam's guardrails meet our needs?

Confirm it with the project's own documentation and maintainers, then test it against your inventory. Start by checking the license, the maintenance status and the release history, since those decide whether you can ship it and get fixes later. Next, map each scanner in your LLM Guard inventory to a DeepTeam guardrail and mark any gaps. Ask which models the guardrails depend on, where they run, what latency they add and whether they can run in your own infrastructure or air-gapped network. Then run your test set through a staging deployment and compare detection and false positive results with the current scanners. Record the results and the owner who accepts them. If DeepTeam covers only part of your inventory, the remaining gaps need a second option or custom code, and the scope should say so before work begins.

How DeployOpen scopes a guardrail replacement

DeployOpen plans, implements, integrates, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For teams moving off LLM Guard, that means agreeing in writing which scanners, rails or validators replace each current control before any migration work starts.

How we scope

  • Inventory every LLM Guard input and output scanner your applications currently call, and record where each one runs.
  • Agree in writing which replacement covers each control, such as NeMo Guardrails rails or Guardrails AI validators.
  • Define the latency, model hosting and logging constraints the written scope must respect before any build begins.
  • Confirm whether ongoing support or upgrades should be included as a retainer alongside the fixed-scope engagement.

How we build

  • Implement the chosen guardrail framework inside your cloud account, data center or air-gapped network.
  • Integrate the guardrails with your existing application, CI pipeline and logging so each check produces evidence.
  • Test replacement controls against the attack categories in your scope, then record gaps that remain open.
  • Harden the deployment configuration, including access controls, secrets handling and version pinning for each component.

How we hand over

  • Document each scanner mapping, configuration file, Colang or validator setup and the owner responsible for it.
  • Deliver a written record of what was tested, what passed, what was accepted as residual risk and why.
  • Walk your engineering and security teams through operating the guardrails, updating them and rolling them back.
  • Provide the migration evidence your compliance lead or independent auditor will ask for, without implying any certification.

How we support

  • Offer ongoing support, upgrades and continuous testing as a retainer once the initial handover is complete.
  • Track upstream releases of each replacement component and assess their impact on your configured guardrails.
  • Re-run the agreed test set after upgrades so regressions in blocking behavior are caught before production.
  • Confirm retainer terms, response expectations and what is excluded in the written agreement before work starts.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.