Communicative Language Symbolism Routing (CLSR)

• CLSR is a test-time framework for LLMs that uses reusable Language Symbolism Frameworks (LSFs) to encode compact symbolic communication protocols.
• It employs an evolutionary synthesis process and a latent-free router to select and compose LSFs, optimizing both token cost and output accuracy.
• Empirical evaluations show CLSR achieves 3–6× token reduction over standard chain-of-thought methods while maintaining or enhancing performance across various benchmarks.

Communicative Language Symbolism Routing (CLSR) is a test-time framework for LLMs in which multiple agents autonomously invent, evolve, and share compact symbolic communication protocols—termed Language Symbolism Frameworks (LSFs)—and a latent-free router adaptively selects and composes these protocols per query to optimize the accuracy–token trade-off. Unlike prompt optimization, CLSR treats each LSF as a reusable symbolic protocol governed by compact symbols, a lightweight grammar, explicit usage rules, intended operations, and empirical performance profiles. The overall methodology enables significant reductions in token completions against standard chain-of-thought (CoT) prompting while preserving or enhancing accuracy across challenging reasoning tasks, as well as providing a formal mechanism for information-theoretic and algorithmic analysis (Pei et al., 28 Jun 2026).

1. Foundations: Language Symbolism Frameworks (LSFs)

An LSF is defined as a reusable symbolic protocol that an LLM agent can invoke at inference time. Each LSF is represented as a “card”:

$$S_k = (\mathcal{V}_k, \mathcal{G}_k, \mathcal{R}_k, \psi_k, \rho_k)$$

where:

• $\mathcal{V}_k$: Finite vocabulary (lexicon) of discrete symbols.
• $\mathcal{G}_k$: Lightweight grammar constraining symbol composition.
• $\mathcal{R}_k$: Well-formedness and usage rules (e.g., required termination symbols, variable bracketing).
• $\psi_k$: Mapping from symbols/templates to intended reasoning operations (e.g., $\langle \mathrm{ADD} \rangle$ for numeric addition).
• $\rho_k$: Empirical profile (token-cost statistics, accuracy estimates, domain tags, failure modes).

Messages generated under $S_k$ must conform to ($\mathcal{V}_k, \mathcal{G}_k, \mathcal{R}_k$), enabling consistent parsing and downstream composition by the router.

Token cost for a full CLSR inference is given by:

$$C = \sum_{t=1}^T \left(\, |r_t^{\mathrm{router}}| + \sum_{k \in I_t} |r_{t,k}|\, \right)$$

where $\mathcal{V}_k$0 and $\mathcal{V}_k$1 are tokens from the router plan and LSF responses, respectively.

Two central objectives are:

• $\mathcal{V}_k$2: Expected total token cost.
• $\mathcal{V}_k$3: Accuracy (probability of producing the correct output).

Trade-offs can be analyzed via the constrained optimization:

$\mathcal{V}_k$4

or by Pareto frontier scalarization:

$\mathcal{V}_k$5

2. Evolutionary Synthesis of Symbolic Protocols

CLSR’s offline phase employs an LLM-driven evolutionary loop to synthesize, evaluate, and refine a population of LSFs. This phased evolutionary loop includes:

• Initialization: Sample $\mathcal{V}_k$6 candidate LSFs using LLM synthesis on a partition $\mathcal{V}_k$7 of the training set.
• Evaluation: Run each LSF on subsequent partitions, recording prediction correctness and token cost for each trace.
• Selection: Apply Pareto filtering—favoring traces with highest accuracy, then minimal token cost.
• Mutation/Crossover: Use the LLM to refine or recombine selected LSFs and traces, aiming to preserve correctness while further minimizing token count.
• Elitism: Retain top-performing LSFs unchanged to avoid losing effective strategies.
• Stopping: Halt after validation accuracy saturates or a fixed number of generations.

This procedure produces a pool of LSFs well-adapted for efficiency and correctness on the downstream task.

3. Routing and Protocol Planning at Inference

At test time, a single LLM acts as a router, determining per-query protocol composition:

Stage 1 – Category Routing: The router emits domain category codes (e.g., ALG, PHY, QA), restricting the candidate LSFs to domain-matched subsets.

Stage 2 – Protocol Planning: For each query $\mathcal{V}_k$8, the router consults LSF cards to generate a plan in a domain-specific DSL, which includes:

• $\mathcal{V}_k$9: Mode (Single, Aggregate, Compose)
• $\mathcal{G}_k$0: Chosen LSF IDs
• $\mathcal{G}_k$1: Round specification (one-shot or multi-phase chains, e.g., PHY1>ALG1)
• $\mathcal{G}_k$2: Parallel sample count
• $\mathcal{G}_k$3: Aggregation rule (e.g., majority vote, self-consistency)
• $\mathcal{G}_k$4: Stopping criterion (validity check, confidence threshold)

The router deterministically executes the plan, invoking the relevant LSFs and aggregating outputs while accounting for all generated tokens. The router may choose to invoke a single LSF, ensemble several, or execute a composed multi-round protocol depending on task difficulty and cost-accuracy constraints.

4. Information-Theoretic Analysis and Program-Execution Subsumption

CLSR inference is formulated as a finite-horizon constrained Markov decision process (CMDP) over a finite token alphabet $\mathcal{G}_k$5.

Theoretical results include:

• Optimal Policy Existence: For any finite token budget $\mathcal{G}_k$6, there exists an optimal routing policy maximizing accuracy while not exceeding average token cost.
• Pareto Frontier Tracing: The accuracy–cost Pareto frontier can be traced via scalarized objectives as deterministic finite-horizon optimal policies, with mixtures of at most two policies sufficing.
• Lower Bound on Token Usage: For a query $\mathcal{G}_k$7, desired accuracy $\mathcal{G}_k$8 (error $\mathcal{G}_k$9), and output space $\mathcal{R}_k$0:

$\mathcal{R}_k$1

where $\mathcal{R}_k$2 quantifies the information-theoretic requirement for achieving accuracy $\mathcal{R}_k$3, and $\mathcal{R}_k$4 is the supremum of mutual information per token under any LSF.

• Program-Execution Pipeline Subsumption: Under the Interpreter-Realisability Premise (the LLM can emulate deterministic executors with bounded error and token overhead), any program-execution method with cost $\mathcal{R}_k$5 and accuracy $\mathcal{R}_k$6 can be matched by a pure-LSF CLSR protocol with cost $\mathcal{R}_k$7, accuracy at least $\mathcal{R}_k$8, and overhead only $\mathcal{R}_k$9 for short-answer tasks.

A plausible implication is that CLSR can, in some regimes, fully subsume intra-model generation-and-execution pipelines without requiring external code execution or model weight changes.

5. Empirical Evaluation: Benchmarks and Comparative Results

CLSR was evaluated across seven diverse benchmarks:

• MMLU-Pro (professional-level factual QA)
• GPQA-main (expert-level science QA)
• GSM8K (grade-school math)
• MATH500 (contest math)
• AIME 21–24 (hard multistep math)
• ScienceQA (short-answer science QA)
• HotpotQA (multi-hop reading QA)

Tested backbone models included Qwen3-8B, Qwen3-32B, LLaMA3-8B, and DeepSeek-R1-Qwen3-8B, with all models left frozen.

Baselines for comparison:

• Raw CoT, CoD, CCoT, SoT, PoT, PAL, P2S, PromptBreeder

Metrics: Query-level accuracy vs. average generated tokens (router and LSF outputs).

Key findings:

• CLSR achieved 3–6x token reduction compared to Raw CoT at matched accuracy, particularly on MMLU-Pro and GPQA.
• On hard math tasks, multi-round CLSR delivered additional accuracy gains (e.g., +2–3 percentage points), with moderate token cost increase.
• CLSR (T=3) outperformed PoT/PAL in the accuracy–token trade-off without using external code execution.
• Scaling experiments showed improved accuracy per token with larger agent populations and deeper offline evolution.
• Allowing adaptive routing rounds optimally balanced accuracy and token usage via instance-adaptive compute allocation.
• LSFs trained with one backbone also transferred to others with minor accuracy loss and retained token savings, suggesting the protocols themselves are model-agnostic to some degree.

Table: Representative CLSR Empirical Insights

Aspect	Empirical Result	Context/Significance
Token reduction	3–6× vs. Raw CoT	Marked drop in latency proxy for QA tasks
Accuracy at fixed cost	CLSR > baselines	Especially in hard mathematical reasoning
Transferability	Low drop across LLMs	LSFs maintain performance across backbones

6. Deployment Considerations, Limitations, and Directions

CLSR offers several deployment advantages:

• Offline Amortization: LSF pool synthesis requires several GPU-days, but amortizes across queries and is particularly suited for domain-specialized services.
• Cache-aware Serving: LSF cards can be cached as prefix prompts, with only router plan and solver tokens incurring decode cost per inference.
• Interpretability: LSF traces may not reflect model internals, but provide compact, algorithmically-scaffolded artifacts that can be easier to audit than traditional CoT outputs.

Limitations:

• CLSR requires training exemplars with explicit reasoning traces to synthesize LSFs.
• Effectiveness depends on the base model’s capacity for internalizing, interpreting, and composing new symbolic protocols.
• Performance may degrade on open-ended tasks or those requiring persistent world-state tracking across modalities.

Anticipated future work includes formalizing cross-modality LSF transfer, multi-agent protocol evolution in interactive environments, and automatic discovery of richer grammar constraints aimed at increasing per-token information $\psi_k$0.

7. Synthesis and Broader Implications

CLSR establishes that LLM agents can dynamically invent and refine compact symbolic “dialects”—Language Symbolism Frameworks—that, when adaptively routed, achieve significant token efficiency improvements and/or higher accuracy than purely natural-language or program-execution-based paradigms, with no model weight modifications and internalized symbolic reasoning (Pei et al., 28 Jun 2026). This architecture positions CLSR as a promising direction for test-time optimization in multi-agent LLM systems requiring both scalability and symbolic interpretability.