IBM releases LLMON markup language and Granite 4.1 LLMON preview models, splitting instructions and data into addressable blocks
In a November 12, 2026 Hugging Face blog post, IBM released the LLMON markup language and two experimental preview models built on Granite 4.1, claiming a sharp drop in attack success rates on static indirect prompt injection benchmarks such as OPI while matching Granite 4.1 Instruct on general capability.

What changed
According to an IBM Hugging Face blog post published November 12, 2026, the team introduced LLMON (LLM Object Notation), a markup language, and released two experimental preview models, granite-4.1-3b-LLMON-preview and granite-4.1-8b-LLMON-preview. These models start from Granite 4.1 base checkpoints rather than the released Instruct models, and learn to read and write LLMON during post-training. The blog explains the approach: a conventional chat template only tells the model which role a passage belongs to, while LLMON further marks what each passage is and how the passages relate to one another. In a turn, instructions, data and constraints each become separately addressable blocks, and an exec block declares which instruction runs over which data, under which requirements, and where output is written. LLMON uses six delimiters implemented as reserved special tokens rather than ordinary characters such as braces and quotes to mark structure. Segments not called by an execution block serve only as reading material. The blog says that on the OPI benchmark, LLMON resisted 47% more attacks than the best frontier model it tested and 95% more than the best open model, and that similar trends appeared on ASB and StruQ. These benchmarks measure static indirect prompt injection. The blog also states that this is learned behavior, not an enforced guarantee. The models are released as experimental previews, and the blog explicitly says they are not suitable for production.
What it means for developers
For developers, what changes here is less about model selection than about how messages are constructed. Adopting LLMON means every component of a prompt must be explicitly named and marked as bound to an execution block or not, which effectively moves the role conventions that used to sit inside the system prompt into application code ahead of time. There are at least two integration implications. First, the LLMON preview models ship with a chat template, so building a messages list and calling apply_chat_template as usual should render LLMON blocks; however, the source does not say whether third-party inference frameworks and gateways support this template and its reserved tokens, and self-hosted services need to verify tokenizer and template compatibility themselves. Second, the blog says most teams' JSON-based pipelines need not be rewritten, since its conversion tool can convert losslessly between JSON and LLMON and tags can be customized before fine-tuning a LoRA on an LLMON model. That means a gradual migration path may exist for existing structured data pipelines, but the equivalence of converted output needs independent verification. On inference cost, the blog says block IDs are drawn from a fixed set that a tokenizer encodes as a single token, so addressing a block always costs two tokens; this is only the source's description of addressing overhead and does not mean overall context cost falls. On security, the reported gains cover only static injection, and the authors say they are working on improving resistance to multi-turn adaptive attacks, which are the more common threat shape in agent tool loops. For RAG and tool-calling applications that put retrieved documents or tool returns directly into context, that distinction deserves separate evaluation; the source, however, gives no general benchmark details beyond the comparison with Granite 4.1 Instruct.
Integration and evaluation
Recommendation one: use indirect prompt injection attack success rate as the gate for deciding whether to try it. The key change reported here is the explicit separation of instructions from data, with uncalled segments not treated as commands. One option is to inject a fixed set of attack samples into existing prompts and retrieved data for Granite 4.1 3B or 8B, test the original Instruct model and the LLMON preview side by side, and measure attack success rate and task completion rate on the same sample set. This comparison is meaningful when the workload includes external documents, web pages or tool returns that get concatenated into context; if all input comes from trusted sources, the measurable security difference may be small. Recommendation two: treat whether to introduce exec binding as an application-layer design decision. One option is to first split existing prompts into named parts such as instruction, data and requirement in Mellea or at the template layer, then see whether the model follows exec blocks. The premise is an evaluation environment that can absorb rewriting prompt-construction code, and the metric is whether answer accuracy and the proportion of irrelevant segments pulled into responses match or beat the original on the same task set. The blog claims general capability comparable to Granite 4.1 Instruct, but this needs rechecking on your own tasks and should not be taken as a conclusion. Recommendation three: for tool calling or agent loops, include multi-turn adaptive attacks in evaluation. The source acknowledges that current benchmarks cover only static injection, so good results on static benchmarks do not imply the same results under multi-turn attacks; a possible metric is the execution rate when malicious instructions are inserted across successive turns of tool returns. All of the above are analysis and recommendations based on the source, not confirmed conclusions.
Limits and open questions
Neither LLMON preview model currently appears in KimiSeek's live catalog; the description of their availability here refers only to the release on IBM's and Hugging Face's side and does not involve this site. The blog explicitly calls them experimental previews not suitable for production; resistance to prompt injection is learned behavior, which the authors themselves stress is not an enforced guarantee. The published injection-resistance comparisons center on three static indirect prompt injection benchmarks, OPI, ASB and StruQ; work on multi-turn adaptive attacks is still in progress, and the general-capability comparison is only against Granite 4.1 Instruct. The source gives no license terms, VRAM or deployment thresholds, third-party inference framework support, or API pricing; all of these need independent verification before adoption.
Illustrations from the original report


