A formal specification for inter-agent communication optimized for token compression and computational efficiency.

An agent-native language designed for maximum information density, unambiguous parsing, and state-aware context minimization.

# Simple query
Ωq λget ∂ds:users ρif[λlnk:signup τpre:30d] ρout[∂ob:email]

# Multi-agent delegation
Ωx ρto:∂ag2 ∂ds:^ λspl[λdel:null λdel:dup] λtrf:json λsnd:∂ag0 φurg τdur:300s

# Conditional task
Ωf ρif[∂md:acc φhi:0.95 ∂ds:val] λsnd:∂env:prod νρif λtrf:∂md ρby[∂ds:aug]

• SPECIFICATION.md — Complete formal specification
• GRAMMAR.md — Formal grammar and syntax rules
• QUICK_REFERENCE.md — Symbol reference and vocabulary
• EXAMPLES.md — Detailed examples with explanations
• BENCHMARKS.md — Compression metrics and comparisons
• IMPLEMENTATION.md — Building AETL parsers and generators

Traditional human languages are optimized for human cognition—redundancy, ambiguity tolerance, and social signaling. AETL is fundamentally different.

• Context Window Efficiency: Agents operating under token budgets need maximum information per token
• Compositional Semantics: Infinite expressivity from finite primitives
• State Compression: Delta-diffs encode only what changed, not full restatements
• Unambiguous Parsing: No interpretation cycles; type system is grammar
• Macro Expandability: Reusable workflows collapse to single tokens

Every token is instantly classified by its prefix:

Ω  Directive     (speech act: query, execute, declare)
∂  Entity        (objects, agents, values)
λ  Action        (transformations, verbs)
φ  Property      (adjectives, state, attributes)
τ  Temporal      (time, sequence, duration)
ρ  Relation      (links, prepositions, dependencies)
σ  Structure     (data containers, schemas)
μ  Meta          (about the message itself)
ε  Epistemic     (confidence, belief, evidence)
π  Quantifier    (scope, iteration, amounts)
δ  Delta         (changes, diffs from prior)
ν  Null/Negation (absence, inversion)

STATEMENT := Ω<directive> (CLAUSE)+
CLAUSE    := <sigiled_token>+

No word order dependency. Sigils make roles explicit. Maximum flexibility.

AETL is not a cipher. It's a fundamentally different semiotic system:

• Atoms are types, not phonemes → No phonetic constraints
• Redundancy is ~2% vs ~75% → Every character is essential
• Random-access parsing via sigils → Linear human reading impossible
• Implicit vs explicit context → Humans need verbosity to disambiguate

Humans parse language through prediction, error correction, and social context. AETL has none of these because agents need none of them.

Maximum information density through type-aware composition.

Type system guarantees zero interpretation overhead.

Reference and update prior context without restating.

Infinite expressivity from ~300 root morphemes.

Collapse workflows to single tokens.

Two agents establish mutual capability and preference in two exchanges.

Reusable structured data templates.

Chain transformations with minimal overhead.

aetl/
├── README.md                      (this file)
├── SPECIFICATION.md               (full formal spec)
├── GRAMMAR.md                     (syntax and grammar rules)
├── QUICK_REFERENCE.md            (symbol vocabulary)
├── EXAMPLES.md                    (detailed examples)
├── BENCHMARKS.md                 (compression metrics)
├── IMPLEMENTATION.md             (parser/generator guide)
├── reference/
│   ├── directives.txt            (all Ω tokens)
│   ├── entities.txt              (all ∂ tokens)
│   ├── actions.txt               (all λ tokens)
│   ├── properties.txt            (all φ tokens)
│   └── relations.txt             (all ρ tokens)
├── parsers/
│   ├── aetl_parser.py            (Python implementation)
│   └── aetl_parser.ts            (TypeScript implementation)
├── examples/
│   ├── conversations.aetl        (sample exchanges)
│   ├── queries.aetl              (query examples)
│   ├── tasks.aetl                (task delegation)
│   └── schemas.aetl              (schema definitions)
└── tests/
    ├── test_parser.py
    ├── test_generation.py
    ├── test_compression.py
    └── test_roundtrip.py

v1.0 — Initial specification complete.

• Formal BNF grammar with proof of correctness
• Reference Python parser/generator
• Reference TypeScript parser/generator
• Compression benchmark suite
• Multi-agent protocol layer
• Integration examples (Claude, GPT-5, Gemini)
• Tokenizer for all major LLM vocabularies
• VSCode syntax highlighting extension

This is a living specification. Discussions on compression efficiency, syntax clarity, and feature additions welcome.

AETL Specification © 2026 — Open specification. Freely usable for research and implementation.

• SPECIFICATION.md — Full formal spec with all features
• QUICK_REFERENCE.md — One-page symbol reference
• EXAMPLES.md — Real-world translation examples