IBM's Granite team released two experimental LLMON previews on November 12, targeting a weakness in agent prompts: instructions and untrusted data often arrive as undifferentiated text. The release article introduces models derived from Granite 4.1 3B and 8B base checkpoints.

LLMON, short for LLM Object Notation, adds explicit structure and relationships to model context. The team reports stronger resistance to indirect prompt injection while retaining general capability near the corresponding Granite Instruct models.

The release is expressly an experimental preview for exploration and evaluation, not production. Its behaviour is learned rather than enforced, and the reported security results concern static attacks.

Meaningful blocks replace implicit relationships

An agent context can contain system instructions, previous turns, retrieved documents, tool responses, output requirements and reasoning. Conventional text or JSON can encode these elements without making their relationships reliable for a language model.

LLMON uses meaningful tags wrapped in reserved special-token delimiters. It marks coherent components as separate blocks and gives them unique identifiers. An execution block then names the instruction, its input data, applicable requirements and output destination.

This makes the intended dependency explicit. A document can be material an instruction acts on without becoming an instruction itself. Unrelated turns or tool outputs can remain in context without being bound to the current task.

The team's argument against ordinary JSON is specific to model interpretation, not parser correctness. Quotes and brackets can appear both as syntax and inside text. A causal model has to learn those distinctions statistically and track nesting across spans. LLMON separates structural delimiters from ordinary content vocabulary and expresses nested structure locally.

The project supplies tools for lossless JSON-to-LLMON conversion and back. It does not require teams to abandon JSON as an application interchange format.

Chat templates still identify the speakers

LLMON enriches chat templates rather than replacing their role structure. Standard chat roles identify the speaker; LLMON identifies what each component means and how it relates to other components.

The preview models ship with their own template. Applications can still build a messages list and call apply_chat_template. Named components can carry an exec flag: enabled parts are bound into the execution block, while disabled parts remain present but unreferenced.

The article's example separates an instruction to write about IBM, the company name as data and two output constraints. The execution block connects those pieces to a named assistant output block. A conventional flattened turn would leave more of that relationship for the model to infer.

The two-character block identifiers are chosen from a tokenizer-specific set. The team says addressing a block costs two tokens regardless of the identifier selected. Structured data inside a component can also be converted into typed, addressable blocks rather than left as one opaque string.

Prompt-injection results have a defined boundary

Indirect prompt injection places hostile instructions inside material the agent should read, such as a retrieved document or tool response. LLMON's separation aims to stop that material acquiring instructional authority.

The team evaluated the previews on OPI and reports robustness as one minus attack success rate. It says LLMON avoided 47% more attacks than the best frontier model tested and 95% more than the best open-source model tested. These are the authors' comparative claims, not percentage-point gains or measurements reproduced here.

The article reports similar trends on ASB and StruQ. Crucially, these benchmarks evaluate static indirect injections. The team says it is still working on adaptive attacks that unfold across multiple chat turns.

A near-zero attack success rate on some benchmarks therefore cannot establish immunity to prompt injection generally. The release explicitly describes the privilege rule as learned behaviour, not an enforced guarantee.

Training teaches the dependency structure

The models start from Granite base checkpoints rather than adding the format to released Instruct models. Six delimiters are installed as reserved single tokens, and a conventional instruction-tuning corpus is reserialized into addressable components and execution blocks.

Training includes chat, multi-turn conversations, retrieval-augmented generation and tool calling. It also introduces decoy instructions and data that remain unbound while the target output stays unchanged. This teaches the model to follow the execution block's dependencies rather than every instruction-shaped sentence in context.

The authors describe five sequential GRPO reinforcement-learning stages covering multi-domain reasoning, human feedback, knowledge calibration and mathematics. A final DPO preference-training stage uses a thousand on-policy pairs drawn from the model's responses to injection attempts.

On standard benchmark categories, the team reports performance comparable to Granite 4.1 Instruct. That comparison applies to the reported evaluations; it does not establish unchanged quality for every application or data format.

Custom vocabularies are possible, with evaluation still required

The ScienceWorld example demonstrates domain-specific tags for goals, planning rules, room state, inventory and next actions. The team converted reference trajectories and trained a LoRA adapter, then evaluated it on held-out simulator games.

This shows how a new vocabulary can represent planning structure. It does not turn a simulator result into proof of safe autonomous operation in a real environment.

The LLMON repository provides tooling and examples. The article also identifies native support in Mellea, which can convert its model calls into the format.

The preview offers a concrete experiment: make instruction-to-data relationships explicit, then test whether the model follows them. Its current boundary remains just as concrete: experimental models, learned separation and static-attack evidence, with adaptive attacks still an open development area.

Sources

Browse the directory →