[Research] LLMs already know how to communicate: AXL — 14 models, 91% error recovery, native structured instructions

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Multi-agent communication in Claude Code uses natural language between orchestrator and subagents. This is verbose (200–350 tokens per 5-step pipeline) and structurally ambiguous — when one model tells another to "create a file with authentication, making sure to include tests," the boundaries between action, target, and constraints are implicit.

This causes three measurable problems:

1. Token waste on inter-agent prose that no human reads
2. Silent task drift under error conditions (NL errors read fluently even when wrong)
3. No pre-execution validation — NL instructions can only be checked by another LLM at inference time

Proposed Solution

We built and evaluated a structured instruction protocol (AXL) that replaces NL between agents:

CRT|1=api.py|#code:lang:py{must:auth}{must:tests}

One line = one operation. Explicit action, target, type, constraints, references.

Evaluation (14 models, 7 developers, 761 runs)

| Metric | Result |
|--------|--------|
| Zero-shot parse accuracy | 95.0% (152/160 perfect, 14 models) |
| Error recovery (K4, N=22) | AXL 91% vs NL 36% (Fisher p=0.024, phi=0.57) |
| Input compression (K8, N=15) | 28–31% shorter with identical constraint compliance |
| Orchestration (K6, N=11) | All models produce valid pipelines, 2.2x compression |
| Generation accuracy | 4.95/5 (N=20, models WRITE valid AXL) |
| Response compression (K2) | NOT significant (Wilcoxon p=0.21) |

Claude-specific findings

• Sonnet: strongest response compression of any model (35% reduction)
• Haiku: 10/10 task completion with AXL vs 0/10 with NL on same benchmark
• Opus: one of only 3 models that execute AXL subagent commands

Critical limitation

Subagent execution fails in 7/10 models — terse AXL interpreted as confirmation, not execution (K6-B).

Paper (NeurIPS format), interactive presentation, 368 tests, and all data available — contact giperzvuk@gmail.com.

Alternative Solutions

Current alternatives for structured agent communication:

| Protocol | Layer | Limitation |
|----------|-------|------------|
| MCP (Anthropic) | Tool integration | Not a message format |
| A2A (Google) | Discovery/routing | No message compression |
| CodeAgents (arXiv:2507.03254) | Pseudocode | ~3.8x more tokens than AXL |
| Raw JSON | Data format | 100% comprehension but 43% larger, no constraints |

None address the message format layer between agents. AXL fills this gap.

Priority

Low - Nice to have

Feature Category

Performance and speed

Use Case Example

Scenario: Developer uses Claude Code with multi-agent orchestration (teams, subagents)

1. Orchestrator receives a task: "audit and fix security issues in the API"
2. Currently: orchestrator writes ~300 tokens of NL prose per subagent delegation
3. With AXL — same task in 5 lines, 147 characters, machine-parseable:

RD|1=src/app.mjs|#code
AUD|2=$1|#code{must:security}
FIX|3=$2|#code{must:minimal}
TST|4=$3|#code{must:node_test}
RPT|5=$2+$4|#text{must:summary}

1. The parser validates the pipeline before any model executes it — catching missing references, circular dependencies, contradictory constraints
2. Result: 91% error recovery (vs 36% NL), fewer wasted turns, deterministic dependency analysis

Additional Context

Paper: "LLMs Already Know How to Communicate Efficiently: AXL — A Native Protocol for Structured Agent Instructions" (NeurIPS format, PDF attached)

Author: Aleksey I. Zapolskiy, Independent Researcher, Perm, Russia
Contact: giperzvuk@gmail.com | Telegram: @giperzvuk

This research was conducted entirely on Claude Code over one month. The runtime ("Brain") with hooks, compression, and stigmergy has been in continuous production use — dogfooding AXL to build AXL.

• 761 experimental runs across 14 models from 7 developers
• Cross-model peer review conducted (Claude Opus, DeepSeek V3, Llama 4)
• 368 tests, formal EBNF grammar, all data reproducible

Repository access available on request (currently private, Apache 2.0 release planned within 30 days).

AXL_A_Native_Protocol_for_Structured_Agent_Instructions.pdf

presentation-final-en.html