IBM equips Granite with an LLMON format to better separate instructions and data

IBM launches two test versions of Granite 4.1, in 3B and 8B, trained with LLMON, a format that explicitly distinguishes instructions and data. The goal: reduce hidden prompt injections in documents or tools.

On November 12, 2026, IBM presented two experimental models, Granite-4.1-3B-LLMON-preview and Granite-4.1-8B-LLMON-preview, trained to clearly distinguish reliable instructions from unreliable data. The project relies on LLMON, a markup format designed for language models, to limit indirect prompt injection attacks. The topic is especially relevant for use cases involving document search, external tools, and agents, where a hidden instruction can easily slip into the context. However, IBM warns that these are previews intended for evaluation and not for production.

When the context becomes too loaded for the model

Large language models do not just read a question: they also ingest system messages, past exchanges, retrieved documents, tool responses, and security instructions. As this context grows, the structure becomes blurred, especially when everything is mixed in a classic text chain. This is precisely where smaller models or less robust architectures derail more quickly. And it is also where prompt injection attacks find their place, often hidden in a document or a tool response.

LLMON, standing for LLM Object Notation, proposes a different logic: each block — instruction, data, requirement, response — is explicitly identified and linked to its role. IBM describes this format as a native markup language for language models, with reserved delimiters and identifiers that allow pointing to a precise instruction. In short, the model no longer has to guess what is a command and what is material to read.

A bulwark against hidden instructions, but not armor

On the OPI benchmark, which places injection in classic NLP task data, IBM says it observed a clear drop in the success rate of attacks. The LLMON version practically eliminates the problem on this test, with robustness measured as 1 minus the attack success rate; the company also claims that the models avoid 47% more attacks than the best tested frontier model, and 95% more than the best open source model [to be verified according to the exact comparisons retained]. The announced results also cover ASB and StruQ, with the same trend. The important point: these are static attacks, not adaptive attacks deployed over multiple rounds.

IBM also emphasizes another useful effect: instructions unrelated to execution are no longer absorbed by the answer engine just because they linger in the context. In other words, each instruction is attached to specific data, which limits confusion between old exchanges, off-topic passages, and tool outputs. This is good news for RAG workflows and agents, where the temptation to put everything into a single textual soup remains strong. The format is no magic wand, but it adds a structural barrier where many systems still mainly rely on behavioral safeguards.

An integration designed for developers, not for verbal gymnastics enthusiasts

The test models are derived from Granite 4.1 and have been fine-tuned from the base checkpoints, not from already published Instruct versions. IBM indicates they can be used with the same list of messages as a standard chat model; the provided template handles transforming this structure into LLMON blocks. Teams therefore do not have to rewrite their entire stack, and can also convert existing JSON to LLMON without loss, then revert if needed.

The associated GitHub repository provides conversion tools, workflow examples, and notebooks. An attention visualization is also offered to see how the model distributes its attention between instructions, data, and unrelated blocks. IBM finally cites Mellea, a library that automatically "LLMONizes" model calls. Practical translation: the markup stays behind the scenes for most developers, avoiding adding a visible complexity layer to each request. The kind of detail that makes product teams smile when they see three debug tickets disappear at once.

Ce que montrent les chiffres d’IBM

The published results mainly outline a trade-off between structured security and overall performance. IBM claims that both versions remain at the level of Granite 4.1 Instruct models on standard benchmarks, with some variations depending on tasks: the 8B model leads on BigCodeBench but lags on GPQA and DeepMind Math in the figures cited by the source note. The message is clear: LLMON is not presented as a uniform improvement, but as a way to reorganize model behavior around an explicit priority principle.

IBM also specifies that the observed privilege rule is learned, not imposed by a hard barrier. This is an important methodological point for teams wanting to use it in sensitive environments: the system reduces risk but should not be the sole defense. The models are under Apache 2.0 license and announced as experimental. For now, the best practice is mainly to test, measure, and see what the format changes in chains where the boundary between data and orders was previously too porous.

Key points

  • Published on November 12, 2026 by IBM Granite.
  • Two previews: Granite-4.1-3B-LLMON-preview and 8B.
  • OPI measures robustness against indirect injections.
  • IBM announces 47% more attacks avoided than the best frontier model.
  • Models remain experimental, not intended for production.
  • Mellea makes LLMON usable without changing the chat flow.

By the numbers

  • 2 models — previews published by IBM on November 12, 2026.
  • 3B and 8B — sizes of the two Granite 4.1 LLMON variants.
  • 47% — attacks avoided more than the best tested frontier model, according to IBM.
  • 95% — attacks avoided more than the best tested open source model, according to IBM.
  • 1,000 pairs — preferences used for the final DPO phase, according to IBM.

To read