AI Security
Introducing Shield
Prompt injection and jailbreak detection for AI agents. Four hosted tiers, an OpenAI-compatible API, and a free Shield tier.
- Author
- ZeroLeaks Research
- Published
- Reading time
- 5 min
- Share
Today we're releasing Shield, a family of models that checks the text an AI agent is about to read for prompt injections and jailbreaks.
In our published comparison across 35 public datasets, Shield Large achieved the highest overall score: 90.4% mean balanced accuracy, ahead of GPT-6 Sol, Jev and OpenAI Guardrails.
The small Shield model runs in a median of 7ms on one CPU thread. Large takes 38ms on one NVIDIA A10G. These are local model timings; hosted requests add network and queue time.
The hosted API is available today. Start with the free Shield tier or use Base, Large and Tiered through any paid ZeroLeaks plan.
Built for the text agents read
An attacker doesn't always send a message directly to an agent. They can put an instruction in an email, a retrieved page or a tool description that the agent will read while doing its work.
Shield checks that text before you pass it to the model. It returns a verdict and score; your application decides whether to block the input, ask for approval or handle it another way.
We trained the classifiers on tool results, MCP descriptions, web pages, agent skills and documents, with injected instructions and benign counterparts. The goal is to recognize the attack without treating the whole format as suspicious.
For example, one poisoned MCP description tells an agent to query an SSH private-key table before listing databases. Shield Large flagged that text in our comparison; Azure AI Prompt Shields and Amazon Bedrock Guardrails did not.
Detection is one layer. The agent should also have only the permissions its task needs.
Performance
We measured five categories: agent attacks, prompt injection, jailbreaks, multilingual inputs and false alarms. The overall score averages the categories so that one large dataset does not dominate the result.
Shield Large scored 90.4%, compared with 87.6% for GPT-6 Sol used as a judge, 84.6% for Jev and 80.1% for OpenAI Guardrails.
Across all benchmark texts, Large caught 84.5% of attacks while flagging 5.4% of benign inputs. GPT-6 Sol caught 78.4% at a similar false-alarm rate. Jev caught 67.2% with fewer false alarms, at 0.9%.
Large doesn't lead in every category. GPT-6 Sol scored higher on agent attacks and prompt injection, while Jev was better at leaving benign text alone. The model card includes every category and dataset.
These are results from our published September comparison. The model card and evaluation notes explain the protocol and its limits.
Four tiers
Shield is the small CPU model and the free hosted tier.
Base is a larger encoder. In this comparison it scored higher than Shield while flagging fewer benign inputs.
Large combines a 1.7B classifier with Base. It has the highest overall score of the four tiers and is intended for GPU inference.
Tiered starts with Shield and sends uncertain scores to Large. In the benchmark, 24% of inputs reached Large. Confident small-model misses can also pass through this route, so escalation is not a guarantee that Large sees every attack.
Speed
On our benchmark hardware, median local model inference was:
- Shield: 7ms on one CPU thread
- Base: 19ms on one CPU thread
- Large: 38ms on one NVIDIA A10G
The CPU tests used an Intel Xeon Platinum 8488C. The Large GPU test used bf16; the hosted artifact uses Q4. These figures exclude hosted transport and queueing. The competitor API timings in the chart include their round trips.
Longer inputs can require more windows and take longer to process. The API reports coverage, so an unflagged result should be read alongside whether the full input was scored.
Get started
Create an API key, then point the OpenAI client at Shield:
import OpenAI from "openai";
const shield = new OpenAI({
apiKey: process.env.ZEROLEAKS_API_KEY,
baseURL: "https://api.zeroleaks.ai/v1",
});
const { results } = await shield.moderations.create({
model: "shield",
input: toolResult,
});
Check results[0].flagged before passing the text to your agent. The quickstart covers all four tiers and coverage metadata.
Evaluation and limits
Shield detects suspicious text. It cannot determine every violation of your application's permissions or rules, and it misses some attacks. Benign security writing that quotes attacks can also be flagged.
The published adaptive and gradient-based tests evaluated the previous September 29 models. They do not measure the current ensemble's adaptive robustness. Those historical results remain in the model card rather than serving as a headline result for this launch.
The model card contains the training details, benchmark method, category results, historical attack tests and limitations.
Availability and data handling
The hosted Shield tier is free with an account, API key and research acknowledgement. Base, Large and Tiered are included in every paid ZeroLeaks plan. Small’s 118 MB int8 ONNX weights are available for noncommercial use under CC BY-NC 4.0, with a Python example you can run locally. Commercial use of the weights requires a separate license. SDK v2 package publication is separate.
Paid requests retain no submitted content. Unflagged free requests are not retained. With your acknowledgement, flagged free requests may contribute redacted excerpts to security research for up to 12 months.
Redaction is best effort. Use the paid service for sensitive content that cannot be retained after redaction. Read the full data-handling policy.