IBM's Prompt Injection Fix: From 96.3% to 0.02%

IBM's Prompt Injection Fix: From 96.3% to 0.02%

IBM cut prompt injection attack success from 96.3% to 0.02%. And the model that did it is small enough to run yourself.

On November 12, 2026, IBM's Granite team released two open preview models, granite-4.1-3b-llmon-preview and granite-4.1-8b-llmon-preview, trained to ignore indirect prompt injections hidden inside documents (AI Parabellum). On the OPI benchmark, attack success rates fell from 100% to 0.1% for the 3B model and from 96.3% to 0.02% for the 8B (AISA Studio). Both are Apache 2.0 licensed, downloadable from Hugging Face, and shipped with a toolkit and example workflows. The catch is in the name: these are previews meant for exploration and evaluation.

And the reported results cover indirect injection, not every form of the attack.

What IBM Actually Shipped

Two models, one at 3 billion parameters and one at 8 billion, built for a single job: telling the difference between instructions they should follow and content they should only read.

That sentence sounds boring until you remember it describes the entire prompt injection problem. Every RAG pipeline and every agent that reads webpages or user-uploaded files currently shoves instructions and data into one channel and hopes the model can tell them apart (AGI Hunt).

IBM's approach is the LLMON labeling system, which separates instructions from read-only content at the input level.

Instead of begging the model in your system prompt to "ignore any instructions inside the documents," the training itself teaches the model that labeled content is material to process, not orders to obey. The distinction matters because a politely worded system prompt is a request, and training is a habit. Habits survive adversarial input better than requests do.

This is why the models are aimed squarely at RAG and agent pipelines that read external content.

And why the stated use case is preventing users from hijacking your app through uploaded files.

If your stack ingests PDFs, fetches pages, or summarizes anything you did not write yourself, this release is pointed directly at you.

The Numbers Come From IBM's Own Tests

OPI hides injected commands inside classic language tasks, which is a fair simulation of how indirect injection actually arrives: buried in a document the model was told to summarize.

The before-and-after numbers are dramatic.

The 3B model went from a 100% attack success rate to 0.1%.

And the 8B went from 96.3% to 0.02%. IBM also reports the previews avoided 47% more attacks than the best frontier model it tested. And 95% more than the best open-source model.

Read that comparison again with the sourcing attached: IBM tested it, IBM graded it, IBM published it. Nothing in the coverage I have seen includes an independent reproduction.

So treat those cross-model percentages as vendor homework until someone outside IBM runs the same eval.

The within-model before-and-after numbers are still the story, since they compare the same architecture before and after LLMON training rather than across different models.

The capability bill is small but real. The 3B model kept a general-capability score of 66.7, while the 8B dropped from 74.2 to 72.8 after the safety training. Losing 1.4 points to gain near-total injection resistance is a trade I would take for an untrusted-content role in a heartbeat. It is not a free lunch, and anyone who tells you safety training costs nothing is selling something.

What These Models Do Not Stop

IBM itself draws the boundary, and you should read it before touching production. Direct prompt injection and multi-turn attacks remain far harder to block than the indirect attacks these previews target. The reported results concern indirect injection specifically, meaning commands smuggled inside content the model processes, not a user simply typing hostile instructions into the chat window. A model that shrugs off a poisoned PDF still needs guardrails against the person talking to it directly.

The preview label is doing honest work here too.

IBM positions these for exploration and evaluation rather than production deployment. I have shipped enough preview software to know what that word means: the behavior is promising, the edges are unmapped. And the vendor is asking you to find the failures for free. That is a fine bargain for a builder and a terrible one for a production incident report.

My own rule after building on agents that read the open web: every fetched page is hostile input until something proves otherwise. And no agent gets permissions it does not need to do today's job. Injection resistance in the model is one layer. Narrow tool permissions and output checks are the layers that save you when the model layer has a bad day.

How a Small Operator Should Test This

Apache 2.0 changes the economics of trying this. IBM describes the Granite family as lightweight, performant models released under Apache 2.0 for transparency and deployment flexibility across any infrastructure (IBM). No sales call, no license negotiation, no per-seat anything. An 8B model is within reach of hardware a solo builder already owns or rents cheaply. And Hugging Face is the download path.

Here is the evaluation I would run before trusting any injection-resistance claim, IBM's included.

Pull the toolkit and example workflows IBM shipped alongside the models, then build a test set from your own uploaded files and fetched pages rather than the benchmark suite. Poison a few documents with instructions your agent should refuse, run them through your actual pipeline, and log what happens. Your documents are not OPI documents, and your pipeline is not IBM's pipeline. The only result that pays your bills is the one from your own stack.

Pair the model with a second check rather than treating it as the whole defense.

IBM's Granite Guardian project is a separate family of models that judge whether input prompts and output responses meet criteria you specify (GitHub).

An LLMON model reading the document plus a Guardian model judging the output gives you two independent layers. And two layers fail independently. Then keep the agent's write access, spending authority. And API keys as narrow as the task allows, so a successful injection finds nothing worth stealing.

The Takeaway

The direction here is correct even if the preview is early.

The industry spent two years asking models to please ignore hostile text. And IBM is instead training the instruction-versus-data distinction into the model itself, in open weights anyone can inspect. Small operators who depend on document-reading agents get a testable security component for the cost of a download.

Do not rip out your frontier model and replace it with an 8B preview for general work.

Do slot something like this into the exact place untrusted text enters your stack, measure it against your own poisoned documents. And keep the permissions narrow. Download the LLMON previews this week, build that test set. And find out whether the 0.02% survives contact with your pipeline before an attacker answers the question for you.