acon-context-compression-agents

name	acon-context-compression-agents
title	ACON: Optimizing Context Compression for Long-Horizon LLM Agents
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.00615
keywords	["context-compression","agent-efficiency","long-horizon-reasoning","memory-reduction","LLM-agents"]
description	Reduce memory overhead of long-horizon LLM agents by learning task-specific context compression strategies. A learnable compressor adapts by analyzing failure cases, achieving 26-54% memory reduction while preserving 95%+ accuracy, enabling smaller models to act as efficient long-context agents.

ACON: Adaptive Context Compression for Agent Efficiency

Long-horizon agents accumulate vast context—environment observations, interaction history, tool outputs—that grow linearly with task length. A 100-step task means 100x screenshot observations plus tool responses. This explodes memory and latency, limiting agent deployment to resource-rich settings. ACON solves this by learning task-specific compression rules that preserve critical information while discarding noise.

The key insight is that compression rules are learnable and task-dependent. Instead of generic compression (truncate old history, remove timestamps), ACON analyzes why compressed contexts fail, then refines the compression strategy iteratively. This produces adapters that work across different agents and tasks.

Core Concept

ACON operates in three phases:

1. Baseline compression: Apply initial heuristic (e.g., keep recent K steps, summarize old steps)
2. Failure analysis: When compressed context causes task failure, diagnose why (what info was lost?)
3. Refinement: Update compression strategy in natural language (e.g., "always preserve error messages")

The compressor is a learned function that maps (observation, history, task) to (compressed_observation, compressed_history). It learns from failure traces, not from paired data.

Architecture Overview

• Compressor module: Maps observations and history to compressed versions
• Failure detector: Identifies task failures caused by missing context
• Analyzer: LLM reasoning over failure traces to identify patterns
• Guideline updater: Refines compression rules in natural language
• Distiller: Optionally compresses the compressor itself into a small model

Implementation Steps

Start with a baseline compressor that uses heuristic rules:

import json
from typing import Dict, List, Tuple

class ContextCompressor:
    """
    Learn task-specific context compression via failure analysis.
    """
    def __init__(self, task_name, model_name=):
        .task = task_name
        .model = model_name
        
        .guidelines = [
            ,
            ,
            ,
            
        ]

     () -> :
        
        
        compressed = {}

        
           observation:
            max_screenshots = 
            compressed[] = observation[][-max_screenshots:]

        
           observation:
            seen = ()
            unique_responses = []
             resp  observation[]:
                resp_hash = (resp)
                 resp_hash   seen:
                    unique_responses.append(resp)
                    seen.add(resp_hash)
            compressed[] = unique_responses

        
           observation:
            compressed[] = observation[]

         compressed

     () -> []:
        
         (history) <= max_recent:
             history

        
        recent = history[-max_recent:]

        
        old_history = history[:-max_recent]
        summary = {
            : ,
            : (old_history),
            : ((a.get()  a  old_history)),
            : [a  a  old_history  a.get() == ]
        }

         [summary] + recent