Compact Enum Mappings

Compact Enum & Short-Code Mapping Protocol

Overview

In automated data extraction, log classification, and batch API workflows, models frequently output structured JSON containing long descriptive string identifiers ("transaction_status": "PAYMENT_AUTHORIZATION_PENDING_FRAUD_REVIEW" or "log_severity": "INFRASTRUCTURE_CRITICAL_FAILURE").

Verbose string constants consume 8 to 15 tokens per record. In a batch processing run of 5,000 items, transmitting repetitive string identifiers burns over 60,000 redundant output tokens.

The Compact Enum Mapping Protocol defines a lightweight integer or 1-character codebook in the prompt header, allowing the model to emit 1-token codes (0, 1, 2) that downstream application code deserializes into rich, strongly-typed domain objects.

Verbose String Identifiers vs. Compact Enum Codes

┌─────────────────────────────────────────────────────────────┐
│                 Enum Token Serialization                    │
│                                                             │
│  Verbose String Identifiers (145 Tokens for 3 Records):     │
│  [                                                          │
│    {"id": 101, "status": "TRANSACTION_SETTLED_SUCCESSFUL"},│
│    {"id": 102, "status": "TRANSACTION_REJECTED_INSUFFICIENT"}│
│    {"id": 103, "status": "TRANSACTION_PENDING_VERIFICATION"}│
│  ]                                                          │
│                                                             │
│  Compact Enum Codes (38 Tokens - 73.8% Reduction!):         │
│  Map: { 0: SUCCESS, 1: INSUFFICIENT_FUNDS, 2: PENDING }     │
│  [ [101, 0], [102, 1], [103, 2] ]                           │
└─────────────────────────────────────────────────────────────┘

The Master Compact Enum Prompt Schema

When prompting an LLM to categorize or classify bulk records, inject the codebook at the top:

Classify the sentiment and urgency of the customer messages below.

### 🔑 Codebook Mapping:
- **Category (C)**: `0: Billing`, `1: Tech_Bug`, `2: Feature_Request`, `3: Account_Access`
- **Urgency (U)**: `0: Low`, `1: Medium`, `2: Critical_Outage`
- **Action (A)**: `0: Auto_Reply`, `1: Escalate_L2`, `2: Page_OnCall`

### Input Records:
1. "My server is down and throwing 500 errors on payment routes."
2. "How do I change my credit card on file?"

### Output Format:
Return a compact JSON array of integer tuples: `[[record_id, C, U, A], ...]`
Output JSON only:

Model Output (Ultra-Dense):

[
  [1, 1, 2, 2],
  [2, 0, 0, 0]
]

Production Python Deserialization (Pydantic / Enum)

from enum import IntEnum
from typing import List
from pydantic import BaseModel

class TicketCategory(IntEnum):
    BILLING = 0
    TECH_BUG = 1
    FEATURE_REQUEST = 2
    ACCOUNT_ACCESS = 3

class UrgencyLevel(IntEnum):
    LOW = 0
    MEDIUM = 1
    CRITICAL = 2

class ProcessedTicket(BaseModel):
    ticket_id: int
    category: TicketCategory
    urgency: UrgencyLevel

def parse_compact_llm_payload(raw_tuples: List[List[int]]) -> List[ProcessedTicket]:
    """Deserializes 1-token compact integer arrays into type-safe Pydantic domain models."""
    return [
        ProcessedTicket(
            ticket_id=row[0],
            category=TicketCategory(row[1]),
            urgency=UrgencyLevel(row[2])
        )
        for row in raw_tuples
    ]

TypeScript Deserializer

export enum LogSeverity {
  DEBUG = 0,
  INFO = 1,
  WARN = 2,
  ERROR = 3,
  FATAL = 4,
}

type CompactLogEntry = [timestamp: number, severityCode: LogSeverity, message: string];

export function decodeLog(entry: CompactLogEntry) {
  const [timestamp, severity, message] = entry;
  console.log(`[${LogSeverity[severity]}] ${new Date(timestamp).toISOString()}: ${message}`);
}

Token Reduction Benchmarks

Batch classification of 1,000 telemetry log lines:

Agent Operational Directive

MANDATORY: For high-volume structured outputs ($>20$ records), agents must map long descriptive strings to integer or 1-character enums. Let client-side deserializers expand codes into human-readable strings.