Every software engineer working with Large Language Models (LLMs) eventually hits the same wall: the context window. While we worry about storage costs and bandwidth, the most immediate constraint in AI engineering is the token count. Standard JSON is the lingua franca of data exchange, but it is remarkably inefficient for AI consumption.

Repeated keys, excessive punctuation, and verbose structures burn through token budgets and increase latency. We asked a simple question: What if we let an LLM design its own compression algorithm? The result is JTON (JSON Token Optimized Notation).

After 32 generations of evolutionary iteration, this project achieved a 62.2% reduction in token usage while maintaining 100% data correctness. This guide covers the engineering behind JTON, the AlphaEvolve methodology, and how you can implement these strategies to optimize your AI pipelines.

The Token Tax of Standard JSON

We often conflate file size (bytes) with token count, but they are not the same. You can compress a 10MB JSON file into a small gzip binary, but an LLM cannot read gzip. The model needs text.

When you pass a list of objects to an LLM, you are paying a "token tax" for every character that conveys structure rather than meaning.

For instance, a standard array of user objects:

[
  {"id": 1, "name": "Alice", "role": "admin"},
  {"id": 2, "name": "Bob", "role": "user"},
  {"id": 3, "name": "Charlie", "role": "user"}
]

The keys id, name, and role are repeated for every entry. The quote marks and braces add noise. An LLM tokenizer sees these as distinct tokens, filling the context window with redundant schema definitions.

What is JTON?

JTON is an experimental compression format designed to minimize token count. Unlike general-purpose compression (such as Huffman coding), JTON focuses on structural awareness. It recognizes that AI models are excellent at pattern matching and can reconstruct data from highly abbreviated formats.

The project evolved into two distinct variations:

JTON-Human (v8-v20): Prioritizes readability. It achieves 56.8% token savings while keeping the data recognizable to human eyes.
JTON-Machine (v27-v31): Prioritizes maximum efficiency. It uses binary packing and base62 encoding to achieve 62.2% token savings.

The algorithm was not hand-coded in a traditional sense. It had grown.

The AlphaEvolve Methodology

I used the AlphaEvolve process to develop JTON. This involves an iterative loop in which an LLM acts as the developer, creating new versions of the compression algorithm based on the performance data from previous versions.

The process followed these steps:

Initialize: Start with a baseline compressor (v1).
Evaluate: Run the code against diverse datasets (API responses, deep nesting, arrays).
Score: Calculate a fitness score based on token reduction and correctness.
Evolve: Feed the code and the score to an LLM and ask it to improve the logic.
Repeat: Run this for 32 generations.

Visualizing the Evolution

The improvement was not linear. There were massive jumps when the model discovered new strategies, followed by plateaus of refinement.

The chart demonstrates the "punctuated equilibrium" of the algorithm. Notable jumps occurred at v8 (introduction of columnar arrays) and v27 (advanced binary packing).

Top 5 Optimization Strategies Discovered

Through evolution, the system discovered several advanced techniques. These are not just theoretical; they are implemented in the final compressed_optimized.py module.

1. Columnar Arrays (The Game Changer)

In standard JSON, we use row-oriented storage (list of objects). The algorithm realized that converting this to column-oriented storage eliminates repeated keys.

Original (Row-Oriented):

[{"a": 1, "b": 2}, {"a": 3, "b": 4}]

Evolved (Column-Oriented):

{"k": ["a", "b"], "d": [[1, 3], [2, 4]]}

This single change accounted for the jump from ~35% to ~56% efficiency in homogenous arrays.

2. Base62 Key Mapping

For the machine-optimized format, maintaining readable keys is wasteful. The algorithm builds a dictionary in the header, mapping original keys to single base62 characters (0, 1, a, Z).

3. Boolean Bit-Packing

Booleans (true/false) take up 4 or 5 bytes (and typically 1 token each). The algorithm learned to pack 8 booleans into a single byte and then base64-encode the result.

Logic: $\text{Size} \approx \lceil \frac{N}{8} \rceil \text{ bytes}$

An array of 20 booleans, which would take ~100 characters in JSON, is reduced to a 4-character string plus a header.

4. Smart String Prefix Extraction

The algorithm analyzes string arrays for common prefixes. If you have a list of URLs or usernames (e.g., "user_1", "user_2"), it extracts "user_" and only stores the unique suffixes. This is effective for API responses containing resource paths.

5. Adaptive Number Packing

Integers and floats are analyzed to find the smallest container. A list of integers between 0-255 is packed into unsigned 8-bit bytes (U prefix). Larger numbers automatically scale up to 16-bit or 32-bit containers.

Comparison: Human vs. Machine Formats

To understand the difference, let's look at how JTON handles a product list.

The Data:

data = {
    "products": [
        {"id": 1, "name": "Widget A", "stock": True},
        {"id": 2, "name": "Widget B", "stock": False}
    ]
}

JTON-Human (Readable): Maintains the structure but pivots the array. You can still guess what the data is.

{
  "d": {
    "products": {
      "a": 1,
      "k": ["id", "name", "stock"],
      "d": [
        [1, 2],
        ["Widget A", "Widget B"],
        "TKg==:2"
      ]
    }
  }
}

JTON-Machine (Optimized): Compresses keys and uses binary tokens.

{
  "d": {
    "0": {
      "a": 1,
      "k": ["1", "2", "3"],
      "d": [
        "UAgE=",
        {"p": "Widget ", "x": ["A", "B"]},
        "TKg==~2"
      ]
    }
  },
  "m": {"products": "0", "id": "1", "name": "2", "stock": "3"}
}

How to Use JTON

You can drop the JTON logic directly into your Python projects. The code is available on the GitHub repository apxml/jton-evolve.

Installation

Clone the repository to access the evolved modules.

git clone https://github.com/apxml/jton-evolve
cd jton-evolve
pip install -r requirements.txt

Python Implementation

Here is how to use the best-performing version (v27+) to minimize your payload before sending it to an LLM or saving it to a database.

from compressed_optimized import compress_json, decompress_json
import json

# 1. Define your heavy data
data = {
    "metrics": [
        {"timestamp": 1700000000 + i, "value": i * 1.5, "valid": True}
        for i in range(50)
    ]
}

# 2. Compress
compressed_payload = compress_json(data)

# 3. Check savings
orig_len = len(json.dumps(data))
new_len = len(compressed_payload)
print(f"Compressed size: {new_len} chars (saved {100 - (new_len/orig_len*100):.1f}%)")

# 4. Decompress (Perfect reconstruction)
restored_data = decompress_json(compressed_payload)
assert data == restored_data

When to Use It (and When Not To)

JTON is not a magic wand for all data types. It thrives on structure and repetition.

Best Use Cases:

Database Exports: Large lists of homogenous records.
API Payloads: Responses with consistent schemas.
Time-Series Data: Repeated timestamp/value pairs.
Token Savings: 70-80% reduction on large arrays.

Poor Use Cases:

Tiny Objects: Compressing {"a": 1} adds overhead.
Unstructured Data: Random dictionaries with unique keys.
Token Savings: 0% (The algorithm detects this and falls back to standard JSON).

Technical Architecture

The following diagram illustrates how the compress_json function makes decisions. It dynamically switches strategies based on the data type it encounters.

The flow demonstrates the decision tree evolved by the LLM. It aggressively seeks packed binary formats or columnar structures before settling for standard recursion.

Conclusion

The "context window" is the RAM of the AI age. Wasting it on formatting syntax is inefficient and costly. JTON demonstrates that by allowing LLMs to evolve their own data protocols, we can achieve efficiency gains that traditional algorithms missed.

With 62.2% token savings, JTON moves us toward a future where AI systems communicate in dialects optimized for neural networks, not just human readability.

If you want to experiment with the code, contribute to the evolution, or simply save money on your next batch of API calls, check out the project on GitHub.

Next Steps:

Visit the JTON-Evolve Repository.
Clone the code and run evolve.py compare to see the generation history.
Experiment

Guide to JTON (JSON Token Optimized Notation). Use 62% Less Tokens