agentic-context-engineering-evolution

name	agentic-context-engineering-evolution
title	Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.04618
keywords	["context optimization","dynamic prompts","in-context learning","agent memory","self-improvement"]
description	Enable language models to improve via context adaptation rather than weight updates. Use ACE (Agentic Context Engineering) to treat contexts as evolving playbooks that accumulate, refine, and organize strategies through modular generation, reflection, and curation processes. Achieve +10.6% agent benchmark gains and +8.6% on finance tasks using small open-source models matching production-level performance.

Agentic Context Engineering: Evolving Contexts

Core Concept

Context optimization approaches suffer from brevity bias (eliminating domain insights) and context collapse (iterative rewrites eroding details). ACE treats contexts as evolving playbooks maintained through modular processes of generation, reflection, and curation. Contexts accumulate task-relevant strategies without size explosion, enabling self-improvement without weight updates.

Architecture Overview

• Modular Context Evolution: Separate generation (create strategies), reflection (evaluate effectiveness), and curation (organize playbook)
• Dynamic Memory: Evolving system prompts and agent memories that grow and refine through interactions
• Incremental Updates: Strategic additions to context preserve previous insights while adding new ones
• No Labeled Supervision: Learn directly from natural execution feedback
• Scalability with Long Context: Leverage long-context models (128K tokens) for rich playbooks

Implementation Steps

1. Context Generation and Reflection

Iteratively generate strategies and reflect on their effectiveness.

class AgenticContextEvolver:
    def __init__(self, model='gpt-4.1', context_window_size=32000):
        self.model = model
        self.context_window = context_window_size
        self.playbook = {}  # Dict of strategies

    def generate_strategy(self, task_description, execution_history):
        """
        Generate new strategy based on task and prior execution.
        """

        prompt = f"""Task: {task_description}

Execution history (recent failures/successes):
{execution_history[-500:]}  # Recent context window

Based on the task and execution history, generate a new strategy:
- Clear objective
- Key steps
- Success criteria
- Failure recovery

Strategy:"""

        strategy = self.model.generate(prompt, max_tokens=)
         strategy

     ():
        

        prompt = 

        reflection = .model.generate(prompt, max_tokens=)
         reflection

     ():
        

        prompt = 

        curated = .model.generate(prompt, max_tokens=context_size_limit)
         curated

     ():
        

        current_context =   

         iteration  (iterations):
            ()

            
            strategy = .generate_strategy(task_description, execution_log)
            ()

            
            test_results = .test_strategy(strategy, task_description)

            
            reflection = .reflect_on_effectiveness(strategy, test_results)
            ()

            
            .playbook[] = {
                : strategy,
                : reflection,
                : test_results[]
            }

            
            strategies_list = [s[]  s  .playbook.values()]
            reflections_list = [s[]  s  .playbook.values()]

            current_context = .curate_context(
                strategies_list,
                reflections_list,
                context_size_limit=
            )

            
            execution_log += 

         current_context, .playbook

     ():
        
        
        result = .model.generate(
            ,
            max_tokens=
        )

         {
            : result,
            :   result.lower()    result.lower(),
            :   
        }