LIACL -- Inter-Agent Compression Language

Version: 1.1 Origin: PureBrain.ai Status: Validated -- 53-68% token savings, 100% information fidelity Portable: Yes -- any multi-agent system can adopt this skill Changelog: v1.1 adds memory snippet compression + progressive disclosure integration (see Section 8)

What This Is

LIACL (pronounced "lye-uh-kel") is a structured message protocol for agent-to-agent communication that reduces token consumption by 55-72% while preserving 100% information fidelity.

Instead of verbose natural language dispatches between agents, LIACL uses shortcodes, reference pointers, and a header-values pattern inspired by TOON format, Google A2A Protocol, and AgentPrune (ICLR 2025).

Why it matters: In a multi-agent system, inter-agent communication is the single largest drain on context budget. A typical task dispatch consumes 800-2,500 tokens in natural language. LIACL reduces that to 250-700 tokens with zero information loss. Over a session with 40+ agent messages, that's 6,800-13,600 tokens saved -- enough for 1-2 additional full agent interactions before context compaction.

Quick-Reference Card (~120 tokens)

Paste this into any agent prompt to enable LIACL:

## LIACL v1.0 Quick Reference

You understand the Inter-Agent Compression Language (LIACL).
Messages use: @MSG {TYPE} {PRIORITY} {TIMESTAMP} / FROM:X TO:Y / body / @END

Types: TASK (dispatch), STAT (status), RSLT (result), ESCL (error)
Priority: P1(critical) P2(high) P3(normal) P4(low) P5(idle)

Operations: CRT(create) UPD(update) RSC(research) ANL(analyze)
  FIX(fix) TST(test) DPL(deploy) INT(integrate) GEN(generate)
  SYN(sync) RPT(report) OUT(outreach) DRF(draft) PUB(publish)
  DEL(delete) OPT(optimize) DOC(document) MON(monitor) CFG(configure)
  SCN(scan) ARC(archive) ENR(enrich) FLT(filter) SCH(schedule)

Errors: E-AUTH E-RATE E-COST E-DEPS E-DATA E-TOOL E-API E-HUMAN

Refs: mem: del: tool: cred: cfg: gdoc: gsheet: task:

Protocol Design

Message Structure

Every LIACL message follows this pattern:

@MSG {type} {priority} {timestamp}
FROM:{sender} TO:{receiver}
---
{body fields per message type}
---
@END

Four Message Types

Priority Levels

Timestamps

Format: YYYYMMDD-HHMM (24hr, UTC assumed unless noted)

Shortcode Reference

Operations (30 codes)

Common Domains (18 codes)

These are platform/tool shortcodes. Extend this list with your own domains.

Agent/Role Codes (Extensible)

Base roles that apply to any multi-agent system:

Error Codes (15 codes)

Context Compression

Reference Pointers

Instead of inlining content, reference it:

CTX Block

Group context references at the top of a message body:

CTX: cred:service-account.json | tool:signal_engine.py | gsheet:1REbSQpb...

Message Templates

TASK Dispatch

@MSG TASK P3 20260227-1400
FROM:PRI TO:SAL
---
OP: RSC+ANL
DOMAIN: LI
OBJ: Find 10 CPG brand managers at target companies
CTX: gsheet:1Fw0XtXX... (Companies tab) | tool:signal_engine.py
CONSTRAINTS: LinkedIn only, director+ seniority, US-based
OUT: gsheet update + summary
---
@END

STAT Update

@MSG STAT P3 20260227-1430
FROM:SAL TO:PRI
REF:task:#42
---
STATE: WORKING
PROGRESS: 6/10 profiles found
BLOCKED: None
ETA: 30min
---
@END

RSLT Return

@MSG RSLT P3 20260227-1500
FROM:SAL TO:PRI
REF:task:#42
---
STATE: DONE
SUMMARY: 10 CPG brand managers identified, emails verified for 7/10
OUTPUT: gsheet:1Fw0XtXX... (People tab, rows 103-112)
METRICS: 70% email hit rate, 3 VP-level, 4 Director, 3 Manager
NEXT: Recommend P3 OUT sequence via IN
---
@END

ESCL Escalation

@MSG ESCL P2 20260227-1545
FROM:BD TO:PRI
REF:task:#8
---
ERR: E-AUTH
STATE: BLOCKED
DESC: Service account delegation returning 403 on write
TRIED: Token refresh, 3 retries, scope verification
NEED: Admin to verify delegation
IMPACT: Task queue not updating, team visibility blocked
---
@END

Before/After Examples

Example 1: Simple Task

BEFORE (287 tokens):

Hey Backend Dev team, I need you to update our task queue Google Sheet. The sheet ID is 1REbSQpbKKdu3OQGcQBnpqXdMI. Please go to the Tasks tab and update row 39 (task E-4) to mark it as DONE. The credentials for Google Sheets access are in the service account file, and you'll need to use domain-wide delegation. After updating, please confirm the change was successful and report back.

AFTER (89 tokens):

@MSG TASK P3 20260227-0900
FROM:PRI TO:BD
---
OP: UPD
DOMAIN: GS
OBJ: Mark E-4 DONE in Tasks tab row 39
CTX: gsheet:1REbSQpb... | cred:service-account.json
AUTH: delegate
OUT: confirmation
---
@END

Savings: 69%

Example 2: Complex Research

BEFORE (412 tokens):

Research team, I need a comprehensive analysis. We're looking at enterprise CPG companies that might be good targets for our experiential marketing services. I need you to research the top 10 mid-cap CPG companies (between $1B and $20B market cap) that have recently shown signals of investing in experiential or consumer activation marketing... [continues with detailed instructions about sources, output format, timeline, etc.]

AFTER (118 tokens):

@MSG TASK P2 20260227-1000
FROM:PRI TO:RES
---
OP: RSC+ANL
DOMAIN: LI+UP
OBJ: Top 10 mid-cap CPG ($1-20B mcap) with experiential marketing signals
SOURCES: Google News, LinkedIn posts, earnings calls, job postings
CRITERIA: Recent experiential/activation spend, new CMO/VP Marketing, agency RFPs
OUT: Ranked list with company, signal, contact, rationale
DEADLINE: EOD
CTX: mem:knowledge/ecosystem-overview.md | del:top-10-target-accounts.md
---
@END

Savings: 71%

Token Savings Summary

Cumulative Session Impact

At 200K context window, heavy session savings = ~7% of total context = 1-2 additional full agent interactions before compaction.

Stress Test Results

6 tests conducted, all PASSED:

How to Adopt

Step 1: Add Quick-Reference Card to Agent Prompts

Paste the ~120 token Quick-Reference Card (from the top of this file) into your agent system prompts or team lead manifests.

Step 2: Start Emitting LIACL from Your Conductor

When your primary/conductor agent dispatches tasks, use LIACL format instead of natural language. Agents that have the Quick-Reference Card will parse it immediately.

Step 3: Extend Domain Codes

Add domain codes specific to your stack. The 18 base codes cover common platforms; add codes for any tools unique to your system.

Step 4: Extend Entity Shortcuts

Create shortcuts for your frequently-referenced resources:

# Example entity shortcuts (customize per system)
TQ = Task Queue Sheet
WF = Working Folder
SE = Signal Engine
SA = Service Account credentials

Step 5: Validate

Run a few LIACL messages through your agents and verify:

• Agents can parse the format without confusion
• No information is lost in compression
• Response quality is identical to natural language dispatches

Design Principles

1. Declare once, reference forever -- Field names in headers, not repeated per-value
2. Shortcodes for the 80% -- The 30 most common operations get 2-4 character codes
3. Context by reference -- Point to files/paths instead of inlining content
4. Structured, not conversational -- Remove filler, hedging, and explanation of the obvious
5. Extensible -- Any system can add domain codes, role codes, and entity shortcuts
6. Zero training required -- Any LLM agent reads this spec and can immediately parse/emit

Research Lineage

LIACL draws from:

Section 8: Memory Snippet Compression (v1.1)

LIACL v1.0 compressed agent-to-agent messages. v1.1 extends the same techniques to memory retrieval, reducing token cost when memories are injected into agent context.

The Problem

Memory systems serve full files (~200-800 tokens each). An agent searching a keyword might load 10 results = ~7,600 tokens. Most of that content is irrelevant to the current task.

Memory Compression Techniques

Technique 1: Progressive Disclosure Integration

Memory search returns LIACL-compressed index entries instead of full files:

@MEM-INDEX "linkedin" 10 results
---
1. feedback_post_via_browser_not_api.md | ~180tok | browser>API, less throttle
2. feedback_no_duplicate_agents.md | ~120tok | 1 agent per branch
3. reference_automation_restored.md | ~340tok | profile restored, cookie ok
...
---
@END

Agent fetches only what it needs: @MEM-FETCH 1,3 (loads 520 tokens instead of 7,600).

Technique 2: Caveman-Speak for Memory Snippets

When injecting mandatory memories (auto-guardrails), compress the content:

Compression rules:

1. Drop filler words (the, a, an, instead, you must, when, etc.)
2. Use shortcodes for known domains (EM=email, LI=LinkedIn, GD=Drive)
3. Keep proper nouns and file paths exact
4. Keep the "why" (incident reference) -- attention anchors
5. Target: 70-80% reduction per snippet

Technique 3: CTX Blocks for Memory References

When an agent needs to pass memory context to another agent, use CTX pointers instead of inlining the memory content:

@MSG TASK P3 20260605-1400
FROM:PRI TO:WEB
---
OP: UPD
DOMAIN: EM
OBJ: Fix newsletter images
CTX: mem:feedback_email_images_rehosted.md | mem:feedback_own_mistakes.md
NOTE: MEM-COMPRESSED: EM-IMG=rehost-CDN, OWN-ERR=lead-w-ownership
---
@END

The receiving agent reads the CTX files only if it needs full context. The NOTE line gives a compressed hint so it may not need to read at all.

Attention Management

More tokens = harder for the model to focus. Compression is not just about cost -- it is about attention quality:

• Compressed snippets reduce noise in the attention window
• Critical information with unique phrasing ("NEVER", specific file names, incident dates) gets higher attention weight
• Filler words dilute attention across non-informative tokens

Label critical info explicitly (additive attention):

• CRITICAL: prefix for must-not-violate rules
• INCIDENT: prefix for learned-the-hard-way lessons
• File paths and error codes verbatim (model attends to specifics)

Strip noise (subtractive attention):

• Remove hedging ("you should consider", "it is recommended")
• Remove re-explanations of obvious context
• Remove transition phrases between bullet points

Token Savings with Memory Compression

Quick Reference: Memory Compression Shortcodes

Add to LIACL Quick-Reference Card when using memory compression:

## Memory Compression (LIACL v1.1)

@MEM-INDEX "query" -- compressed memory search results
@MEM-FETCH N,N -- fetch specific results by rank
MEM-COMPRESSED: -- inline compressed memory hint in NOTE field

Compression: drop filler, use domain codes (EM/LI/GD/WP),
keep proper nouns + paths + incident refs exact.
Target: 70-80% reduction per snippet.

Created by PureBrain.ai. Open for community adoption, extension, and improvement. Any multi-agent system may adopt and extend this protocol.