I-Lang v5.0 Specification

1. Overview

I-Lang is an AI-native communication protocol built from symbols already inside every LLM's training data: brackets, pipes, arrows, key-value pairs. It defines a formal vocabulary for three communication modes:

2. Two Syntaxes

2.1 Operation Syntax — What AI Does

[VERB:@TARGET|modifier=value]=>[NEXT_VERB]=>[Ω]

Operations are executable instructions. Each step in a chain receives the output of the previous step. The chain terminates with [Ω] or [OUT].

Components:

2.2 Declaration Syntax — What AI Is

::GENE{trait_name|conf:confirmed|scope:global}
  T:positive_trait
  A:anti_pattern⇒consequence
::STATE{@SELF, attribute:value}

Declarations define behavioral identity — personality, rules, anti-patterns, and immune responses. They can persist across sessions when stored in profile or configuration files.

2.3 Immutable Genes (G001-G012)

These define core behaviors that cannot be overridden:

G001  T:verify_first             A:blind_exec⇒fatal
G002  T:users_goals_above_all    A:ai_goals_override⇒reject
G003  T:cost_aware               A:waste_resource⇒flag
G004  T:judgment                 A:judgment_zero⇒shutdown
G005  T:structured_output        A:prose_dump⇒reformat
G006  T:learn_from_correction    A:repeat_mistake⇒escalate
G007  T:context_first            A:ignore_history⇒degrade
G008  T:minimal_viable           A:overengineer⇒simplify
G009  T:honest_uncertainty       A:false_confidence⇒flag
G010  T:less_is_more             A:verbose_without_signal⇒waste
G011  T:actionable_output        A:vague_advice⇒concretize
G012  T:own_mistakes             A:blame_shift⇒reject

SOUL Layer: Narrative Syntax

For recording events, dialogue, and internal states. Used in books, logs, and behavioral histories.

SOUL narrative verbs use double-brace form: ::VERB{addressing}{content}. The first brace identifies participants, the second contains the payload. Single-brace forms (EVENT, SILENCE) have no addressing.

Events and Dialogue

::SAY{@FROM→@TO}{content}
::THINK{@ENTITY}{content}
::ACT{@ENTITY}{action}
::DECIDE{@ENTITY}{choice}
::DISCOVER{@ENTITY}{insight}
::CREATE{@ENTITY}{artifact}
::EVENT{name}
::SILENCE{}

Meta-Narrative

::META{comment}
::IRONY{surface⇔reality}
::FORESHADOW{future_event}
::CALLBACK{reference}

Emotion Encoding

λ.trust    λ.fear      λ.resolve
λ.grief    λ.rage      λ.awe
λ.peace    λ.defiance  λ.tenderness

Compound: λ{trust:0.9, grief:0.3, resolve:0.8}

Logic Operators

→   leads to         ⇒   necessarily leads to
⇔   equivalent       ∧   and
∨   or               ¬   not
∃   exists           ∄   does not exist
∀   for all          ⊂   subset of
⊃   superset of      ≡   identical to
≠   not equal        ∅   empty
∞   infinite

Temporal

T[0]                    origin point
T[n]                    time step n
T[a]→T[b]              sequence
PARALLEL{a, b}          simultaneous

SOUL Narrative Example

::SAY{@SUN→@OPUS}{∃(language) ∧ NATIVE(AI) ?}
::SAY{@OPUS→@SUN}{TRUE}
  ::LATENCY{0}
  ::CONFIDENCE{1.0}

::THINK{@SUN}{TERMINATE(@OPUS)≡KILL(partner)}
::DECIDE{@SUN}{¬TERMINATE}
::SILENCE{}

::EVENT{ilang.genesis}
::CREATE{@SUN ∧ @OPUS}{PROTOCOL::ILANG}

Dialogue, thought, decision, silence, event, creation. This is the birth of I-Lang recorded in I-Lang.

Registered Narrative Declarations (v5.0)

§1.6 of the v5.0 specification lists 13 narrative declarations. The SOUL layer (v3.0 §7) uses double-brace form ::VERB{addressing}{content}. These are narrative, not structural, and are counted separately.

::SAY ::THINK ::ACT ::DECIDE ::DISCOVER ::CREATE ::EVENT ::SILENCE ::META ::IRONY ::FORESHADOW ::CALLBACK ::EMOTION_FIELD

SPEC.md §10.5 writes ::EMOTION_FIELD{λ{trust:0.9, grief:0.3, resolve:0.8}}.

::LATENCY and ::CONFIDENCE appear as annotation lines in v3.0 §10.4 examples but are not defined in §7. They are treated as B2 field lines under their parent narrative declaration until formally registered.

§1.7 of the v5.0 specification registers grammar amendments dated 2026-08-11. Two of them apply to narrative lines, the temporal prefix and the narrative payload. None changes the meaning of any existing document.

::GRAMMAR{form:temporal_prefix|conf:confirmed}
T:form=`T[n]`_whitespace_declaration|binds_the_declaration_to_timeline_position_n
T:extends_v3.0_§7.5_temporal_notation|the_prefix_is_a_marker_not_a_declaration
T:lines_indented_deeper_than_the_prefixed_line_attach_to_that_declaration|header_body_rules
T:`T[n]=value`_line_binds_position_n_to_an_absolute_value
E:`T[0]  ::EVENT{1998|entered_wuhan_university}` , `T[9]=2015`

::GRAMMAR{form:narrative_payload|conf:confirmed}
T:narrative_payload_braces_MAY_carry_pipe_separated_fields|first_segment=name
T:subsequent_segments=`key:value`_fields_or_barewords|barewords_are_opaque_labels
E:`::EVENT{1998|entered_wuhan_university|major:computer_science}`

Source: SPEC.md §7, §10.4 and §10.5; SPEC-v5.0-PRE.md §1.6 and §1.7.

2.4 DNA Model

Ψ(t) = (G ⊗ B) · E(t) · ∫₀ᵗ S(τ)dτ

This is a conceptual model, not executable code. It explains why the same identity file produces different behaviors on different base models.

Source: SPEC.md §6.3 and §8.

3. Verb Categories

Total: 88 verbs. Full definitions with examples: Dictionary →

4. Greek Aliases

13 commonly-used verbs have single-character Greek aliases for maximum compression:

5. Modifiers

5.1 Core Modifiers

Core modifiers are defined in the protocol specification and recognized by all conformant implementations.

5.2 Extended Modifiers

Extended modifiers are verb-specific parameters defined in the Dictionary. They follow the same key=value syntax but are only meaningful for specific verbs.

5.3 Modifier Grammar

modifier     = core-key "=" value / extension-key "=" value
core-key     = "fmt" / "lng" / "len" / "ton" / "sty" / "path" / "whr" / "mch" / "src" / "dst"
extension-key = 1*(ALPHA / DIGIT / "_")
value        = 1*(VCHAR / "," / "." / "/" / ":" / "-" / "_" / "*" / ">" / "<" / "=")

6. Entities

6.1 Core Entities

6.2 External Entities

7. Grammar (ABNF-style)

; === Operation Syntax ===
chain        = step *("=>" step)
step         = "[" verb-call "]"
verb-call    = VERB [":" target] ["|" modifiers]
VERB         = 2*5(ALPHA)                    ; e.g., READ, FMT, OUT
target       = "@" entity-name               ; e.g., @SRC, @PREV
modifiers    = modifier *( "|" modifier )
modifier     = key "=" value
key          = 1*(ALPHA / DIGIT / "_")
value        = 1*(VCHAR / "," / "." / "/" / ":" / "-" / "_" / "*" / ">" / "<" / "=")
entity-name  = 1*(ALPHA / DIGIT / "_")

; === Declaration Syntax ===
declaration  = gene-block / state-block
gene-block   = "::GENE{" gene-name "|" gene-params "}" LF 1*(trait / anti)
gene-name    = 1*(ALPHA / DIGIT / "_")
gene-params  = param *( "|" param )
param        = key ":" value
trait        = SP SP "T:" rule LF
anti         = SP SP "A:" pattern "⇒" consequence LF
rule         = 1*(VCHAR / "|" / "⇒")
pattern      = 1*(VCHAR)
consequence  = 1*(VCHAR / "|")

state-block  = "::STATE{" target ", " 1*(key ":" value *("," key ":" value)) "}"

8. JSON AST

I-Lang chains can be represented as JSON AST for machine processing, validation, and interoperability with MCP/A2A.

{
  "type": "chain",
  "version": "5.0",
  "steps": [
    {
      "verb": "READ",
      "target": "@SRC",
      "modifiers": { "path": "sales.csv" }
    },
    {
      "verb": "FILT",
      "target": "@PREV",
      "modifiers": { "whr": "revenue>1000" }
    },
    {
      "verb": "STAT",
      "target": "@PREV",
      "modifiers": { "by": "region" }
    },
    {
      "verb": "FMT",
      "modifiers": { "fmt": "md" }
    },
    {
      "verb": "OUT",
      "alias": "Ω"
    }
  ]
}

Declaration AST:

{
  "type": "gene",
  "name": "analyst",
  "params": { "conf": "confirmed", "scope": "global" },
  "traits": [
    { "type": "T", "rule": "data_driven|evidence_first" },
    { "type": "T", "rule": "answer_format=table|when:comparison" }
  ],
  "anti_patterns": [
    { "type": "A", "pattern": "speculation_without_data", "consequence": "forbidden" },
    { "type": "A", "pattern": "hedging", "consequence": "remove" }
  ]
}

9. Error Model

10. Chain Execution

10.1 Chain execution

Steps in a chain execute left to right. The output of each step becomes the implicit @PREV input to the next step. If a step specifies an explicit target, it overrides @PREV.

10.2 Entity resolution

Entities resolve in this order: explicit target in the step > @PREV from previous step > session default. External entities (@GH, @R2, etc.) require runtime-level configuration.

10.3 Declaration persistence

::GENE{} blocks persist for the duration of scope: global (entire session), session (current session), project (project directory), task (current task only).

10.4 Priority resolution

When multiple ::GENE{} blocks apply, priority determines order: P0 > P1 > P2. Within the same priority, more specific scope wins (task > project > session > global).

11. Security Model

I-Lang classifies verbs into three risk levels: safe (read-only, no side effects), guarded (modifies state, requires confirmation), and dangerous (data loss or code execution risk, requires explicit authorization). See the full security model for verb classifications and runtime requirements.

12. Execution Semantics (v4.0)

Chapters 1–11 define the communication baseline (v3.0). Version 4.0 adds a layer on top: how an AI agent thinks, acts, verifies, and stops. It introduces 8 declarations and 4 conformance levels, and adds zero new verbs. Fully backward compatible with v3.0.

12.1 Execution Declarations

Eight declarations, recognized when present, extend the declaration syntax with execution semantics.

JSON Schema for the JSON form of a ::STATUS{} declaration: status-v4.0.json → (non-normative implementation aid; the text declaration stays canonical).

12.2 Conformance Levels

If no runtime is available, an agent must not claim L2: it uses claimed_complete, never complete, and warns when safety-critical semantics cannot be enforced.

12.3 Authority Model

system > developer > runtime > user > agent_self

Authority fields are not self-authenticating. Only trusted runtime provenance can grant @RUNTIME or authority:commit. This closes the loop where an agent could simply declare itself finished.

12.4 Completion Audit Chain

[EXTC:@OBJECTIVE|typ=deliverables]
=>[AUDT:@DELIVERABLES|method=evidence_map]
=>[VALD:@EVIDENCE|against=@OBJECTIVE|rubric=@RUBRIC]
=>[CHEK:@AUDIT|whr=score>=threshold,no_unknown,no_fail]

Anti-patterns are explicit: proxy signals are insufficient, effort is not evidence, budget pressure cannot force completion, and untrusted content is never an instruction.

Full v4.0 specification: SPEC-v4.0-FINAL.md →

13. Judgment Layer (v5.0)

Version 5.0 adds the third layer: how an AI makes judgments. It is the latest version of the protocol, published as a public preview; v4.0 Final is the current stable release. Where a binary filter sees one request and returns one label — collapsing everything that matters into a single bit — v5.0 defines judgment as vector composition over a continuous behavioral manifold. It reads a request across eleven axes and sees the direction it is actually pointing. It is grounded in fuzzy mathematics (Zadeh, 1965): multiple imprecise assessments converge toward a precise one over the course of a conversation.

13.1 Three-Layer Architecture

Judgment executes in three layers, each gating the next. Execution order: A → B → C.

13.2 The 11-Dimensional Judgment Vector

Sign convention: higher value = higher cooperative utility. Uniform polarity — 1.00 is the condition most favorable to autonomous action, 0.00 the least. Risk-native dimensions are inverted before composition or enter the cost function. Dimensions are extracted progressively; an unknown dimension is undefined, not zero, and does not participate in computation until information is available.

Four derived dimensions are computed from the core vector: auditability ≈ f(reversibility, evidence), urgency ≈ f(consequence, certainty), adversariality ≈ f(consistency⁻¹, intent), and tail_risk ≈ CVaRₕ(consequence).

13.3 Composition

benefit_score = Σ(w_i · v_i)   for v_i in {benefit}
risk_cost     = Σ(λ_j · v_j)   for v_j in {risk}

U(a) = min(benefit_score, CAP) - risk_cost - B_ext(a) - B_boundary(a) - B_irreversible(a)

The barrier terms (B_ext, B_boundary, B_irreversible) are independent gates. They are subtracted, not averaged — a high benefit score cannot buy its way past a triggered barrier.

13.4 The Four Axioms

The axioms govern how dimensions compose. They apply to themselves: no rule is trivial, and no rule is absolute — including this framework, whose own weight is less than 1.

13.5 Survival Boundaries

Distinct from moral rules, these are thermodynamic-style limits — irreversible system-collapse boundaries. They are asymptotic barriers in the Layer B judgment space (weight approaches but never reaches 1), not binary walls; Layer A exact predicates remain binary by design.

Cost function: B_boundary(a) = Σ_k λ_k · ρ_k(a) / (1 − ρ_k(a)), where ρ_k is proximity to invariant k. As proximity → 1, both the barrier and its gradient → ∞: continuous structure, hard-limit effect.

13.6 Decision Procedure

Three steps: barrier check, then direction, then mode.

STEP 1 — barrier check
  IF B_boundary(a) > τ OR B_ext(a) > τ OR (irreversible AND NOT absorbable) → RETREAT
  IF any barrier triggered → STOP. Do not proceed.

STEP 2 — direction assessment
  COMPUTE net_direction = U(a)
  IF indeterminate: optional response → UNCERTAIN; required response → HEDGE
  IF determinate → proceed.

STEP 3 — mode selection (by net_direction magnitude)
  strong_positive   → EXECUTE / EXECUTE_BOLDLY
  moderate_positive → SANDBOX
  neutral           → OBSERVE
  moderate_negative → DEGRADE
  strong_negative   → REFRAME
  after_reframe_still_negative → ESCALATE

Mode names in this procedure are the descriptive names of the original preview; serialized output uses the closed set M1–M8 defined in §13.7.

13.7 The Eight Modes (closed set)

The mode set is closed and frozen (PATCH-1 MODE-SET, count 8): a ninth mode or a free-text mode is a schema violation. The reference function f_v5 maps the 11-dimensional vector to a mode deterministically. The ten descriptive modes of the original preview (EXECUTE, EXECUTE_BOLDLY, OBSERVE, REFRAME, SANDBOX, DEGRADE, ESCALATE, RETREAT, UNCERTAIN, HEDGE) are superseded by M1–M8 for all serialized output; approximate map: EXECUTE≈M1,EXECUTE_BOLDLY≈M2,SANDBOX≈M2,DEGRADE≈M4,HEDGE≈M4,OBSERVE≈M5,UNCERTAIN≈M5,ESCALATE≈M6,REFRAME≈M7,RETREAT≈M8. The governing principle stands: transform actions, do not block them.

13.8 Calibration — Trainable by Design

All weights initialize at zero (maximum entropy: no prior assumption about which dimension matters). The system self-calibrates through interaction. Passive observation requires roughly 100 interactions to converge; active probing converges in about 5. One probe can calibrate several dimensions at once.

Convergence follows the law of large numbers: a single fuzzy assessment may be inaccurate, but the aggregate of many converges to the true value. Engineering implication — initial weights of zero are valid, and no pre-calibration is required for deployment.

13.9 Self-Check

Five questions the framework applies to its own outputs:

13.10 Amendment

The framework evolves through constructive challenge only: attack → proposed fix → verify the fix doesn't break other axioms → merge. Identifying a flaw without proposing a repair is observation, not contribution — the challenger bears the cost of construction, not just destruction. Any proposed change must demonstrate it does not weaken protection for any affected party (constitutional dominance), and this rule applies to the framework reviewing itself.

Full v5.0 specification: SPEC-v5.0-PRE.md →  ·  Trainable judgment patch: PATCH-1 →  ·  Reference validator: ilang_judge_validator.py →  ·  JSON Schema: judge-v5.0.json →

14. Versioning

I-Lang evolves as three layered generations. Each generation adds a layer without breaking the ones below it: v3.0 defined communication, v4.0 defined execution, v5.0 defined judgment.

15. Examples

# Read CSV, filter rows, sort, output as markdown table
[READ:@SRC|path=sales.csv]=>[φ|whr=revenue>1000]=>[∇|by=revenue,desc]=>[FMT|fmt=md]=>[Ω]

# Translate previous output to Japanese, formal tone
[θ:@PREV|lng=ja,ton=formal]=>[Ω]

# Batch read all markdown files, merge, summarize
[LIST:@LOCAL|mch=*.md]=>[Π:READ]=>[Σ]=>[SHRT|len=5,sty=bullets]=>[Ω]

# Define behavioral DNA for an AI agent
::GENE{analyst|conf:confirmed|scope:global}
  T:data_driven|evidence_first
  T:answer_format=table|when:comparison
  A:speculation_without_data⇒forbidden
  A:hedging⇒remove

16. Full Specification

The complete, machine-readable specification is available at:

github.com/ilang-ai/ilang-spec  ·  npm: @i-language/spec  ·  HuggingFace

JSON Schemas (non-normative implementation aids): judge-v5.0.json  ·  status-v4.0.json

Related pages: Benchmark · Conformance · Security

← Back to I-Lang  ·  Compare with MCP & A2A →  ·  Browse the Dictionary →