Why an air-gapped LLM guardrail needs an offline alternative to Lakera Guard
A security team that must keep prompt filtering inside an isolated network cannot send prompts to a hosted guardrail API, so the question is not whether a guardrail can run offline but what has to be planned to make it work there. NeMo Guardrails and Guardrails AI are both Apache-2.0 licensed and can be self-hosted, but neither ships with its detection models, update path and review evidence already solved for a disconnected environment. Those three items are the real work of this decision. Lakera Guard's air-gapped path is different in kind. As supplied, it requires an Enterprise license and container exports pulled from Check Point's registry, which means the contract, the export process and the import into the isolated network all become dependencies. Before comparing products, ask Lakera for the written list of what the air-gapped package includes, how detection updates reach the enclave, who approves each transfer across the boundary, and what happens to detection quality between releases. Those answers define the baseline you are replacing.
With NeMo Guardrails, the open-source library includes self-check moderation, jailbreak and injection detection, and NVIDIA content safety and topic safety models, but the models themselves must be obtained, verified and staged before the boundary is closed. Guardrails AI works differently: its validators come from Guardrails Hub and are installed separately, so each validator and its dependencies are another package set to bring across. Confirm with each project which model weights and packages a fully offline install needs, and record their versions and checksums. Finally, plan the evidence. A security review or a supervisory examiner will ask what was deployed, how it was verified, and how updates were approved. Under NERC CIP-013-2, supply chain procurement must address verification of software integrity and authenticity, which applies directly to every model file and package carried across the boundary. Build that verification into the process from the first deployment, not as an afterthought.
What an air-gapped boundary requires from a guardrail deployment
A guardrail service inside an isolated network has to run without outbound calls, arrive with verified packages and models, and be installed from images staged in advance. Access to it from outside the boundary also has to be controlled and logged, because the guardrail sits on the path between users and models.
No outbound calls at runtime
Confirm that every component, including the guardrail library, the detection models and any telemetry setting, works with no route to the internet. The Guardrails AI quickstart asks whether to enable anonymous metrics reporting during guardrails configure, so answer that setting deliberately and verify it with a network capture. Check that validators and rails never fetch remote resources when a request arrives. Ask the vendor or project to confirm each outbound dependency in writing.
Verified packages and models
NERC CIP-013-2 expects procurement to address verification of software integrity and authenticity for vendor software and patches, so every Python wheel, container image, validator and detection model carried across the boundary needs a recorded checksum or signature check. Build an internal mirror, record the source and hash of each artifact, and keep a manifest that reviewers can compare against the original release. Repeat this for every model update, not only the first install.
Offline installation from staged images
Kubernetes clusters can be built without internet access by running kubeadm config images list and kubeadm config images pull ahead of time, then pointing kubeadm init at a private registry with --image-repository. Guardrail server images need the same treatment: stage them in the internal registry, pin versions, and test the install on a disconnected lab cluster before production. Confirm that Helm charts and any Python dependencies are bundled in the transfer as well.
Remote access through an intermediate system
For OT-adjacent systems, NERC CIP-005-7 requires interactive remote access to pass through an Intermediate System with encryption and multi-factor authentication, and requires methods to detect and disable active vendor sessions. Apply the same pattern to administrators who update rails or models: no direct path from a laptop to the guardrail host, session recording on the jump point, and a documented procedure to revoke vendor access. Confirm with your compliance team whether the guardrail falls inside an electronic security perimeter.
Logs and access records for reviews
Security reviewers will ask who changed a rail, which model version was loaded and what each verdict was based on. Keep the guardrail configuration files, Colang or validator definitions and model manifests under version control inside the boundary, and forward server logs to the same log store as the rest of the environment. Set access so that only named administrators can change rails, and retain records for the period your assessor specifies.
Where Lakera Guard's air-gapped path meets the constraint and where it leaves gaps
The first decision is whether your network can accept the Lakera Guard air-gapped route at all. The air-gapped deployment requires an Enterprise license and container exports pulled from Check Point's registry. That means the product arrives as images that someone must carry across your boundary, verify and load into your own container platform. Before you plan that work, ask Check Point in writing which images, versions and digests you will receive, how they are signed, and what your team must check before import. If your security team already has a process for software crossing an isolated boundary, map this delivery onto it. NERC CIP-013-2 is one example of a supply chain control that asks for verification of software integrity and authenticity for vendor software and patches.
Three operational questions decide whether the air-gapped path still works after go-live. The first is model and rule updates. Confirm how detection content reaches a disconnected network, how often updates are issued, whether they arrive as signed bundles you import, and whether you can defer an update without losing support. The second is license renewal. Confirm how the license is validated, whether it requires periodic contact with a license server, what happens at expiry if the network stays offline, and whether any grace period is written into the contract. The third is evidence. Ask what Check Point provides for your reviewers, such as release notes, software bills of materials, vulnerability statements and change records for each update.
Gaps remain even when the paperwork is clean. Under this model, every vendor update becomes a controlled import that your team must test against its own traffic, so the vendor's release cadence becomes part of your change process. Your engineers also have limited ability to inspect or tune the vendor's detection logic. Open-source options such as NeMo Guardrails, which is Apache 2.0 licensed, expose their configuration and can run from images you build and scan yourself. Their detection models still need separate evaluation, and your own red-team testing should check the assumptions you make about either option before you rely on it.
Which open-source guardrails run fully offline, and at what trade-off
This table compares the open-source guardrail frameworks and the local model layer that could run inside an isolated network. Read each row for what ships in the box, what must be staged in advance, and what you must confirm before relying on it offline.
| Component | Offline fit and what it needs | Trade-off to confirm before choosing |
|---|---|---|
| NeMo Guardrails (library) | Apache-2.0, supports Python 3.10 to 3.13, latest supplied version v0.24.1 (released 16 September 2026). Can run as a library or as a guardrails server built from the supplied Dockerfile, with jailbreak and injection detection and self-check and content safety models. | Model-backed rails need local model weights. Confirm each detection model is downloaded and pinned into your internal registry before cutover. |
| NeMo Guardrails microservice | NVIDIA's production container on Kubernetes, deployed with Helm. Built on the same configuration model as the library. | Treat as a separate product. Confirm with NVIDIA whether offline Helm installs and model updates are supported in your environment. |
| Guardrails AI (framework) | Apache-2.0, latest supplied version v0.11.0 (released 14 August 2026). Runs as a standalone REST service started with guardrails start, callable through the OpenAI SDK. | Validators are installed from Guardrails Hub. Pre-download every validator package and its model files, because a connected install will not work in an air gap. |
| Guardrails AI validators | Regex, toxicity and custom validators can be chained and kept in your own repository once staged. | Some validators load external models. Test each one with network egress blocked to find hidden calls. Anonymous metrics reporting is an opt-in prompt during guardrails configure, so answer no. |
| vLLM model serving | Serves open-weight models locally. Its online serving docs describe an --enable-offline-docs option for air-gapped environments. | Check that the served model and any classifier weights are staged locally. Confirm GPU capacity with your own sizing. |
| Open WebUI with Ollama | Open WebUI can run entirely offline with Ollama, which keeps model files on local disk. | Suited to chat front ends and smaller models. Confirm it meets your concurrency and audit logging requirements before using it as a guardrail layer. |
How to stage, install and run guardrails inside an air-gapped network
This sequence moves a guardrails server, its detection models and the Kubernetes base it runs on from a connected build network into an isolated network, with each artifact checked before it crosses the boundary. The result is a verified, offline guardrails service that your security reviewers can trace back to specific versions and hashes.
Build the staging inventory on a connected network
On a connected build network, the platform team lists every artifact the isolated side will need: the nemoguardrails Python package or the guardrails-ai package with its Guardrails Hub validators, the NeMo Guardrails server image built from its Dockerfile, base images, Helm charts, and the Kubernetes control plane images. Pin each version in a manifest kept under change control, starting from the NeMo Guardrails v0.24.1 release or the Guardrails AI v0.11.0 release, depending on which framework you choose. Done means every entry has a name, version and source URL recorded in one file that reviewers can read.
Pull Kubernetes control plane images in advance
Run kubeadm config images list to print the control plane image names and versions that the chosen Kubernetes release requires, then run kubeadm config images pull to fetch them on the connected side. Save the pulled images as archives so they can be loaded later without contacting a public registry. Done means every image listed by the first command appears in your staging area with the tag recorded in the manifest.
Mirror everything into a private registry
Load the images and archives into a private registry that is reachable from the isolated network, and tag them with the same names recorded in the manifest. Point kubeadm init at that registry with the --image-repository flag so the control plane never reaches for public hosts. Confirm the mirror by pulling each image from a node inside the isolated network and comparing its digest with the staged copy. Done means every control plane and guardrails image pulls successfully from inside the boundary.
Fetch, hash and validate models and validators
Download the detection models your rails call, such as the jailbreak, injection and content safety models named in your NeMo Guardrails configuration, and the Guardrails Hub validators you plan to use. Compute SHA-256 hashes for every file and record the source, license and version beside each hash. Confirm each model's license permits your use, and confirm with the model publisher or your legal team where the license is unclear. Done means a signed or checksummed inventory exists for every model and validator file.
Transfer through an approved media process
Move the staged bundle across the boundary using the media process your security office has approved, such as a one-way transfer device or verified removable media. Before import, recompute the hashes on the isolated side and compare them with the manifest. Keep the transfer log, the hash comparison and the names of the people who approved each step as evidence. Done means every file matches its recorded hash and the transfer record is complete.
Install and run the guardrails server offline
Load the guardrails container image into the private registry, install the Python packages from a local wheel directory with pip configured to avoid public indexes, and place your configuration folder with config.yml, Colang files and any Python actions into the deployment. For NeMo Guardrails, start the guardrails server so it loads that configuration folder and exposes its HTTP API. For Guardrails AI, start the Flask REST service with guardrails start. Confirm the process starts, and that outbound connections to public hosts fail, since the network should have no route out. Done means the service answers requests from inside the enclave.
Verify the rails with a test suite before enforcement
Write a regression suite of prompts that should be blocked, prompts that should pass, and output samples that should be filtered, then run it against the offline server and record verdicts. Include tests for the rail types your configuration uses, such as input and output rails, and for any Colang 2 migration output that still needs manual review. Run the suite again after every model, validator or configuration change. Done means the results are stored with the artifact versions tested, and your application team has signed off on the verdicts before the service is placed in enforcement mode.
How model and rule updates reach an isolated guardrail
Treat every update as a controlled import, not a sync. On an isolated network, a new NeMo Guardrails release, a detection model version or a Guardrails AI validator never arrives by pulling from a repository. It is downloaded on a connected staging host, reviewed, fingerprinted and then carried across the boundary on approved media. Record a SHA-256 hash for each Python wheel, container image tarball, model weight file and validator package in a manifest, and have a second person verify the hashes on the inside before anything is installed. Ask your vendor or integrator whether release artifacts ship with signatures you can verify offline, and confirm the signing key chain before you rely on it.
Security Onion's documented airgap path is a useful model for the media-based step. Its ISO carries the packages and detection rules, and its soup tool updates the system from newer ISO media rather than from the internet. Apply the same discipline to your guardrail stack: each import is a dated media set with a manifest, a change record and a rollback copy of the previous container images, model files and Colang or YAML configuration. Pin the exact NeMo Guardrails version in your import manifest, since the library's release history (v0.24.1 on 16 September 2026, per its releases page) shows how quickly the code moves, and confirm which Python version your image uses against the supported 3.10 to 3.13 range.
Rerun your red-team results after every import, before the new version takes traffic. A detection model or rail change can shift verdicts on prompt injection and harmful content in ways that a version number does not reveal, so keep a frozen suite of attack prompts and benign production samples and score the new build against the previous one. Record the differences in false positives and false negatives, file them with the import record, and make promotion conditional on that comparison. Keep this evidence with the same manifest, because a security reviewer will ask which build was tested and which build was running on the day an incident occurred.
Evidence a security review will ask for from an offline guardrail
An offline guardrail is only as defensible as the record of what entered the network, how it was checked, and how it behaves. The cards below list the artifacts a security review usually asks for, and each one connects to a control in NERC CIP-013-2 or to general audit preparation. DeployOpen prepares this evidence, but independent auditors and assessors issue the findings.
Software bill of materials and license inventory
Record every package, container layer and runtime dependency behind NeMo Guardrails or Guardrails AI, including transitive Python libraries and the Colang or validator packages installed from outside the enclosure. Pair the inventory with a license list so reviewers can see that each component is Apache-2.0, MIT or another license your legal team has approved. Ask whether your scanner can generate the inventory from the transfer bundle itself, not from a live internet lookup that the isolated network cannot perform.
Hash records for transferred packages and models
For each wheel, container image and detection model that crosses the boundary, store a cryptographic hash, the source location it came from and the person who verified it. Reviewers use these records to confirm that what runs inside the enclosure matches what was approved outside it. This is the working control behind the software integrity and authenticity expectations in NERC CIP-013-2, so keep the hashes with the transfer media log rather than in a separate spreadsheet.
Change records for each import
Each time a package, rule set or model update enters the isolated network, open a change record with the reason, the approver, the rollback plan and the test results that gated it. Security Onion's airgap soup process and similar offline update paths make this easier to standardize, because every update arrives as a defined media set. Auditors will sample these records to check that no import happened outside the approved process.
Guardrail configuration under version control
Keep config.yml, Colang files, Python actions and validator settings in a Git repository hosted inside the enclosure, with signed commits and mandatory review before merge. A reviewer should be able to see who changed a rail, when it changed and which detection threshold moved. Confirm that the repository mirror is updated only through the same import process as other artifacts, so configuration history and package history stay aligned.
Test and red-team results
Store the results of regression tests, false positive reviews and red-team runs against each guardrail version, with the dataset, tool version and pass criteria recorded. Results from promptfoo or a similar tool show whether jailbreak and injection detection still catches the attack set after an update. Keep failed runs as well as passing ones, since reviewers ask how issues were found and fixed.
Access and audit logs
Collect logs of who logged into the guardrail server, who approved imports, which service accounts called the HTTP API and which configuration changes were made. Forward these to a log store inside the enclosure and set a retention period that matches your audit policy. Confirm with your assessor which access controls, including the intermediate system and multi-factor authentication described in NERC CIP-005-7, must be shown alongside the guardrail logs.
Questions buyers ask before choosing an air-gapped guardrail path
Does Lakera's air-gapped deployment require an Enterprise license?
Yes, according to the air-gapped path described for Lakera Guard, which needs an Enterprise license and container exports pulled from Check Point's registry. Confirm the exact terms, support scope and renewal conditions in writing with Check Point or your Lakera account team, since the license cost recurs with the contract. An open-source path changes that line item: NeMo Guardrails is Apache 2.0 licensed and Guardrails AI is Apache-2.0 licensed, so the software itself carries no license fee. You still pay for the hardware or cloud capacity that runs your detection models, the engineering work to configure and test the rails, and any commercial model licenses you choose to add. Ask your legal team to review the component licenses of every model you plan to bring across the boundary, because open-source code and open-weight models often carry different terms.
What drives the cost of an air-gapped guardrail project?
The main drivers are the number of applications and traffic paths that need screening, the detection models you run locally, the size of your red-team test set, and how many environments (development, staging, production, and any isolated enclave) you must replicate. Costs fall into one-time work, including architecture, rail design, integration, hardening and documentation, and recurring work, including model refreshes, rule updates, regression testing and support. Hardware is another driver: detection models can run on CPU or GPU, and the choice depends on latency targets and request volume, so benchmark it on your own traffic. When requesting a quote, ask for a written scope that lists systems in scope, the rails and models to be delivered, the test cases, the handover documents and what is excluded. A fixed-scope agreement makes these items visible before work starts.
How long does an air-gapped guardrail implementation take?
The duration depends on the number of integration points, how many detection models must be transferred and validated, the state of your isolated network, and the amount of testing your risk owners require. No public figure applies to your environment, so ask for a timeline in the written scope rather than relying on a generic estimate. Plan separately for the transfer process itself. Every package, container image and model file crossing into the isolated boundary needs a verification step, which supports the software integrity and authenticity expectations in NERC CIP-013-2 if you operate under that standard. Also allow time for a side-by-side comparison on recorded traffic before enforcement is switched on. Ask the implementation partner to show which phases run in parallel and which depend on a change window in your environment.
What does the work require from our own engineers?
Expect your engineers to provide access to the isolated environment, approve the software and model intake process, supply representative application traffic, and own the change process after handover. The platform side needs people who can run Kubernetes or a container host in the enclave, manage a private registry, and operate a model server. The application side needs developers who can call an HTTP guardrail endpoint, handle a block or flag verdict, and log the outcome. Security staff must define which risks to enforce, which to monitor, and which exceptions require approval. Python skills matter because NeMo Guardrails configurations combine config.yml files, optional Python actions and Colang files, and Guardrails AI validators are installed and chained in Python. Confirm with the implementation partner which of these skills you will need in-house and which will be delivered and documented.
Can our own team run the air-gapped guardrails without an implementation partner?
Many teams with mature platform and security engineering can do it internally, especially if they already operate Kubernetes, private registries and self-hosted services in disconnected networks. A partner adds the most value when you lack that experience, when a compliance review requires documented evidence, or when you need an independent red-team exercise to test the rails. Internal teams should be honest about four tasks: building and validating the offline model and package set, writing and reviewing rail configurations, keeping test suites current as applications change, and handling false positives without weakening controls. If you choose a partner, DeployOpen plans, implements, hardens, documents and supports self-hosted open-source platforms inside your own infrastructure, including air-gapped networks, and most engagements are fixed-scope with agreed deliverables. Ongoing support and continuous testing are available as retainers.
How do model and rule updates work when the network is offline?
Updates arrive as a controlled import, not as a live download. Your team or partner pulls approved releases of NeMo Guardrails or Guardrails AI, their validators and the detection models on an connected staging system, scans and verifies them, then carries them across the boundary on approved media. Security Onion's documentation shows the general pattern of applying newer ISO media in airgap mode, and Wazuh can use an offline vulnerability repository, which illustrates how other security platforms handle the same problem. For guardrails, plan a regression run against your recorded traffic before each import, because a new model version can change verdicts. Keep the previous version available for rollback. Ask the implementation partner to document the update procedure, the approval roles and the rollback steps. Confirm also whether the validators you need are published on Guardrails Hub and whether they install from a package set you can mirror.
What does red-team testing of the guardrails involve?
Red-team testing checks whether the rails stop the attacks you care about and whether they wrongly block legitimate use. It typically covers prompt injection and jailbreak attempts, attempts to extract sensitive data, harmful content requests, and attacks delivered through retrieved documents or tool outputs. The work produces a test set, a record of verdicts, a list of bypasses and false positives, and fixes that are retested. Open-source tools such as promptfoo can help measure detection before and after a switch, and DeployOpen runs application, API, AI system and agent security testing, including red teaming, under a written scope. Results should show the test cases, the model and rail versions used and the decisions made, so they can support a security review. Note that a red-team exercise does not certify the system. Independent auditors and certification bodies issue those assessments, and DeployOpen prepares the evidence for them.
What evidence will a security review or auditor expect from an offline guardrail?
Reviewers usually want a current inventory of components with versions and licenses, a record of how each artifact was verified before entry, the architecture showing the isolated boundary and data flows, the rail and policy configurations under version control, and test results linked to specific versions. They also look for documented access control, logging of guardrail verdicts, and a tested rollback procedure. Some frameworks expect controls for remote access, such as NERC CIP-005-7, which requires remote access to high and medium impact BES Cyber Systems to pass through an Intermediate System with encryption and multi-factor authentication. If your environment falls under a regime such as CMMC, confirm its applicability with your assessor, since the scope rules in 32 CFR Part 170 determine which systems count. DeployOpen prepares the systems, controls and evidence for compliance assessments, but independent auditors issue any attestation or certification.
How DeployOpen deploys guardrails under an air-gapped constraint
DeployOpen plans, implements, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure, including air-gapped networks. For a Lakera Guard alternative in an isolated environment, we start by agreeing in writing what the guardrails must cover, then build, test and hand over the stack so that your team can run it without outside connectivity.
How we scope
- Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
- We record which prompt attack, harmful content and data leakage risks the guardrails must catch inside your isolated network.
- We confirm which detection models, rule sets and packages must be carried across the boundary, and who approves each transfer.
- The written scope states how model and rule updates will be imported, verified and tested, so the process is clear before build.
How we build
- We deploy the chosen open-source guardrail framework, such as NeMo Guardrails or Guardrails AI, into your cluster or servers.
- We pull container images, Python packages and models through a private registry and mirror them so nothing depends on the public internet.
- We configure input, output and tool-call rails or validators, then test them against red-team prompts and recorded application traffic.
- We document each verified artifact, its source and checksum, and the steps used to import it across the air gap.
How we hand over
- Handover includes architecture diagrams, runbooks for offline updates, and configuration kept in version control inside your environment.
- Security reviewers receive evidence packs covering the controls, test results, access settings and change records for the deployment.
- We walk your engineers through rail tuning, false positive review and the import procedure for new artifacts before closing the engagement.
- Compliance leads receive mapping notes that show which controls the evidence supports, while independent auditors make any assessment decision.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers, scoped separately from the initial engagement.
- Retainers can cover periodic re-testing of the rails, review of new open-source releases and offline update cycles.
- Ask any provider to confirm in writing how they handle model updates, vulnerability feeds and package verification without internet access.
- Ask for the cost components in a quote, including one-time build effort and recurring support, before choosing a scope.

