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.

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.

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 a public preview — v4.0 remains the current stable version, and v5.0 is frozen for review while it is validated. 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

13.7 The Ten Modes

Preference order: REFRAME > SANDBOX > DEGRADE > UNCERTAIN > HEDGE > RETREAT. The governing principle: transform actions, do not block them. Refusing is the last resort, not the first instinct. Admitting uncertainty is preferable to forcing a judgment.

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 →

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

Related pages: Benchmark · Conformance · Security

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