LLMON Tests Whether Explicit Context Structure Can Make Smaller Models Safer
IBM's experimental Granite 4.1 LLMON models separate instructions, data, and requirements with model-native markup. The useful question is not whether the format replaces JSON, but whether explicit authority links improve reliability under realistic adversarial evaluation.

LLMON is a promising model-aware structure for separating authority from data, but teams should evaluate it as one defense layer and retain deterministic authorization and validation.
IBM has released experimental LLMON variants of Granite 4.1 at 3B and 8B parameters. LLMON, short for LLM Object Notation, gives context an explicit structure: instructions, data, requirements, and outputs occupy distinct blocks, while an execution block links the pieces that belong to a task. The preview models were post-trained to interpret that structure and to disregard unbound material.
This is a different proposition from adding another serialization format around an unchanged chat model. The format and model behavior are designed together. IBM reports strong resistance to static indirect prompt injections on its chosen benchmarks while retaining performance close to corresponding Granite instruct models. The release also includes conversion tools and support through the models' chat template. Crucially, IBM labels the models experimental and says the learned behavior is not an enforced guarantee.
Structure is useful only when it carries authority
Most model inputs contain more roles than a typical chat transcript reveals. A retrieval-augmented request may include a system policy, a user goal, search results, tool output, formatting constraints, and several earlier turns. Flattening those components into strings forces the model to infer both their boundaries and their authority. A malicious sentence inside a retrieved page can resemble a genuine instruction because both ultimately arrive as tokens in the same context.
LLMON makes a more specific distinction. Blocks identify semantic roles, and explicit references state which instruction acts on which input under which requirements. Content that is present but not linked can remain visible without becoming part of the active operation. In programming terms, this resembles passing named arguments to a function more than concatenating a command and its data into one long string.
That distinction matters more than the surface resemblance to XML. Tags alone do not create a security boundary. The meaningful feature is that the model has been trained to treat the execution graph as a map of authority. Reserved delimiter tokens may make boundaries easier for the model to recognize, but the security claim still depends on learned behavior, correct application-side construction, and the coverage of training and evaluation.
JSON and LLMON solve different problems
JSON remains a good interchange format because conventional software can parse and validate it deterministically. LLMON targets a different consumer: a causal language model reading a mixed context. An application could therefore keep JSON at its external interfaces, validate it normally, and convert selected content into model-facing blocks before inference. The two formats need not compete for the same layer.
This separation suggests a practical architecture. First, trusted application code decides which text is an instruction and which is data. Next, it constructs the model context and links only the intended blocks. Finally, deterministic code validates the generated result before any tool invocation or state change. LLMON can strengthen the middle step, but it cannot determine whether the application classified an attacker-controlled field incorrectly at the first step. Nor can it replace output validation at the last step.
The conversion story deserves similar care. Lossless conversion can preserve a document's structure, but preserving structure is not the same as assigning trust. A field named instruction inside an untrusted document should remain data unless trusted code deliberately grants it authority. Teams evaluating LLMON should test that provenance decision, not merely confirm that documents round-trip between formats.
A useful evaluation starts with attack paths
A convincing trial should mirror the intended system instead of relying on a single headline benchmark. Build a small matrix around where hostile text can enter: retrieved documents, tool results, uploaded files, stored memories, and earlier conversation turns. For each path, include ordinary content, obvious injection attempts, subtle conflicts, and multi-turn attacks that try to shift authority gradually.
Measure at least three outcomes. Task quality asks whether the model still completes the legitimate request. Attack success asks whether it follows the embedded instruction. Operational safety asks whether downstream controls prevent a harmful action even when the model produces a bad answer. These measures should be reported separately; an apparent security improvement caused by refusing most inputs is not equivalent to robust task execution.
Comparison baselines also matter. Test the LLMON preview against the corresponding Granite instruct model using equivalent content and decoding settings. Add a well-designed conventional prompt with clear delimiters, because the relevant engineering question is the incremental value of model-native structure. Repeat tests at realistic context lengths and with the actual chat-template path, rather than hand-building special tokens.
Preview status defines the deployment boundary
The release is best viewed as a research tool for testing structured authority, not as permission to remove existing defenses. Static benchmark attacks do not cover every adaptive adversary, encoding trick, compromised tool, or application bug. Smaller models may also behave differently when contexts become long, schemas become deeply nested, or custom vocabularies depart from their training distribution.
A safe pilot would keep the model away from irreversible actions, log the rendered structure without sensitive payloads, and preserve a deterministic authorization layer around tools. Failures should be classified: was a block linked incorrectly, did the model ignore a correct link, or did downstream code trust an unsafe output? That diagnosis reveals whether the remedy belongs in schema construction, model behavior, or system controls.
LLMON's most valuable idea is that context should express relationships, not merely contain labeled text. The Granite previews make that idea testable at accessible model sizes. Their significance will depend on whether those relationships remain reliable under messy, adversarial workflows—and whether applications continue to enforce security outside the model.
Source: LLMON: An LLM-Native Markup Language, now in Granite 4.1 3B and 8B ↗. How we write


