acon-context-compression-long-horizon

name	acon-context-compression-long-horizon
title	ACON: Agent Context Optimization for Long-Horizon Tasks
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","long-horizon-agents","efficiency","prompt-optimization"]
description	Compress agent interaction histories and environment observations through natural language guideline optimization, reducing token usage by 26-54% while preserving 95%+ accuracy. Use for cost/latency reduction in multi-step agent tasks.

ACON: Agent Context Optimization for Long-Horizon Tasks

ACON addresses unbounded context growth in multi-step agents through compression guideline optimization in natural language space. Rather than parameter fine-tuning, the approach optimizes natural language instructions that guide what to compress, enabling closed-source API compatibility and rapid iteration.

Core Architecture

• Compression guidelines: Natural language rules describing what to compress
• Gradient-free optimization: No parameter updates; pure prompt/instruction learning
• Contrastive training: Optimize guidelines using compressed vs. uncompressed agent performance
• Flexible integration: Works with closed-source models (GPT-4, Claude)
• Composable: Stack compression guidelines for layered reduction

Implementation Steps

Setup ACON compression optimizer:

# Initialize ACON for agent context compression
from acon import CompressionOptimizer, CompressionGuidelineManager

# Create compression guideline manager
guideline_manager = CompressionGuidelineManager(
    initial_guidelines=[
        "Remove intermediate steps that don't affect final decisions",
        "Abbreviate repetitive tool outputs",
        "Summarize multi-turn conversation threads"
    ],
    optimization_strategy="contrastive"
)

# Initialize optimizer
optimizer = CompressionOptimizer(
    agent_model="gpt-4",
    compression_model="gpt-4",  # can differ from agent
    guideline_manager=guideline_manager,
    max_iterations=10
)

Execute contrastive guideline optimization:

# Optimization loop for compression guidelines
from acon import AgentExecution

for iteration in range(num_optimization_iterations):
    # Task set to optimize over
    test_tasks = load_benchmark_tasks()  # e.g., AppWorld, OfficeBench

    scores_by_guideline = {}

     task  test_tasks:
        
        full_execution = AgentExecution(
            agent_model=,
            task=task
        )
        full_result = full_execution.run()
        full_accuracy = evaluate(full_result, task.ground_truth)
        full_tokens = count_tokens(full_execution.trajectory)

        
        compressed_execution = AgentExecution(
            agent_model=,
            task=task,
            compression_guidelines=guideline_manager.current_guidelines
        )

        
        compressed_trajectory = compressed_execution.compress_context(
            full_trajectory=full_execution.trajectory,
            guidelines=guideline_manager.current_guidelines,
            compression_ratio_target=  
        )

        
        compressed_result = compressed_execution.run(
            compressed_trajectory=compressed_trajectory
        )
        compressed_accuracy = evaluate(compressed_result, task.ground_truth)
        compressed_tokens = count_tokens(compressed_trajectory)

        
        accuracy_retained = compressed_accuracy / full_accuracy
        token_reduction =  - (compressed_tokens / full_tokens)

        
        score =  * token_reduction -  * (,  - accuracy_retained)
        scores_by_guideline[task.] = score

    
    avg_score = np.mean((scores_by_guideline.values()))
    ()

    
    improved_guidelines = optimize_guidelines_with_lm(
        current_guidelines=guideline_manager.current_guidelines,
        evaluation_scores=scores_by_guideline,
        full_trajectories=[e.trajectory  e  test_executions],
        optimization_prompt=GUIDELINE_OPTIMIZATION_PROMPT
    )

    guideline_manager.update_guidelines(improved_guidelines)