LLMON is IBM’s new approach to prompt injection: a markup language that lets a language model clearly tell instructions and data apart in its context. On 12 November 2026, IBM released two experimental preview models based on Granite 4.1 that are trained on this format. In benchmarks with instructions hidden inside user data, they largely ignore such attacks. IBM itself stresses, however, that this is learned behaviour, not an enforced security guarantee.
What LLMON is
LLMON stands for “LLM Object Notation” and, according to IBM, is pronounced like “lemon”. In a blog post by the Granite team on Hugging Face, IBM describes the problem: over a long trajectory, a model’s context fills up with many components, such as a system prompt, past turns, instructions acting on retrieved documents, tool responses, user data, output requirements and reasoning chains. That structure is mostly implicit to the model or encoded in formats like JSON that were not designed for language models. IBM says this makes smaller models in particular brittle and can be exploited by attackers.
LLMON uses XML-like markup instead. The key difference is that its structural delimiters are not ordinary characters but reserved special tokens in the tokenizer. IBM names six such delimiters. Structure and content therefore use separate parts of the vocabulary. A quotation mark inside a document can no longer be confused with one that closes a field, something IBM says is only a statistical distinction for a model reading JSON.
Every block gets a unique ID. A dedicated execution block states which instruction runs on which data, under which requirements, and where the answer goes. IBM compares this to calling a function in a programming language and passing its arguments explicitly.
LLMON against indirect prompt injection
In indirect prompt injection, an attacker hides an instruction in data the model is supposed to process, such as a retrieved document, a tool response or user input. That is exactly what LLMON targets. Under the format’s logic, an instruction is only authoritative if it is reached through the execution block. Anything bound as input, meaning data, documents, tool schemas and tool results, is material to read, not a command. Blocks that the execution block does not reference at all are ignored.
IBM measured this on the OPI benchmark, which places injections in the data of classic NLP tasks. Robustness is defined as the share of attacks in which the model does not carry out the injected instruction. According to IBM, all tested models without LLMON are highly susceptible. The LLMON models avoided 47 percent more attacks than the best frontier model tested and 95 percent more than the best open-source model. IBM reports similar trends on the ASB and StruQ benchmarks.
The caveat IBM adds itself matters: these benchmarks test static indirect injections. The team says it is still working on improving robustness against adaptive attacks that unfold over many turns. The blog post does not detail which frontier models were compared, and all figures come from IBM alone.
The models: Granite 4.1 3B and 8B as a preview
Two models are available: granite-4.1-3b-LLMON-preview and granite-4.1-8b-LLMON-preview. According to the model card on Hugging Face, they are released under the Apache 2.0 licence. IBM explicitly calls them an experimental preview, ready for exploration and evaluation but not for production.
On general capabilities, IBM says the LLMON models perform on par with the regular Granite 4.1 Instruct models. If you already use Granite 4.1 at 3B or 8B, IBM says you can swap in the preview without building a conversion pipeline. The models ship with their own chat template. Developers still pass a normal list of messages, but they name the parts of a turn, such as instruction, data and requirements, and mark which of them should be executed. The template turns that into LLMON blocks.
For existing JSON pipelines, IBM provides converters that are meant to translate JSON to LLMON and back without loss. A GitHub repository contains tooling and examples. According to IBM, the Python framework Mellea supports LLMON natively. In an example based on the text environment ScienceWorld, IBM also shows that teams can define their own tag vocabulary and train it in with a LoRA adapter.
How IBM trained the models
The starting point was the Granite 4.1 base checkpoints rather than the released instruct models. LLMON behaviour is therefore learned during post-training instead of being layered on top of an existing chat format. IBM re-serialised a conventional instruction-tuning corpus into LLMON, keeping the usual task mix of chat, multi-turn dialogue, RAG and tool calling.
The training data also contained decoys: instructions and data blocks that sit in the context but are deliberately left unbound, while the target output stays the same. The model is meant to learn to follow only the dependencies stated in the execution block. IBM says this was followed by five sequential GRPO stages covering reasoning, RLHF, knowledge calibration and math, and a final DPO stage with a thousand preference pairs built from the model’s own responses to injection attempts.
What it means for developers
Prompt injection is one of the core problems once language models act as agents that read outside content and use tools at the same time. That AI agents are already part of the security picture is shown by cases like the one in which an AI agent exploited a Cisco BroadWorks flaw. Many teams currently rely on filters, system prompts with warnings or separate checker models. LLMON moves the separation into the input format and the model’s training itself.
That is an interesting step, but it does not replace security architecture. IBM puts it plainly: the separation is learned behaviour, not an enforced guarantee. A model that ignores almost every injection in tests can still fail against new attack patterns. Agents with access to sensitive data or actions still need restricted permissions, human approvals and logging. Our explainer on MCP, memory, skills and hooks shows how those building blocks fit together.
The approach is also notable because it starts small. At 3 and 8 billion parameters, the models target use cases where local or cheap inference matters, much like llama.cpp v1.0.0. Whether large providers adopt similar formats remains to be seen.
Bottom line
LLMON is a serious attempt to tackle the mixing of instructions and data at the root: with reserved tokens, addressable blocks and training that only executes bound instructions. Against static indirect injections, IBM’s own measurements show clear results. But the models are a preview, not yet mature against adaptive attacks and no guarantee. Developers should test them; production use is not on the table yet.




