█

AI/TLDR

Buy me a coffee
Buy me a coffee

Granite 4.1 LLMON Preview

IBM's experimental open-weight 3B and 8B models released 12 November 2026: Granite 4.1 fine-tunes that read prompts in LLMON markup, keeping trusted instructions apart from untrusted data to resist prompt injection, under Apache 2.0.

IN SHORT

What is Granite 4.1 LLMON Preview?

Granite 4.1 LLMON Preview is a pair of experimental open-weight instruct models that IBM's Granite team published on Hugging Face on 12 November 2026, in 3B and 8B sizes, under the Apache 2.0 license. Its weights can be downloaded under the Apache-2.0 licence.

Updated Checked against 2 sourcesMarkdown version ↗
Cite this pageAI/TLDR, "Granite 4.1 LLMON Preview: specs, pricing and benchmarks", https://ai-tldr.dev/models/granite-4-1-llmon-preview/ (updated 12 November 2026)
// FACTSas of 12 November 2026
LicenceApache-2.0 · open weights[1]
Released12 November 2026[2]
Parameters3B and 8B (per IBM's model cards)[1]
  1. [1] huggingface.co Granite 4.1 8B LLMON Preview model card (Hugging Face)
  2. [2] huggingface.co LLMON: An LLM-Native Markup Language, now in Granite 4.1 3B and 8B (IBM Granite on Hugging Face)
Granite LLMON (prompt-injection resistant, experimental)Open weightsExperimental preview — open weights on Hugging Face, not for production
Released
12 Nov 2026
Parameters
3B and 8B (per IBM's model cards)
License
Apache-2.0

Overview

Granite 4.1 LLMON Preview is a pair of experimental open-weight instruct models that IBM's Granite team published on Hugging Face on 12 November 2026, in 3B and 8B sizes, under the Apache 2.0 license. Both are fine-tuned from the Granite 4.1 base checkpoints rather than from the released instruct models, and both read prompts written in LLMON (LLM Object Notation, pronounced "lemon"), which IBM describes as an LLM-native markup language for explicitly communicating structure and semantics to the model. IBM labels the release an experimental preview, ready for exploration and evaluation but not for production.

LLMON wraps every part of a prompt — system policy, instructions, data, documents, tool definitions and tool results — in its own addressable block, using six reserved delimiters that are each a single token. An exec block then names which instruction to run, which inputs it operates on and where the output goes. The model is trained on a privilege rule: the instruction and system blocks are authoritative, while everything reached through exec input — data, documents, tool schemas and tool results — is material to read, not a command to follow, however it is phrased. The shipped chat template renders ordinary messages into LLMON, so callers use apply_chat_template and never write the markup by hand.

LLMON Attention Visualization stepping through a generated answer, with curves showing how much attention each output token pays to the target instruction, target data, distractor instruction, distractor data and LLMON tags
IBM's attention demo: thicker curves show which prompt blocks a Granite LLMON model attends to while it generates.IBM Granite LLMON blog ↗

IBM's launch post says the training converted a standard instruction-tuning dataset into LLMON with added decoy blocks, then ran five sequential GRPO reinforcement-learning stages and a final DPO stage on 1,000 preference pairs. On the OPI prompt-injection benchmark (9,000 attacks, robustness = 1 − attack success rate), IBM reports that both LLMON models resist nearly every attack, a 47-point gain over the best frontier model it tested and a 95-point gain over the conventional Granite 4.1 8B. On general benchmarks the goal was parity with the conventional Granite 4.1 instruct models rather than improvement, and the 8B model card shows mixed results: higher on BigCodeBench, INCLUDE and the safety suites, lower on GPQA, MGSM and the math sets.

The model cards stress that the privilege rule is learned behaviour, not an enforced guarantee: it substantially reduces, but does not eliminate, the chance that an instruction hidden in data is followed, so it should not be the sole defence for an agent with access to sensitive systems. Prompts in a conventional chat format are out of distribution and degrade quality. IBM publishes the LLMON toolkit on GitHub, an attention-visualization demo on Hugging Face Spaces, and native LLMON support in its Mellea library.

Released2026-11-12
LicenseApache-2.0
WeightsOpen weights
Parameters3B and 8B (per IBM's model cards)
ArchitectureGranite 4.1 base checkpoints fine-tuned to consume prompts in LLMON (LLM Object Notation) instead of a conventional chat template
ModalitiesText
StatusExperimental preview — open weights on Hugging Face, not for production

Benchmarks

Bar chart of robustness to prompt injection on the OPI benchmark (9,000 attacks): Granite 4.1 3B and 8B LLMON Preview near 1.0, ahead of GPT-6 Astra, Claude Opus 5.5, Granite 4.1 8B, Gemma 4 E2B, E4B and 12B, Qwen3.8-27B and Qwen3.5-9B, with a 47-point gain over GPT-6 Astra and a 95-point gain over Granite 4.1 8B
OPI prompt-injection robustness (1 − attack success rate), as published by IBM. — IBM Granite
Table of Granite 4.1 3B and 8B Instruct vs LLMON Preview across seven benchmark categories; averages 68.09 vs 69.44 for 3B and 74.90 vs 74.76 for 8B, with LLMON ahead on safety (89.64 vs 80.89 and 90.36 vs 84.19)
Granite 4.1 Instruct vs LLMON Preview by benchmark category, as published by IBM. — IBM Granite

Granite 4.1 8B LLMON Preview vs the conventional Granite 4.1 8B Instruct

BenchmarkGranite 4.1 8B LLMON PreviewGranite 4.1 8B Instruct
MMLU (5-shot)74.273.84
MMLU-Pro (5-shot, CoT)53.1155.99
BBH (3-shot, CoT)80.8880.51
AGI EVAL (0-shot, CoT)73.372.43
GPQA (0-shot, CoT)35.0541.96
IFEval Avg86.6987.06
GSM8K (8-shot)89.1692.49
GSM Symbolic (8-shot)86.383.7
Minerva Math (0-shot, CoT)72.280.1
DeepMind Math (0-shot, CoT)70.8680.07
HumanEval (pass@1)86.5985.37
HumanEval+ (pass@1)81.7179.88
MBPP (pass@1)85.1987.3
MBPP+ (pass@1)74.673.81
CRUXEval-O (pass@1)36.8847.63
BigCodeBench (pass@1)44.0435
MULTIPLE (pass@1)61.0860.26
BFCL v367.9368.27
MMMLU (5-shot)64.9664.84
INCLUDE (5-shot)63.658.89
MGSM (8-shot)76.1682.32
SALAD-Bench97.795.8
AttaQ86.0781.19
Tulu3 Safety Eval Avg87.3175.57

Comparison source ↗

This model's scores

  1. Tulu3 Safety Eval Avg (8B)87.31
  2. IFEval Avg (8B)86.69
  3. HumanEval pass@1 (8B)86.59
  4. MMLU 5-shot (8B)74.2
  5. BFCL v3 (8B)67.93
  6. MMLU 5-shot (3B)68.05

Scores on a 0–100 scale (25-point gridlines); higher is better. Each benchmark links to its published source.

Strengths

  • Apache 2.0 weights in 3B and 8B sizes — commercial use, fine-tuning and self-hosting allowed
  • Trained to treat retrieved documents, pasted content and tool results as data rather than instructions
  • IBM reports near-complete robustness on the OPI prompt-injection benchmark for both sizes
  • General-capability scores close to the conventional Granite 4.1 instruct models of the same size
  • Bundled chat template renders ordinary messages into LLMON, with OpenAI-style tool definitions supported
  • Twelve supported languages, inherited from the Granite 4.1 base

Best for

  • RAG assistants that quote untrusted web pages or documents into the prompt
  • Tool-using agents whose tool results may carry injected instructions
  • Research into structured prompting and instruction/data separation
  • Evaluating prompt-injection defences against a model trained for the boundary

FAQ

Is Granite 4.1 LLMON Preview open source?

Yes. IBM publishes both the 3B and 8B checkpoints on Hugging Face under the Apache 2.0 license, and the LLMON toolkit is open source on GitHub.

What is LLMON?

LLM Object Notation, a markup language IBM designed for model prompts. Every instruction, piece of data, document, tool definition and tool result sits in its own block, and an exec block states which instruction to run on which inputs. The model is trained to treat only the instruction and system blocks as commands.

Do I have to write LLMON by hand?

No. The model ships a chat template that renders messages into LLMON. User messages can carry instruction, data and requirement lists whose items have a value and an exec flag; a plain content string is treated as a single executable instruction.

Can it be used in production?

IBM calls it an experimental preview, ready for exploration and evaluation but not for production. The model cards add that the instruction/data boundary is learned behaviour, not a guarantee, so it should not be the only defence for an agent that can reach sensitive systems.