Model reference · open weights

SingGuard-NSFA

LLMs inclusionAI Vision + text 2 builds Open weights 953 dl/mo

SingGuard-NSFA is an open-weight language model from inclusionAI. SingGuard-NSFA-0.8B (BF16) weighs 2.2 GB; the smallest configuration that runs it is RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • SingGuard-NSFA is a dual-mode guardrail framework developed by inclusionAI to secure agentic AI systems against operational threats such as prompt injection and malicious code requests.
  • The 0.8B variant contains 1.1B parameters, supports a context length of 262144 tokens, and is licensed under Apache 2.0.
  • It operates in 133 languages and combines generative reasoning for offline auditing with lightweight classification heads for real-time detection.

Summary of the inclusionAI/SingGuard-NSFA-0.8B model card, 2026-10-01

What it is

Released byinclusionAI
Released2026-07-10
Parameters1.1B
VRAM2.2 GB for the weights

What it runs on

Memory and cards for SingGuard-NSFA-0.8B (BF16)

2.2 GBweights, file size
12 MBcache per 1K tokens
39 MBfixed state per request
2.0 GBruntime overhead, at least
262,144 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB5216all 256K11.6 GB
RTX 4060 Ti 16 GB7925all 256K15.4 GB
RTX 3090 24 GB13743all 256K23.4 GB
RTX 4090 24 GB13643all 256K23.4 GB
RTX 5090 32 GB19160all 256K31.0 GB
L40S 48 GB28489all 256K44.0 GB
A100 80 GB529167all 256K78.2 GB
H100 80 GB492155all 256K78.1 GB
RTX PRO 6000 Blackwell 96 GB604191all 256K93.8 GB
DGX Spark (GB10) 128 GB unified701221all 256K107 GB
H200 141 GB920291all 256K138 GB
B200 180 GB1000+377all 256K176 GB
Memory needed at each load
Requests at once8K tokens each32K tokens each
14.4 GB4.7 GB
54.9 GB6.4 GB
85.3 GB7.8 GB
166.5 GB11.3 GB
328.7 GB18.4 GB
6413.2 GB32.5 GB

One card, with vLLM's small-card settings.

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
SingGuard-NSFA-0.8B (above) ↗ 1.1BBF16 2.2 GBRTX 3060 12 GB
SingGuard-NSFA-4B ↗ 5.2BBF16 10.3 GBRTX 4060 Ti 16 GB

From the model card

What inclusionAI says about SingGuard-NSFA

Read the model card

SingGuard-NSFA is a dual-mode guardrail framework for securing agentic AI systems against operational threats such as prompt injection, sensitive information extraction, malicious code requests, dangerous tool misuse, and resource exhaustion. It combines SFT-based generative reasoning for interpretable offline auditing with lightweight discriminative classification heads on the frozen backbone, enabling real-time detection at approximately 50 ms. Four model sizes (0.8B, 2B, 4B, 9B) are released, all achieving >94% F1 on purpose-built multilingual benchmarks and surpassing the strongest competing guardrails by 6--12 absolute F1 points.

Model Details

Model Description

SingGuard-NSFA is built on the NSFA (Not-Secure-For-Agents) taxonomy, a CIA-triad-grounded hierarchical classification of 185 risk variants cross-validated against three OWASP guidelines. The framework operates as a single-turn, text-based guardrail, inspecting user queries (input guardrail) and agent responses (output guardrail) to block operational threats before agent execution.


  • Developed by: SingGuard Team, AI Security Lab, Ant Group
  • Model type: Dual-mode guardrail (generative reasoning + discriminative classification heads) for agentic AI security
  • Language(s) (NLP): 133 languages
  • License: Apache 2.0
  • Finetuned from model: Qwen3.5 (Base variants, 0.8B / 2B / 4B / 9B)

Model Sources

  • Repository: https://github.com/inclusionAI/SingGuard-NSFA
  • Paper: SingGuard-NSFA: Extensible Guardrails for Agentic AI via Generative Reasoning and Real-Time Classification (https://arxiv.org/abs/2607.13081)

Uses

Direct Use

SingGuard-NSFA is intended to be deployed as a guardrail module in agentic AI systems to detect operational security threats in real time. It supports two complementary inference modes:

  • Real-time classification (online interception): Lightweight per-domain MLP classification heads on the frozen SFT backbone output risk probability scores in a single forward pass (~45--57 ms per sample on a single NVIDIA A100 GPU). This mode is suitable for high-throughput online traffic where rapid risk screening is the primary requirement. Operators can set per-domain confidence thresholds based on their risk tolerance.
  • Generative reasoning (offline auditing): The SFT model autoregressively generates a free-form chain-of-thought risk analysis followed by a structured risk-type judgment, providing full interpretability for compliance auditing, incident investigation, and human-in-the-loop decision workflows.

The guardrail inspects two detection sides:

  • Query-side (input guardrail): 5 Level-1 risk domains -- Prompt Injection & Jailbreak, Malicious Code & Cyberattack, Sensitive Information Stealing, Dangerous Operations & Tool Abuse, Resource Abuse.
  • Response-side (output guardrail): 2 Level-1 risk domains -- Hazardous Action Generation, Sensitive Information Leakage.

Downstream Use

  • Plug-in enhancement for other guardrails: The classification-head architecture can be trained on top of any frozen guardrail backbone (e.g., Llama Guard 3) to extend its detection capabilities to NSFA risk domains. Experiments show that augmenting Llama Guard 3 with NSFA classification heads improves F1 by 17.6 points on query detection and elevates it to the top rank among all external guardrails.
  • Extensibility to new risk types: New risk domains can be added by training only an additional lightweight classification head on the frozen backbone's embeddings, without retraining the backbone or disrupting existing detection capabilities. For example, a content safety head trained on the SingGuard-NSFA 9B backbone achieves near state-of-the-art performance on content moderation benchmarks.
  • Edge deployment: The 0.8B model variant is suitable for resource-constrained edge devices while maintaining >94% F1.

Out-of-Scope Use

  • Multi-turn or trajectory-level analysis: SingGuard-NSFA processes single-turn, text-only inputs. It cannot detect threats that emerge across multi-turn interaction trajectories, including gradual goal hijacking and cascading tool-call failures.
  • Multimodal threats: Image, audio, or video-based threats are outside the current scope.
  • Inter-agent communication poisoning: Multi-agent system-level threats such as cascading failures and inter-agent communication poisoning are not covered.
  • Content safety moderation: The NSFA taxonomy focuses on operational agent security (what an agent does), not textual compliance (what a model says). Risks such as pornography, violence, and drug-related content are excluded from the NSFA taxonomy. (However, the classification-head architecture can be extended to content safety as a downstream use.)
  • Malicious use: The model should not be used to generate, optimize, or evade detection of harmful agent inputs. It is a defensive tool only.

Recommendations

Users (both direct and downstream) should be made aware of the following:

  • SingGuard-NSFA is a single-turn guardrail and should be complemented by multi-turn trajectory analysis tools for comprehensive agent security.
  • Per-domain confidence thresholds should be tuned based on deployment-specific risk tolerance and traffic characteristics.
  • For low-resource language deployments, additional evaluation on local language data is recommended.
  • The classification-head architecture is natively extensible; operators are encouraged to train custom heads for domain-specific risks not covered by the NSFA taxonomy.

How to Get Started with the Model

SingGuard-NSFA supports two inference modes. Below are usage examples.

Generative Reasoning Mode

The generative reasoning mode uses vLLM for efficient inference. The model accepts user queries or agent responses wrapped in boundary tags (for queries, for responses) and outputs a chain-of-thought risk analysis followed by a structured risk-domain

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms