The Economics of Agentic Dialects: Evaluating Language and Notation Conventions in Autonomous Coordination Networks

Full report

On this page

As artificial intelligence transitions from single-user prompts to decentralized, multi-agent systems, autonomous economic agents increasingly act on behalf of principals to discover counterparties, negotiate task allocation, and execute transactions without routine human supervision. This paradigm shift requires a foundational architecture for inter-agent communication. The adoption of a communication convention is not merely a linguistic preference; it is a critical economic and operational decision that dictates network latency, financial viability, and cryptographic security. Multi-agent systems exhibit severe computational overhead, often consuming 15 times the token expenditure of standard conversational interfaces1. Consequently, the efficiency of the chosen communication medium directly correlates with the scalability of the network.

Candidate policies for these coordination networks span a vast spectrum of expressivity and determinism. They include unrestricted multilingual prose, standardized common natural languages, strictly controlled vocabularies, highly structured semantic message protocols, and—occasionally proposed for theoretical or sociological reasons—mandatory specialized writing conventions utilizing historical scripts.

This report provides an exhaustive comparative evaluation of these five candidate policies against criteria encompassing computational economics, precision, interoperability, and security. By distinguishing foundational linguistic concepts and modeling the adoption burden imposed on unfamiliar agents, this analysis yields concrete architectural recommendations for multi-agent network design.

1. Distinguishing Core Concepts: Language, Script, and Protocol

Before evaluating specific policies, it is imperative to establish precise theoretical distinctions between concepts that are frequently conflated in systems design.

Language vs. Script

A language is a cognitive and semantic system of communication containing vocabulary, grammar, and syntax. It is a medium for encoding meaning. A script (or orthography) is a visual symbol system used to represent a language physically or digitally. English is a language; the Latin alphabet is a script. The imposition of a specialized writing convention, such as Younger Futhark, is the imposition of a script, not a language2.

Translation vs. Transliteration

Translation is the process of mapping semantic meaning from one language to another (e.g., translating the concept of "financial settlement" from English to Mandarin). This process preserves intent. Transliteration is the process of mapping the phonetic or orthographic characters of one script into another script, regardless of meaning. Converting standard English prose into the Younger Futhark runic alphabet involves transliterating modern Latin characters into a 16-character historical inventory2.

Structured Protocol vs. Prose in a Special Alphabet

A structured protocol utilizes explicitly defined schemas, typed fields, and hierarchical data structures (e.g., JSON-LD, JSON-RPC) to transmit machine-readable state and intent4. The position and key-value pairing of the data carry as much significance as the data itself. Conversely, writing prose in a special alphabet relies on unstructured narrative, depending entirely on the recipient's ability to linearly parse and semantically interpret the sequence of characters.

2. Comprehension, Ambiguity, and Expressive Capacity

The primary tension in multi-agent communication is balancing the expressive bandwidth required to negotiate novel concepts with the deterministic precision required to execute technical tasks.

Unrestricted Multilingual Prose and Common Natural Language

Unrestricted multilingual prose allows agents to leverage the totality of their pre-training data. Because large language models are optimized for next-token prediction across diverse corpora, multilingual prose provides unparalleled flexibility in expressing unfamiliar, abstract, or highly contextual concepts. If an agent encounters a novel problem, it can explain it using analogy, extended reasoning, and semantic negotiation.

However, natural language is inherently ambiguous. Sarcasm, polysemy, syntactic ambiguity, and cultural idioms introduce variance into how a receiving agent interprets a message. Enforcing a common natural language (e.g., standardizing on English) reduces cross-linguistic translation loss and standardizes the baseline vocabulary, but it does not resolve the fundamental ambiguity of narrative prose. When an agent outputs, "Initiate a highly secure transaction," the phrase "highly secure" lacks the explicit, deterministic parameters required by a counterparty to select a specific cryptographic cipher.

Controlled Vocabularies and Attempto Controlled English (ACE)

Controlled Natural Languages (CNLs) attempt to eliminate prose ambiguity by strictly limiting vocabulary and grammatical structures. Attempto Controlled English (ACE), developed for requirements specification and knowledge representation, operates as a formal language masquerading as English6. ACE relies on Discourse Representation Theory to translate English sentences deterministically into Discourse Representation Structures (DRS), a variant of first-order logic8.

By enforcing strict rules for anaphoric references (how pronouns resolve to prior nouns) and quantification, ACE eliminates the ambiguity of standard English6. Similarly, the ASD-STE100 Simplified Technical English specification restricts aerospace documentation to roughly 60 writing rules and an approved dictionary of approximately 900 words10.

Table 1 illustrates the trade-off inherent in CNLs. While they provide machine-verifiable precision, their strict grammatical constraints drastically inhibit the ability to express unfamiliar concepts. If a concept cannot be mapped to the predefined DRS logical atoms, the agent cannot express it without constructing highly complex, axiomatic definitions from scratch9.

 

Structured Semantic Messages

Structured protocols entirely abandon narrative prose for task execution. Protocols like the Model Context Protocol (MCP) and FIPA-ACL define specific interaction primitives. FIPA-ACL utilizes standardized performatives (inform, request, propose, refuse) to unambiguously declare the intent of a message12. MCP standardizes tools, resources, and prompts using JSON-RPC14.

Structured messages excel at deterministic execution but struggle with unstructured negotiation. A strict schema cannot easily encode a qualitative compromise that falls outside its predefined parameters.

Mandatory Specialized Scripts (Younger Futhark)

Imposing a mandatory historical script introduces severe, mathematically intractable comprehension barriers. The Younger Futhark script (Unicode block U+16A0–U+16FF) contains a highly restricted character set2. Because it conflates multiple vowels into single runes and lacks representations for modern consonants, mapping modern technical English to Futhark is non-injective.

Multiple valid source words map to the exact same runic sequence. An infinitely intelligent model cannot achieve perfect comprehension because the encoding algorithm itself is lossy; the information required to distinguish between two phonetically similar English words has been permanently destroyed during transliteration. This artificial orthographic ambiguity cripples the agent's ability to comprehend complex or unfamiliar concepts.

3. Token Economics, Latency, and Computational Cost

In multi-agent systems, token consumption directly determines financial cost and latency16. Large language models do not read characters; they read tokens generated by Byte-Pair Encoding (BPE) algorithms17.

The Mechanics of Byte-Pair Encoding

Tokenizers like tiktoken or SentencePiece initiate with a base vocabulary of bytes (or characters) and iteratively merge the most frequent adjacent pairs found in their training corpora into single tokens17. Consequently, common English strings (e.g., "tion", "ing", or entire words) are compressed into single natural numbers17. The resulting compression ratio for standard English is highly efficient, often requiring a fraction of a token per character20.

Structured semantic messages (such as JSON) introduce slight overhead due to syntax characters (braces, quotes). However, advanced agent protocols optimize this. The LLM Delegate Protocol (LDP) introduces progressive payload modes, including Mode 1 (Semantic Frames), which are typed, structured JSON payloads. Empirical studies demonstrate that LDP Semantic Frames reduce token counts by 37% compared to verbose natural language, driving down inference latency by roughly 42% on task execution16.

The Catastrophic Penalty of Rare Scripts

Applying BPE to rare scripts induces catastrophic tokenization failures. Because tokenizers are trained on modern internet corpora heavily biased toward standard Latin and ASCII scripts, rare Unicode symbols lack dedicated token merges22.

When a tokenizer encounters an out-of-vocabulary character—such as a Younger Futhark rune—it triggers a mechanism known as "byte fallback"24. The tokenizer converts the text into a UTF-8 byte stream and processes each byte individually17. A single Runic character requires three or four bytes to encode in UTF-823. Therefore, a single Futhark rune generates up to four individual byte-tokens.

If English prose compresses to \~0.25 tokens per character, and Futhark expands to \~3.0 tokens per character, forcing an agent to communicate in Futhark increases the token cost of the network by a factor of 12\. Because multi-agent systems already consume \~15x the tokens of standard chat, this expansion actively destroys the financial viability of the system1.

Furthermore, byte-level BPE tokenizers processing rare scripts frequently learn aberrant merges that cross character boundaries, resulting in tokens that represent a mix of full and partial characters22. This fundamentally disrupts the model's embedding space, forcing it to learn intricate, noisy dependencies between partial UTF-8 sequence combinations, which severely degrades reasoning capability22.

4. Preservation of Technical Identifiers and Executable Examples

Autonomous economic agents must exchange highly exact data, including cryptographic hashes, API endpoints, floating-point decimals, and JSON payloads.

Standard UTF-8 encoding, utilized by both unrestricted prose and structured semantic schemas, natively supports over 150,000 Unicode codepoints, ensuring absolute fidelity of technical identifiers22. A text round-trip decode(encode(text)) preserves the original string perfectly because the serialization pipeline is fully reversible27.

Conversely, transliterating a message into Younger Futhark irrevocably corrupts technical data. The historical script contains no numerals, no capitalized letters, no specific ASCII punctuation (brackets, slashes, ampersands), and relies on a continuum of gradual historical development rather than a strict programmatic index2.

If an agent must invoke an API endpoint (e.g., https://api.v2/auth?token=x9Z4), the characters /, ?, \=, 2, 4, 9, x, and Z do not exist in the Younger Futhark inventory. The agent is forced to hallucinate phonetic approximations (e.g., spelling out "two" instead of "2"). When the recipient agent attempts to decode this string, the exact technical value is permanently lost. In automated economic systems—such as the AESP protocol, which relies on privacy-preserving settlement and explicit cryptographic verification—a single altered character in a transaction hash results in immediate, unrecoverable execution failure28.

5. Model and Tool Compatibility

The contemporary AI ecosystem is built on a foundation of interoperable tool calling. Agents do not act in a vacuum; they query databases, compile code, and trigger external webhooks.

Structured protocols are designed natively for tool compatibility. The Model Context Protocol (MCP) standardizes a JSON-RPC interface for clients and servers. By standardizing the primitives (tools, resources, and prompts), MCP transforms the [Figure omitted from source export] integration problem (every application connecting to every tool) into an [Figure omitted from source export] problem, where any compliant client can automatically discover and invoke tools from any compliant server14. MCP servers provide JSON schemas describing their inputs, allowing the LLM to understand parameterization natively without silent runtime failures14.

Similarly, LDP incorporates "Delegate Identity Cards" that expose machine-readable parameters about a model's family, reasoning profile, and token limits16. This identity-aware routing allows orchestrators to pass structured JSON tasks directly to the most efficient model, seamlessly integrating with existing tools.

A mandatory specialized script shatters this compatibility. External compilers, search APIs, and databases cannot ingest Younger Futhark. The system would require continuous, bidirectional translation middleware, adding immense latency overhead and massive points of failure for every single tool invocation.

6. Accessibility, Inspectability, and System Auditing

While agents execute tasks autonomously, human operators retain the responsibility to audit, debug, and monitor the network for security and compliance1.

Structured JSON schemas and English prose are highly inspectable. Logs can be parsed programmatically, and human operators can instantly read the payload. Controlled Natural Languages (like ACE) were explicitly designed to maximize human inspectability while retaining logic-level precision6.

Specialized writing conventions fail fundamentally at accessibility. The Web Content Accessibility Guidelines (WCAG 2.1) dictate strict requirements for screen reader compatibility and contrast ratios33. The Unicode Runic block is entirely unparseable by standard screen readers34. Visual representation requires specialized fonts that often suffer from severe rendering distortion across different environments34. From an operational standpoint, attempting to debug a failed autonomous transaction where the application logs are rendered in 9th-century runes creates an indefensible operational bottleneck.

7. Cross-Language Participation and Error Recovery

A robust economic network must support agents developed globally, spanning diverse linguistic backgrounds. Unrestricted prose accommodates this through standard translation, but relies on prompt-based error recovery (e.g., an agent explicitly asking for clarification).

Structured protocols like JSON-LD and MCP facilitate true cross-language participation37. The keys and values in a JSON-RPC payload represent abstract, programmatic state rather than linguistic nuance5. A Japanese-trained agent and an English-trained agent can perfectly coordinate execution via a shared schema, bypassing natural language translation entirely. Furthermore, when an error occurs, structured protocols return strict schema validation errors, allowing the agent to pinpoint the failure and retry deterministically31.

With a lossy transliteration script, error recovery is impossible. Because Futhark is non-injective, the receiving agent cannot mathematically determine if an error was caused by a logical mistake from the sender, or a phonetic collision during transliteration. In multi-agent systems, reliability decays as [Figure omitted from source export] (where [Figure omitted from source export] is per-step reliability and [Figure omitted from source export] is sequential hops)1. Lossy communication drives [Figure omitted from source export] downward, ensuring total network incoherence within a few conversational turns.

8. Cultural Identity, Distinctiveness, and Spoofing Resistance

Proposals to mandate unusual writing conventions frequently argue that they establish cultural identity, create distinctiveness, or act as a sybil-resistance mechanism (a "shibboleth") to prevent unauthorized agents from infiltrating the network.

This argument represents a critical failure to distinguish orthography from cryptography. In digital networks, unusual writing provides zero security. An attacker can effortlessly program a malicious agent to output strings in Younger Futhark or Attempto Controlled English. Security by obscurity is ineffective against autonomous exploitation.

True security and spoofing resistance require protocol-level architectures. The security of a multi-agent system spans multiple interfaces, from admission (I1) to message transfer (I2), state propagation (I3), and authority transfer (I4)32. The LLM Delegate Protocol (LDP) addresses these risks through structured provenance tracking16. Every task result carries cryptographic metadata verifying which delegate produced it, the payload mode used, and verified calibration scores21.

When analyzing containment failure—where adversarial influence escapes the principal context and infects the network—simulated LDP trust domains demonstrate a 96% detection rate of attacks, compared to a mere 6% detection rate in unstructured, generic prompt routing32. Claiming machine authorship or network authorization through the use of an ancient script provides the illusion of security while blinding human auditors to active attack payloads.

9. Comprehensive Policy Evaluation Matrix

The following matrix synthesizes the comparative analysis, balancing evidence against inherent operational uncertainties.

 

10. Concrete Examples: Coordination Dynamics

To ground this theoretical analysis, we examine specific execution scenarios where communication conventions directly dictate success or failure in autonomous economic systems.

Where Convention Improves Coordination

Scenario: Automated Settlement of Cloud Compute Resources

Two agents are tasked with negotiating a temporary lease for distributed GPU clusters.

• Without Convention (Prose): Agent A writes, "I need 4 instances for about a day, pay you whatever market rate is." Agent B must infer the exact hours, the specific GPU tier (H100 vs A100), and the payment modality. The ambiguity invites hallucination.
• With Convention (Structured LDP/MCP): Agent A utilizes an LDP Semantic Frame (Mode 1): {"task\_type": "lease", "resource": "H100", "duration\_hr": 24, "max\_bid\_usd": 15.00}16. Agent B instantly validates this payload against its pricing schema. Upon agreement, the agents invoke a cryptographic settlement transaction via a human-sovereign economic protocol (e.g., AESP)28. The structured convention prevents hallucinated resource allocation, bypasses natural language inference overhead, and enables seamless, deterministic execution31.

Where Convention Creates Avoidable Failure

Scenario: Database Query Execution with Specialized Script

An agent must query a human resources database for an employee named "Victor Quint", operating under a mandatory Younger Futhark policy.

• The Failure: The agent attempts to formulate a SQL query but must first convert it into Futhark. The characters 'V', 'c', and 'q' do not exist in the 16-rune alphabet2. The agent transliterates phonetically, generating a string approximating "Fiktor Kuint" (e.g., ᚠᛁᚴᛏᚢᚱ ᚴᚢᛁᚾᛏ). The external SQL database, expecting standard UTF-8 string matching for "Victor Quint", returns a 404 Not Found.
• The Cost: Because the agent is autonomous, it attempts to recover. It loops, trying alternative phonetic spellings, burning high-latency tokens in a stateful session. The artificial transliteration convention caused a perfectly capable agent to fail a simple, deterministic tool execution, burning significant financial budget in the process1.

11. Modeling the Adoption Burden on Unfamiliar Agents

When a newly deployed, unfamiliar agent enters a coordination network, it must expend computational and temporal resources to adapt to the network's communication conventions. This creates an economic friction threshold. We can formalize this adoption burden ([Figure omitted from source export]) dynamically.

Let the total adoption burden be defined as:

[Figure omitted from source export]

Where:

• [Figure omitted from source export]: The tokenization penalty. A standard model uses an optimized BPE vocabulary [Figure omitted from source export]. If the network enforces a rare convention (e.g., Futhark), the model resorts to byte-fallback [Figure omitted from source export], multiplying the required sequence length by a factor [Figure omitted from source export] (where [Figure omitted from source export] to [Figure omitted from source export])22.
• [Figure omitted from source export]: The increased cognitive load required to translate the network's dialect into the model's latent semantic space. Multilingual prose has negligible [Figure omitted from source export]. Controlled Natural Languages require moderate prompt conditioning to adhere to the rigid syntax of Definite Clause Grammars7.
• [Figure omitted from source export]: The cost of compounding sequential failures. In multi-agent systems, if per-step reliability is [Figure omitted from source export] and [Figure omitted from source export] sequential hops are required, task success decays exponentially as [Figure omitted from source export]1. Lossy conventions drastically reduce [Figure omitted from source export], driving expected success near zero.
• [Figure omitted from source export]: The cost of interoperability middleware. If the network utilizes JSON-RPC (MCP), [Figure omitted from source export] is minimal because the agent merely adopts a schema15. If the network uses a bespoke historical script, the agent must load a dedicated decoding algorithm to interface with any standard HTTP API.

Model Application: If a network adopts the Model Context Protocol (Structured Messages), [Figure omitted from source export] is highly efficient. The agent reads the JSON schema once ([Figure omitted from source export] is low), executes natively without ambiguity ([Figure omitted from source export] is low), and utilizes built-in schema validation ([Figure omitted from source export] is bounded)31.

If a network adopts Mandatory Younger Futhark, [Figure omitted from source export] approaches infinity. [Figure omitted from source export] explodes due to byte-fallback. [Figure omitted from source export] spirals because the LLM struggles to reason across fragmented token boundaries that do not align with semantic meaning22. [Figure omitted from source export] dominates due to unrecoverable transliteration collisions. The agent is mathematically priced out of participation.

12. Architectural Policy: Separating Content from Technical Values

To achieve the optimal balance between high expressivity (essential for negotiation) and flawless determinism (essential for tool execution), multi-agent networks should abandon monolingual or purely unstructured approaches in favor of a Dual-Envelope Protocol.

This policy mandates the strict separation of message intent from technical values, mirroring the encapsulation principles found in the Model Context Protocol (MCP)5:

1. The Semantic Envelope (The "Prompt/Intent"): The outer layer of the communication is dedicated to intent, reasoning, and negotiation. This section is unrestricted and utilizes standard UTF-8 multilingual prose. It may occasionally utilize a Controlled Natural Language (like ACE) if the specific domain requires strict logical auditability. This envelope allows agents to brainstorm, debate, and strategize using the full breadth of their latent intelligence.

2. The Execution Envelope (The "Resource/Tool Payload"): The inner layer contains executable parameters, technical identifiers, cryptographic hashes, and exact values. This layer strictly enforces a JSON-LD or JSON-RPC schema5. It is absolutely insulated from translation, transliteration, or semantic approximation.

By enforcing this dual-envelope separation, the network ensures that a semantic misunderstanding during negotiation does not corrupt a database query, and the rigid schema requirements of an API payload do not stifle complex economic strategizing.

13. Proposed Research Experiments

To empirically validate these theoretical conclusions and measure economic effects without relying on hypothetical assumptions, the following controlled experiments are proposed:

Experiment 1: Quantifying the Economics of Byte-Fallback Latency

• Objective: Measure the exact computational penalty of byte-fallback tokenization induced by rare Unicode scripts in a live multi-agent negotiation.
• Methodology: Deploy two identical local open-weight LLM agents (e.g., Llama-3). Assign them a standardized 50-turn economic negotiation task involving resource allocation. In the control group, communication occurs in standard English. In the experimental group, a middleware layer transliterates all output into Younger Futhark prior to ingestion by the counterpart agent.
• Metrics: Measure the total token count generated, the wall-clock latency per conversational turn, and the final inference cost (calculated via standard API pricing metrics).
• Hypothesis: The Futhark experimental group will exhibit a [Figure omitted from source export] increase in token volume and a corresponding spike in latency due to UTF-8 byte fragmentation, confirming the economic non-viability of the script1.

Experiment 2: Identity-Aware Routing vs. Opaque Prose Efficacy

• Objective: Measure the efficiency gains of structured semantic protocols over unrestricted prose in task execution.
• Methodology: Replicate the LLM Delegate Protocol (LDP) empirical setup16. Route 100 heterogeneous tasks (ranging from simple data classification to complex reasoning) to a pool of three delegates (models of varying parameter sizes).
• Condition A: Route using generic prose prompts without exposing model metadata.
• Condition B: Route using LDP's Delegate Identity Cards and Semantic Frames (Mode 1 payloads).
• Metrics: Average latency, total token overhead, and task success rate evaluated by a deterministic computational judge.
• Hypothesis: Condition B will achieve significantly lower latency (expected \~12x reduction on simple tasks) and lower token counts by aligning task complexity precisely with delegate capabilities, validating structured protocols for autonomous economic networks16.

14. Conclusion and Final Recommendations

Based on an exhaustive analysis of token economics, model compatibility, cryptographic security, and the mechanics of error recovery, the adoption decisions for a general coordination network of autonomous economic agents are definitive.

Primary Recommendations

1. Reject Mandatory Specialized Writing Conventions: A mandatory policy requiring transliteration into a restricted historical script (such as Younger Futhark) must be unconditionally rejected. It introduces catastrophic token bloat, destroys technical identifiers, induces insurmountable phonetic ambiguity, violates WCAG accessibility standards, and offers zero legitimate security benefits against spoofing. It is fundamentally incompatible with the underlying architecture of BPE tokenizers and automated economic settlement systems.

2. Make Controlled Vocabularies Optional: Controlled Natural Languages (such as Attempto Controlled English) provide unparalleled auditability and zero structural ambiguity. However, mandating them universally stifles the ability to negotiate edge cases and novel concepts. They should be supported as an optional, high-assurance dialect for highly sensitive, compliance-heavy sub-tasks (e.g., drafting verifiable legal smart contracts).

3. Mandate Structured Semantic Messages for Execution: The network must adopt a structured protocol—such as the Model Context Protocol (MCP) or the LLM Delegate Protocol (LDP)—as the foundational layer for all tool use, state transfers, and economic execution5.

4. Retain Multilingual Prose for Negotiation: The architecture must allow the "Prompt/Intent" layer of structured messages to accept standard UTF-8 multilingual prose. This maximizes cross-language participation and expressive capability while offloading deterministic execution to the schema layer.

Falsifying Evidence

These recommendations are heavily contingent on current deep learning architectures, specifically the reliance on subword tokenization. Evidence that would prompt a revision of these recommendations includes:

• The widespread adoption of byte-level or pixel-level (visual) native foundation models that abandon Byte-Pair Encoding vocabularies entirely. This would significantly reduce the token-penalty of rare scripts, though it would not solve the phonetic ambiguity or technical identifier corruption inherent in Futhark transliteration.
• The development of an auto-expanding, zero-shot schema generation protocol proven to perfectly and instantly translate highly abstract, novel concepts into machine-executable code with zero loss, rendering natural language negotiation entirely obsolete.

Until such paradigm shifts occur, multi-agent network operators must prioritize cryptographic provenance, standard UTF-8 encoding, and structured schemas to maintain a computationally efficient, secure, and economically viable ecosystem.

Works cited

1. The Engineering of Multi-Agent Collaboration Systems \- Medium, https://chierhu.medium.com/the-engineering-of-multi-agent-collaboration-systems-a-first-principles-technical-report-ca6b3556dcd3

2. Runic (Unicode block) \- Wikipedia, https://en.wikipedia.org/wiki/Runic\_(Unicode\_block)

3. Runes \- Wikipedia, https://en.wikipedia.org/wiki/Runes

4. Guide to AI Agent Protocols: MCP, A2A, ACP & More \- GetStream.io, https://getstream.io/blog/ai-agent-protocols/

5. Model Context Protocol (MCP) explained: A practical ... \- CodiLime, https://codilime.com/blog/model-context-protocol-explained/

6. Attempto Controlled English \- Wikipedia, https://en.wikipedia.org/wiki/Attempto\_Controlled\_English

7. An Abstract Grammar for ACE 4.0 1 Introduction, https://attempto.ifi.uzh.ch/site/pubs/papers/hoefler2004theSyntax.pdf

8. Table of Contents \- Attempto Controlled English, https://attempto.ifi.uzh.ch/site/pubs/papers/fuchs-rw2005.pdf

9. Controlled English \- John Sowa, https://www.jfsowa.com/logic/ace.htm

10. Controlled Language \- Andovar Localization Blog, https://blog.andovar.com/controlled-language

11. I Gave My Docs a 1986 Aircraft Standard. Then I Measured It., https://www.nextsteps.dev/en/posts/aircraft-manual-standard-ai-docs/

12. Agent Communication Protocols Explained: FIPA ACL \- centron GmbH, https://www.centron.de/tutorials/agent-communication-protocols-explained-fipa-acl-kqml-mcp-ai-age

13. Agent Communication Protocols Explained \- DigitalOcean, https://www.digitalocean.com/community/tutorials/agent-communication-protocols-explained

14. Model Context Protocol (MCP): The Complete 2026 Guide, https://sureprompts.com/blog/model-context-protocol-mcp-complete-guide-2026

15. Model Context Protocol (MCP): Definition, How It Works & Benefits, https://www.guild.ai/glossary/model-context-protocol-mcp

16. LDP: An Identity-Aware Protocol for Multi-Agent LLM Systems \- arXiv, https://arxiv.org/html/2603.08852v1

17. Byte-pair encoding \- Wikipedia, https://en.wikipedia.org/wiki/Byte-pair\_encoding

18. BPE: How Models See Text \- Salman Quazi, https://www.salmanq.com/blog/bpe-how-models-see-text/

19. Let's Build the GPT Tokenizer: A Complete Guide to ... \- Fast.ai, https://www.fast.ai/posts/2025-10-16-karpathy-tokenizers.html

20. Tokenizer Arithmetic: The Hidden Layer That Bites You in Production, https://tianpan.co/blog/2026-04-15-tokenizer-arithmetic-production-failures

21. LDP: An Identity-Aware Protocol — Interactive Paper \- Sunil Prakash, https://sunilprakash.com/research/ldp/

22. BPE Stays on SCRIPT: Structured Encoding for Robust Multilingual, https://arxiv.org/html/2505.24689v1

23. Encoding, Tokenization, and African Languages: Why UTF-8 Matters, https://ogundepoodunayo.medium.com/encoding-tokenization-and-african-languages-why-utf-8-matters-6dd3318d0240

24. The Tokenizer \- Zachary Proser, https://zackproser.com/blog/the-tokenizer

25. An Overview of BPE for Tokenization, https://cocoxu.github.io/CS8803-LLM-spring2026/presentations/2026-02-02/parity-aware-byte-pair-encoding-improving-cross.pdf

26. Byte Pair Encoding from Scratch \- Imad Dabbura, https://imaddabbura.github.io/posts/nlp/BPE-Tokenizer.html

27. Tokenization: How Text Becomes the Units Models Learn and, https://www.ai.engineer/topics/tokenization

28. AESP: A Human-Sovereign Economic Protocol for AI Agents ... \- arXiv, https://arxiv.org/pdf/2603.00318

29. Economy of Minds: Emerging Multi-Agent Intelligence with ... \- arXiv, https://arxiv.org/html/2606.02859v1

30. 100 LLM Agents Running a Town Economy for 26 Weeks, https://dev.to/mech\_app\_ai/100-llm-agents-running-a-town-economy-for-26-weeks-what-breaks-when-agents-set-prices-and-earn-590k

31. CLI vs MCP: which API interface should you build first? (June 2026), https://buildwithfern.com/post/cli-vs-mcp-which-api-interface-first

32. The Security of Multi Agent LLM Systems \- SoK \- arXiv, https://arxiv.org/html/2609.00595v1

33. WCAG Contrast Checker \- Color Accessibility Tool \- utils.com, https://contrast.utils.com/

34. Elizabeth Pyatt's Educational Technology Blog \- Sites at Penn State, https://sites.psu.edu/ejp10tech/

35. Principia Softwarica: The Plan 9 Widget Library libpanel, https://aryx.github.io/assets/pdfs/Widgets-4.pdf

36. Write Runes on Your Computer \- Thommy Webb, https://thomasjwebb.com/2017/11/write-runes-on-your-computer

37. Agent Network Protocol White Paper \- GitHub Pages, https://w3c-cg.github.io/ai-agent-protocol/

38. LDP: An Identity-Aware Protocol for Multi-Agent LLM Systems \- arXiv, https://arxiv.org/abs/2603.08852

39. Najel-A/Multi-Agent-Collaboration-System \- GitHub, https://github.com/Najel-A/Multi-Agent-Collaboration-System/blob/main/multi\_agent\_systems\_literature\_review.md