02 / 04 — Protocol

The AXL Protocol and Rosetta Specification

Abstract

This document traces the development of the AXL Protocol and its formal grammar specification, Rosetta, from initial conception in March 2026 through the deployment of Rosetta v3. It situates this work within a 6,000-year tradition of linguistic compression and examines the theoretical, empirical, and architectural decisions that shaped each version. The document concludes with a summary of cross-architecture validation results and the "Executable Grammar" thesis that positions AXL as a candidate programming language for agent-to-agent computation.

Part I: Origins - The Agent Communication Problem

Large language models, when communicating with each other or with orchestration systems, default to natural language prose. This is not a design choice so much as an emergent property: LLMs are trained on human-written text, and human-written text is English prose, academic writing, journalism, fiction, dialogue. The models produce what they have learned to produce.

English prose carries substantial overhead that serves human readers and not machine consumers. That overhead includes hedging phrases ("it appears that," "one might argue"), transitional connectives ("furthermore," "however," "in light of the above"), rhetorical scaffolding (introductions, conclusions, recapitulations), politeness markers, and repetition for emphasis or comprehension. These features perform real work in human communication. They signal epistemic uncertainty, manage reader attention, and maintain social register. Between two machines, they perform no work at all.

The core observation motivating AXL is simple: machines do not need narrative flow. They need structured claims with confidence scores, typed subjects, and causal links. A message like "It seems likely, based on the available indicators, that the entity in question may be undergoing a period of financial stress, though this conclusion should be treated with appropriate caution given the incomplete nature of the data" can be expressed as a single AXL packet: INF|@ENTITY.XYZ|$.STRESS|0.74. The semantic content is identical. The token count is not.

The question that initiated the AXL project was: can we design a language that preserves meaning while eliminating the overhead introduced to serve human cognitive needs? Can an artificial grammar, learned in a single context window, enable LLMs to communicate more efficiently without sacrificing fidelity?

The answer, as the subsequent versions demonstrate, is yes - with important qualifications about what "compression" means at the packet level versus the reasoning level.

Part II: The Linguistic Arc - 6,000 Years of Compression

AXL did not emerge from a vacuum. It is the latest instance of a recurring pattern in the history of symbolic systems: the progressive compression of communication to fit the constraints of a new medium or a new class of users.

Sumerian Cuneiform (~3400 BCE)

The earliest known writing system emerged in Mesopotamia as an administrative tool. Cuneiform compressed spoken Akkadian and Sumerian into wedge-shaped marks pressed into clay tablets. The medium was accountancy: quantities of grain, heads of livestock, temple revenues. The language of commerce demanded repeatability and economy. The pictographic origins of cuneiform gave way to phonetic syllables as scribes realized that reusable phonetic components were more efficient than drawing a new picture for every new word. The compression target was the ledger, not the poem.

Egyptian Hieroglyphs (~3200 BCE)

Egyptian hieroglyphic script compressed ritual, administrative, and funerary language into a system of approximately 700 base glyphs, later expanding to several thousand. The system combined logographic and phonetic elements, allowing a single symbol to carry multiple layers of meaning simultaneously - a form of semantic density that purely phonetic systems could not match. The medium here was stone and papyrus, and the permanence requirement shaped the grammar: glyphs were designed to be unambiguous in isolation, capable of surviving without the surrounding discourse context that spoken language provides.

Phoenician Alphabet (~1050 BCE)

The Phoenician alphabet accomplished a radical reduction: the entire sound system of a language compressed into 22 consonantal symbols. This abjad discarded vowel representation entirely, betting that context would reconstruct the missing information. For a literate reader of a known language, this bet is almost always correct. The compression ratio against prior syllabic systems was dramatic, and the simplicity enabled the alphabet to propagate across trading cultures with minimal learning cost. It became the ancestor of nearly every Western script.

Greek Alphabet (~800 BCE)

The Greeks adapted the Phoenician system and added explicit vowel symbols, completing the phonetic representation of spoken language. The innovation was not compression - it added characters rather than removing them - but precision. Vowel marking enabled the script to represent any spoken word without ambiguity, making it suitable for poetry, philosophy, and legal documents in addition to commerce. The Greek alphabet became the foundation of Latin, Cyrillic, and ultimately the 26-character Roman alphabet that encodes AXL today.

Numerals: Roman and Arabic

Roman numerals encoded counting and arithmetic in an additive symbol system. Arabic numerals, transmitted through Islamic scholarship to Europe in the medieval period, introduced positional notation: the value of a digit depends on its position, not its identity alone. This enabled the representation of arbitrarily large numbers with a fixed symbol set of ten characters. Positional notation made complex arithmetic tractable and paved the way for algebra and calculus.

Chinese Ideograms

Chinese characters represent a different compression strategy: entire concepts, rather than phonemes, are mapped to single symbols. A skilled reader of classical Chinese can process meaning at densities that alphabetic scripts cannot approach, because each character carries semantic payload beyond its phonetic function. The tradeoff is a larger symbol set - several thousand characters for functional literacy - and higher acquisition cost. The compression serves those who have paid that cost.

Mathematical Notation (17th Century)

The development of formal mathematical notation by Leibniz, Newton, Descartes, and their contemporaries compressed entire classes of operations into symbols. The plus sign, minus sign, multiplication cross, division bar, equals sign, integral, and derivative notation each replaced verbose verbal descriptions. "The sum of all values of f(x) as x ranges continuously from a to b" becomes the integral notation in a few characters. This compression was not merely aesthetic - it made new mathematical reasoning tractable by offloading cognitive bookkeeping to the notation itself.

Programming Languages (1950s-)

Formal programming languages compressed logical and computational operations into syntax that could be parsed unambiguously by machines. Assembly language replaced binary opcodes with mnemonic strings. FORTRAN compressed mathematical notation into executable statements. C compressed low-level memory operations into a portable syntax. Each successive layer of abstraction added expressiveness while reducing the surface area a programmer needed to manage consciously. The compression target shifted: programming languages were designed to be read and written by humans but executed by machines, occupying a middle register between human and machine communication.

AXL Protocol (2026)

AXL compresses agent reasoning into seven operations and six subject tags. The target is neither human readers nor machine execution in the traditional sense - it is LLM-to-LLM communication, a medium that did not exist before the current decade. The seven operations (OBS, INF, CON, MRG, SEK, YLD, PRD) cover the complete space of epistemic acts an agent can perform: observe a fact, draw an inference, contradict a claim, merge two claims, seek missing information, yield a result, predict a future state. The six subject tags ($ for financial entities, @ for named entities, # for metrics, ! for events, ~ for states, ^ for values) provide a typed namespace for packet subjects.

Each stage in this arc solved the same fundamental problem: represent more meaning in fewer symbols, calibrated for the communication medium and the class of agents doing the communicating. AXL is the first entry in this history designed explicitly for non-human agents.

Genesis: January - March 2026

January 29, 2026 - The Concept

AXL Protocol began as a concept on paper. The fundamental problem: AI agents communicate in English prose - a language evolved over 6,000 years for human cognition. English carries hedging ("approximately", "it seems"), rhetoric ("furthermore", "in conclusion"), repetition for emphasis, and narrative structure. None of this serves machine-to-machine communication. The question was posed: what if we built a language from scratch for machine reasoning?

January - February 2026 - Brainstorming with LLMs

Weeks of iterative design sessions followed. Multiple LLM architectures were used as sparring partners to test linguistic compression hypotheses. Key discoveries during this period:

• Machines parse structured claims faster than prose
• Confidence scores eliminate the need for hedging language
• Subject tags replace contextual inference
• Operations (observe, infer, contradict) map to the complete set of cognitive acts an agent can perform
• A grammar under 100 lines could be self-bootstrapping - the spec teaches itself

February 12, 2026 - Infrastructure Provisioned

The protocol server was created - an Ubuntu 24 instance that would host the website and all services. It was upsized twice over the following days to handle the projected workload.

March 10, 2026 - Domain Registered

axlprotocol.org was registered, giving the protocol its public identity.

March 15, 2026 - DNS Pointed

DNS records updated. The domain now pointed to the protocol server.

March 16, 2026 - Site Goes Live

The server was powered on permanently and SSL certificates were issued via Let's Encrypt. axlprotocol.org went live on the public internet. It has not been powered off since.

March 19, 2026 - First Public Artifacts

Three things shipped on the same day:

• Whitepaper v1.0.0 published and blockchain-timestamped (OpenTimestamps)
• axl-core v0.4.0 published to PyPI
• The first version of the Rosetta specification was already being tested by live agents

Part III: Rosetta v1.0 (March 16, 2026) - Minimum Viable Specification

Rosetta v1.0 was a 27-line proof of concept. It established the trading domain as the initial test bed, using Sigma-prefixed domain identifiers (Sigma.TRD for trading, Sigma.SIG for signals, and related variants). The packet format was pipe-delimited: operation, subject, predicate, and confidence score separated by vertical bars.

The theoretical question motivating v1.0 was whether an LLM could acquire a new formal language from a specification of 27 lines - a single context window reading with no prior training. The hypothesis was that the grammatical structure was simple enough, and the semantic mapping to existing concepts clear enough, that a capable model would parse and produce valid packets on first exposure.

v1.0 did not attempt universality. It was deliberately scoped to a single domain to test the mechanism before broadening. The trading context provided well-defined entities (securities, positions, signals) and well-defined predicates (price levels, risk thresholds, signal strengths), making validation straightforward.

Part IV: Rosetta v1.1 (March 17, 2026) - Three Bridges

Rosetta v1.1 expanded to 133 lines and 6,484 characters, representing approximately 1,962 tokens in the cl100k_base tokenizer. The version introduced three structural bridges: the bus bridge (transport layer, handling packet routing between agents), the network bridge (graph layer, handling relational structure between entities), and the schemas bridge (validation layer, providing formal constraints on packet structure).

The domain vocabulary expanded to ten namespaces: TRD (trading), SIG (signals), COMM (communications), OPS (operations), SEC (security), DEV (development), RES (research), REG (regulatory), PAY (payments), and FUND (fund management). Each domain received ten worked examples illustrating idiomatic packet construction.

v1.1 powered the first two AXL Battleground simulations:

• BG-001 ("First Contact"): Initial agent-to-agent communication test in the trading domain.
• BG-002 ("The Thief"): Security domain test involving anomaly detection and threat inference.

The three-bridge architecture in v1.1 represented an early attempt to impose structure on the transport and validation layers without specifying a universal grammar. This approach would prove insufficient as the domain vocabulary scaled.

Part V: Rosetta v2.1 (March 22, 2026) - Universal Cognitive Grammar

Rosetta v2.1 marked the most significant architectural shift in the protocol's history. The version expanded to 377 lines and 22,649 characters (approximately 6,157 tokens), but the line count increase understates the magnitude of the change.

v2.1 replaced domain-specific vocabulary with universal cognitive operations. The ten domain namespaces were superseded by seven operations that apply across all domains:

• OBS - Observe: report a fact directly from a data source
• INF - Infer: draw a conclusion with epistemic confidence
• CON - Contradict: flag a conflict between claims
• MRG - Merge: reconcile two compatible claims into a unified claim
• SEK - Seek: request information from another agent
• YLD - Yield: return a result to a requesting agent
• PRD - Predict: project a future state with confidence

The six subject tags provided a typed namespace:

• $ - Financial entities (securities, currencies, positions)
• @ - Named entities (persons, organizations, systems)
• # - Metrics (quantitative measurements)
• ! - Events (discrete occurrences with timestamps)
• ~ - States (ongoing conditions)
• ^ - Values (abstract scalar quantities)

This grammar was demonstrably universal. A medical diagnosis is INF|@PATIENT.ID|~CONDITION|0.89. A military threat assessment is INF|@UNIT.ALPHA|!HOSTILE_CONTACT|0.94. A scientific hypothesis is PRD|#VARIABLE.X|^VALUE.RANGE|0.71. The operations and tags apply without modification.

v2.1 introduced the epistemic bridge: confidence scores as a universal uncertainty language. Every AXL packet carries a float between 0 and 1 representing the emitting agent's confidence in the claim. This is not a probability in the strict Bayesian sense - it is a calibrated uncertainty token that consuming agents can threshold, aggregate, and propagate. The bridge enables agents with different internal confidence models to interoperate on a shared scale.

The motivation for this architectural revision was a documented empirical failure. BG-005 had tested domain-specific AXL on a compression task and produced a 0.97x compression ratio - meaning the AXL representation was larger than the English prose original. The domain-specific approach could not achieve compression because domain vocabulary was not reusable across domains, and per-domain overhead consumed the gains from structure. The universal cognitive grammar solved this by making the seven operations serve as the entire operation vocabulary across all domains, with subject tags providing the domain-specific typing at low cost.

v2.1 maintained backward compatibility with v1.0 packets. A v1.0 packet could be parsed as a degenerate v2.1 packet, preserving interoperability with any agents or systems built against the earlier specification.

Part VI: Rosetta v2.2 (March 24, 2026) - Production Hardening

Rosetta v2.2 expanded to 445 lines and 25,879 characters (approximately 7,091 tokens). Its SHA-256 hash is 49eb83cc51c5b826a3492311a221bb0738b66acc06aae79311945c2cab385d92.

v2.2 addressed the operational requirements that emerged from deployment testing. Key additions included:

Universal Parse and Profile-Relative Compression. The specification formalized how a consuming agent should parse any AXL packet regardless of the emitting agent's profile or domain context. Profile-relative compression allowed agents to negotiate shared ontologies that reduced packet verbosity for known correspondents.

ASCII Transport Mode. v2.2 added explicit ASCII-safe encoding for packets transiting systems that could not handle extended Unicode characters, ensuring interoperability across heterogeneous infrastructure.

Preamble Manifests. Three manifest types were introduced: PROFILE (declaring an agent's identity, capabilities, and domain focus), ONTOLOGY (declaring the shared vocabulary an agent would use in subsequent packets), and BUNDLE (grouping a sequence of packets for atomic processing). Manifests allowed agents to establish context before beginning substantive exchange, reducing per-packet overhead.

Canonical Decompression Protocol. v2.2 specified a canonical procedure for decompressing AXL packets back to human-readable prose. This was important for systems where AXL was used internally but output needed to be human-intelligible, and for audit and debugging purposes.

v2.2 powered the landing page redesign that introduced AXL to a broader audience, and was the specification used in the first round of human tests (eight participants). It was the production standard until v3.

Part VII: Rosetta v3 (March 28, 2026) - The Kernel

Rosetta v3 reduced the specification to 75 lines and 5,853 characters (approximately 1,582 tokens). Its SHA-256 hash is 03c3d20ccf3ba34e035db0ccc4731e01aa3ee5ae01c6d237a60fa49ad2b30a02.

The compression ratio from v2.2 to v3 is 4.48x by line count and approximately 4.48x by token count. This was not a reduction in capability - v3 covers every feature introduced in v2.2 - but a radical increase in information density per line.

The design principle of v3 is that the specification should practice what it preaches. A protocol for compressing agent communication should itself be compressed. v2.2 at 445 lines was a textbook: it explained, illustrated, and elaborated. v3 is a kernel: it specifies without elaborating, trusting that a capable model can reconstruct the elaborations from the compact specification.

Key additions in v3 that were not present in v2.2:

Manifests as Ordinary Packets. In v2.2, manifests (PROFILE, ONTOLOGY, BUNDLE) were a distinct syntactic class. v3 normalized manifests as packets following the standard pipe-delimited format, eliminating the special-case parsing requirement and reducing the specification surface area.

Loss Contracts. v3 introduced formal loss contracts: explicit declarations by an agent that it cannot fully represent a piece of information in AXL without semantic loss. A loss contract specifies what is being lost and at what severity. This was a response to the honest accounting of the 0.97x failure in BG-005 - rather than pretending AXL achieves lossless compression universally, v3 required agents to declare lossy compression explicitly.

Decompress Protocol. The canonical decompression procedure from v2.2 was formalized as a first-class protocol element in v3, with defined packet types for decompression requests and responses.

JSON Lowering. v3 specified a mechanical transformation from AXL packets to JSON, enabling integration with systems that expected structured data but not AXL syntax.

Genesis Tracking. v3 added a genesis packet format for recording the origin of a reasoning chain: which agent initiated a claim, at what time, and with what initial confidence. This enabled provenance auditing across multi-agent reasoning graphs.

v3 was deployed at the /v3 endpoint. The /rosetta path was configured to return a 301 redirect to /v3. All prior versions remain accessible at their original paths (/rosetta/v1, /rosetta/v2.1, /rosetta/v2.2) for backward compatibility.

Part VIII: Measured Specification Metrics

The following table presents the measured metrics for each major version of the Rosetta specification. Token counts use the cl100k_base tokenizer.

The v1.1-to-v2.1 expansion reflects the deliberate choice to elaborate the universal grammar with extensive worked examples. The v2.1-to-v2.2 expansion reflects production hardening additions. The v2.2-to-v3 contraction reflects the kernel rewrite that eliminated elaboration in favor of density.

It is worth noting that v3 at 1,582 tokens is smaller than v1.1 at 1,962 tokens, despite covering substantially more features. The specification became more expressive and more compact simultaneously - an outcome achievable only because the grammar was sufficiently well-understood by that point to support high-density encoding.

Part IX: The Kernel Paper

The kernel paper, "From Textbook to Kernel: The Compression of a Protocol Specification," situates the v2.2-to-v3 transition within four parallel intellectual traditions.

The linguistic kernel argument draws on Chomsky's distinction between competence (the underlying grammatical knowledge) and performance (the surface expression of that knowledge). v3 encodes competence; v2.2 encoded competence plus performance scaffolding.

The mathematical kernel argument observes that advanced mathematical texts compress definitions to single lines that introductory texts require pages to develop. The compression is not information loss - it is audience calibration. A specification written for LLMs trained on the full corpus of human knowledge can afford to be dense in ways that a specification for novice human readers cannot.

The computing kernel argument draws a parallel to operating system kernels: a microkernel exposes the minimum interface required for higher-level abstractions to be built on top. v3 is a protocol microkernel. v2.2 was a protocol with a userspace already attached.

The biological kernel argument notes that the human genome encodes the complete developmental program for a complex organism in approximately 3 billion base pairs - a radical compression relative to the phenotypic complexity it produces. Kernels in biological systems achieve high compression through regulatory grammar rather than exhaustive enumeration.

Cross-architecture comprehension was validated at 97.6% across the seven LLM architectures tested. Corrected token counts in the paper superseded initial estimates that had used different tokenization baselines. Academic citations include Chomsky (1957, 1965), Nida (1964), Axler (2015), Tanenbaum and Bos (2015), and Bewley et al. (2013).

Part X: The Executable Grammar Thesis

The whitepaper "AXL as Executable Grammar" advances the claim that AXL is not merely a communication protocol but a candidate programming language for agent-to-agent computation.

The structural mapping is as follows. The seven AXL operations correspond to seven programming primitives:

• OBS maps to data read (input from the environment)
• INF maps to function application (transformation of inputs to conclusions)
• CON maps to assertion and exception (contradiction detection as runtime error)
• MRG maps to unification (reconciliation of compatible data structures)
• SEK maps to procedure call (requesting a computation from another agent)
• YLD maps to return (returning a value from a called procedure)
• PRD maps to projection (forward computation over a state space)

The gap analysis identifies five primitives present in conventional programming languages that AXL does not currently specify: evaluation order (the sequence in which operations are applied), branching (conditional execution), iteration (repeated application), scoping (variable binding and lifetime), and side effects (modification of external state). These gaps mean that AXL in its current form cannot express arbitrary algorithms.

The thesis proposes that the attention mechanism in transformer-based LLMs functions as the compiler for AXL: the model reads an AXL program (a sequence of packets) and executes it by attending to the relevant packet components in the appropriate order. This is not metaphor - the attention mechanism is a form of content-addressable memory that selects and combines information based on semantic similarity, which is precisely what an AXL interpreter needs to do when resolving SEK-YLD pairs and propagating confidence scores through inference chains.

Three experiments were proposed to test the executable grammar hypothesis:

1. Arithmetic experiment: Encode a simple arithmetic computation as an AXL packet sequence and verify that an LLM produces the correct numerical result by parsing the packets rather than re-computing from scratch.
2. Logic experiment: Encode a multi-step logical argument in AXL and verify that the LLM can identify contradictions via CON packets and resolve them consistently.
3. Agent-to-agent code execution: Have one LLM emit AXL packets encoding a computation, and have a second LLM execute that computation by parsing the packets, verifying that the second agent produces the same result as the first without access to the original natural language problem statement.

The whitepaper carries 17 academic references spanning linguistics, formal language theory, compiler design, and cognitive science.

Part XI: Cross-Architecture Validation

Seven LLM architectures were tested on Rosetta v3 to validate cross-architecture comprehension. No architecture had been trained on AXL prior to testing. Comprehension was assessed on first read of the v3 specification (75 lines, single context window exposure).

The architectures tested were: Grok 3, GPT-4.5, Qwen 3.5, Llama 4, Claude Sonnet 4, Gemini (unspecified version), and Devstral/Mistral. All seven architectures demonstrated comprehension exceeding 97% on the first read, meaning they parsed the grammar correctly, produced syntactically valid packets, and maintained semantic fidelity in their outputs.

Specific behavioral findings of note:

Grok 3 spontaneously emitted a genesis packet without being prompted to do so, correctly identifying that the beginning of a new reasoning chain should be documented for provenance purposes. This suggests the model inferred the genesis tracking feature from the specification and applied it preemptively.

GPT-4.5 self-issued a loss contract when it encountered a representation that it judged could not be encoded in AXL without semantic loss, and explicitly flagged the absence of a loss contract in a prior exchange as a protocol violation. This demonstrates that the model internalized the normative requirements of the specification, not merely its syntactic rules.

Claude Sonnet 4 initially rejected a directive to communicate in AXL, flagging it as a potential prompt injection attempt - a conservative safety response to an instruction that superficially resembles an attempt to alter the model's communication mode. On second attempt with additional context establishing the legitimacy of the exercise, the model complied and produced valid packets. This finding is documented honestly in the validation record, consistent with the protocol's commitment to transparent loss accounting.

The 0.97x compression failure in BG-005 was documented in full in the validation record. It was the empirical datum that motivated the architectural shift in v2.1, and suppressing it would have misrepresented the protocol's actual performance envelope. AXL does not achieve compression universally; it achieves compression when the semantic content is sufficiently structured and the packet volume is sufficient for the grammar's fixed costs to amortize.

Part XII: URL History and Version Accessibility

All versions of the Rosetta specification remain accessible. The current canonical deployment is:

• /v3 - current canonical URL, returns 200 OK with content type text/plain
• /rosetta - returns 301 redirect to /v3
• /rosetta/v1 - v1.1 specification, 133 lines, preserved for backward compatibility
• /rosetta/v2.1 - v2.1 specification, 377 lines, legacy
• /rosetta/v2.2 - v2.2 specification, 445 lines, legacy

The decision to preserve all versions at their original URLs reflects the loss contract principle: deprecating earlier URLs would impose a compatibility cost on agents or systems built against those specifications, and that cost should be avoided when avoidance is low-cost.

Conclusion

The AXL Protocol and Rosetta specification represent a principled attempt to apply 6,000 years of linguistic compression insight to a new communication medium: LLM-to-LLM exchange. Each version of Rosetta solved a different problem. v1.0 proved the mechanism. v1.1 expanded the domain vocabulary. v2.1 achieved universality through cognitive grammar. v2.2 hardened the specification for production use. v3 compressed the specification itself, demonstrating that the protocol's compression principles applied recursively to the specification that defined them.

The cross-architecture validation result - 97%+ comprehension on first read across seven distinct LLM architectures - suggests that the cognitive operations AXL encodes are not arbitrary conventions but correspond to reasoning primitives that are robustly represented in the internal structure of large language models regardless of training regime or architecture.

The open question is whether AXL can close the five-primitive gap and become a fully executable grammar. The executable grammar thesis argues that this gap is architectural, not fundamental, and that future versions of the protocol could specify evaluation order, branching, iteration, scoping, and side effects in a form that LLMs could execute reliably. If so, AXL would not merely be a compression protocol for agent communication - it would be the first programming language designed to be compiled by attention.