Every LLM can read a bracket. Very few can actually follow a protocol.
That gap — between recognizing syntax and executing structured workflows — is what iLang's conformance levels measure. There are four of them: L0 through L3. A fifth (L4) exists for runtime-integrated systems, but the first four are where the real story lives. And the story is this: almost every AI agent shipping today is stuck at L0, and most builders do not even realize it.
What Conformance Means in a Protocol Context
In traditional protocol engineering — HTTP, TCP, USB — conformance levels define what an implementation must do to be considered compatible. A device that physically connects to a USB port but cannot negotiate data transfer is not USB-compatible. It is just a piece of plastic that fits the hole.
The same logic applies to AI communication. An LLM that recognizes [READ:@SRC|fmt=json] as "some kind of bracketed instruction" is not protocol-compatible. It is pattern-matching syntax without understanding operational semantics. That is L0. It is where most agents live, and it is the reason multi-agent systems break in production.
L0: Syntax-Aware — "I See Brackets"
L0 means the model can identify the structure of an iLang instruction. It recognizes that [VERB:@TARGET|mod=value] is a command pattern, not random text. It can parse the components — verb, entity, modifiers — and describe what they probably mean.
::CONFORMANCE{L0|name:syntax_aware}
T:recognizes [VERB:TARGET|param] structure
T:can identify verb, entity, modifier components
A:executes_reliably⇒NOT_GUARANTEED
Every modern LLM passes L0. GPT-4, Claude, Gemini, DeepSeek, Llama — they all recognize bracket-pipe-arrow syntax because it overlaps with code, JSON, and markup patterns in their training data. This is not an achievement. This is table stakes.
The problem is that L0 recognition creates an illusion of understanding. A model at L0 can look at [READ:@GH|path=config.json]=>[FMT|fmt=json]=>[Ω] and explain what it means in natural language. But hand it to a different model in a multi-step pipeline, and the second model may interpret @GH as a variable name, ignore the pipe semantics entirely, or treat Ω as a Greek letter rather than the output terminator. L0 is recognition without contract. It is reading sheet music without knowing how to play.
L1: Instruction-Compatible — "I Can Execute One Step"
L1 is the first level that matters operationally. An L1-compatible system can take a single iLang verb with its target and modifiers, and execute it correctly. Not describe it — execute it.
::CONFORMANCE{L1|name:instruction_compatible}
T:executes single verb with target and modifiers
T:respects modifier semantics (fmt, lng, len, ton, sty)
T:produces output matching specified format
A:chain_execution⇒NOT_GUARANTEED
The difference between L0 and L1 is the difference between reading a recipe and cooking a dish. At L1, when you send [XLAT|lng=en|ton=formal|sty=email], the model does not just understand that you want a translation — it produces formal English in email style. The modifiers are not suggestions. They are parameters with defined semantics.
Here is what L1 execution looks like in practice:
# L0 behavior (recognition only):
Input: [SHRT:@article|len=200|lng=zh]
Output: "You want me to summarize the article in Chinese
in about 200 words."
# L1 behavior (actual execution):
Input: [SHRT:@article|len=200|lng=zh]
Output: [200-word Chinese summary of the article]
Most commercial AI products that claim to support structured instructions are L1 at best. They can follow a single well-formed command. But chain two commands together with a pipe operator, and things start to fall apart.
L2: Workflow-Compatible — "I Can Run a Pipeline"
L2 is where protocol conformance gets genuinely useful. An L2 system understands pipe chains — the => operator that connects operations into workflows where each step's output becomes the next step's input.
::CONFORMANCE{L2|name:workflow_compatible}
T:executes multi-step pipe chains
T:auto-injects @PREV between steps
T:maintains state across chain steps
T:handles modifier inheritance in chains
A:agent_to_agent_handoff⇒NOT_GUARANTEED
This is the level where iLang's batch processing power — the feature the protocol author calls its strongest — comes alive:
[READ:paper.pdf]=>[EXTC|whr=data,findings]=>[XLAT|lng=zh]=>[STYL|sty=academic]=>[Ω|fmt=md]
Five operations. One pipeline. The natural language equivalent would be five separate prompts, five round trips, five chances for context loss. At L2, this executes as a single instruction with each step feeding the next through @PREV, the implicit pipe variable.
The critical L2 behavior is state propagation. When [READ:paper.pdf] produces output, that output must survive intact as it flows through extraction, translation, and styling. A system that re-interprets the source material at each step — rather than operating on the previous step's actual output — is not L2. It is doing L1 five times in a row, which is a different thing entirely.
This is where most real products currently sit. The iLang product portfolio maps to conformance levels explicitly:
AutoCode → L2 (47 skills in chained workflows)
Imprint → L2 (behavioral DNA mutation + decay chains)
iReview → L3 (AI-to-AI code review handoff)
Getting to L2 is the threshold for building useful things. The jump from L1 to L2 is not incremental — it requires the model to maintain a concept of pipeline state that most prompt-based systems do not have.
L3: Agent-Compatible — "I Can Talk to Other Agents"
L3 is the multi-agent level. An L3 system can participate in AI-to-AI communication: handing off tasks to other agents, inheriting state from upstream agents, and recovering from errors in a distributed workflow.
::CONFORMANCE{L3|name:agent_compatible}
T:AI-to-AI handoff with state transfer
T:status inheritance across agent boundaries
T:error recovery in multi-agent chains
T:respects UNTRUSTED{} boundaries on injected content
This is where the v4 execution declarations become essential. iLang v4 added eight structured declarations specifically for agent-to-agent coordination:
UNTRUSTED — marks content from unverified sources
BUDGET — resource constraints (tokens, time, cost)
STATUS — agent state for handoff
OBJECTIVE — declared goal for downstream agents
RUBRIC — evaluation criteria
EVIDENCE — supporting data with provenance
PRIOR — known context the receiving agent should assume
FALLBACK — what to do when the primary path fails
Consider a real scenario: Agent A researches competitor pricing, Agent B synthesizes a strategy document, Agent C reviews the document for logical flaws. At L3, Agent B receives Agent A's output wrapped in a STATUS{} declaration that carries metadata — what was searched, confidence levels, which sources were used. Agent C receives the document with an OBJECTIVE{} telling it exactly what to evaluate and a RUBRIC{} defining what counts as a logical flaw.
Without L3, each agent operates blind. Agent B gets raw text and has to guess what Agent A actually did. Agent C gets a document with no instructions beyond "review this." The result is the telephone game — semantic degradation at every handoff point.
The UNTRUSTED{} declaration deserves special attention. In a multi-agent pipeline, content from external sources (web scrapes, user uploads, third-party APIs) enters the chain alongside trusted instructions. L3 conformance requires the agent to recognize UNTRUSTED{} boundaries and treat that content as data rather than instructions — the protocol-level defense against prompt injection that is otherwise left to each model's ad hoc safety layer.
Why Most Agents Are Stuck at L0
The answer is structural, not technical. Current AI development treats the model as the entire system. You write a prompt, send it to an API, get text back. The model itself handles parsing, execution, state management, and output formatting — all in one undifferentiated blob of next-token prediction.
Protocol conformance requires separation of concerns. The perception layer (understanding what the instruction means) is a different problem than the decision layer (choosing what to do) which is a different problem than the execution layer (actually doing it). iLang v5's three-layer architecture — Layer A for exact predicates, Layer B for vector judgment, Layer C for co-evolutionary trust — makes this separation explicit.
But most builders never get past the "send a prompt, get text back" loop. They are building at L0 because their entire architecture assumes L0 is all there is.
The Cost of L0
When your agents operate at L0, every integration is bespoke. Every multi-step workflow requires hand-coded orchestration. Every agent-to-agent handoff loses information. You cannot audit what happened because there is no structured record of what was intended.
The iLang v5 judgment spec includes a formal conformance scoring system (JCS) that measures this precisely:
Schema validity rate — weight: 0.20
Mode exact match — weight: 0.40
Vector MAE — weight: 0.20
Boundary case accuracy — weight: 0.20
L2 pass threshold:
schema ≥ 0.99
mode ≥ 0.90
MAE ≤ 0.12
boundary ≥ 0.80
JCS ≥ 0.90
These are not arbitrary numbers. They represent the minimum bar where an agent's judgment becomes reliably auditable — where you can trace back from an action to the vector assessment that produced it, verify the decision cascade, and identify exactly where a failure occurred.
The Path Forward
Getting from L0 to L1 is easy: use a model that follows structured instructions faithfully. Getting from L1 to L2 requires pipeline architecture — a system that maintains state across steps. Getting from L2 to L3 requires protocol awareness — agents that speak a common language with structured handoff semantics.
The gap between L0 and L3 is not about smarter models. GPT-4 and Claude are both capable of L3 behavior when given proper protocol context. The gap is about architecture. It is about treating AI communication as an engineering problem with defined interfaces, not a prompt-crafting art project.
iLang defines those interfaces. The conformance levels measure how well an implementation respects them. And right now, the industry is building skyscrapers on L0 foundations — which explains why multi-agent systems keep collapsing in production.
The fix is not more parameters or better prompts. The fix is protocol discipline. L0 through L3, one level at a time.
Get Started with iLang
- Website: ilang.ai
- GitHub: github.com/ilang-ai
- npm: @i-language/spec
- Book: I-Lang on Amazon
No comments:
Post a Comment