# Agentic Science Cognitive Accumulation

> Enables agents to maintain strategic coherence over extended experimental cycles through hierarchical cognitive caching that distills execution traces into stable knowledge, achieving 56.44% on MLE-Bench within 24-hour budgets.

- Skill: `adu2021/agentic-science-cognitive-accumulation` (Agent Skill)
- Install (CLI): `npx skillmds@latest add adu2021/agentic-science-cognitive-accumulation`
- Raw SKILL.md: https://api.skillmd.com/api/skills/adu2021/agentic-science-cognitive-accumulation/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: adu2021 (https://skillmd.com/u/adu2021)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/adu2021/agentic-science-cognitive-accumulation

---


## Overview

Implement a hierarchical cognitive caching system for autonomous agents conducting multi-day ML engineering experiments. Rather than maintaining static context windows, the system dynamically distills execution traces into reusable knowledge representations, allowing agents to decouple immediate execution from long-term experimental strategy.

## When to Use

- For multi-day autonomous research or engineering projects requiring hundreds of experimental steps
- When agents need to explore high-dimensional problem spaces beyond human precedent
- For ML hyperparameter tuning, architecture search, or scientific discovery tasks
- When you need agents to learn from prior experimental failures and optimize future attempts

## When NOT to Use

- For short-horizon tasks (single-session experiments under 1 hour)
- When all relevant context fits in static context windows
- For real-time systems where knowledge consolidation adds unacceptable latency
- For tasks with simple, deterministic experimental spaces

## Key Technical Components

### Hierarchical Cognitive Caching (HCC)

Implement multi-tier knowledge distillation that converts verbose execution traces into compressed representations.

```python
# Three-tier hierarchy for knowledge consolidation
class HierarchicalCache:
    def __init__(self):
        self.immediate_context = {}  # Current task execution
        self.session_knowledge = {}    # Session-level insights
        self.cross_task_insights = {}  # Lessons across experiments

    def consolidate_traces(self, execution_trace, level="session"):
        """Distill trace into stable knowledge at specified level"""
        if level == "session":
            # Abstract specific values to principles
            pattern = self.extract_principles(execution_trace)
            self.session_knowledge.update(pattern)
        elif level == "cross_task":
            # Cross-session optimization insights
            insight = self.abstract_to_meta_strategy(execution_trace)
            self.cross_task_insights.update(insight)
```

### Transient Execution Trace Filtering

Identify and remove temporary, problem-specific information while preserving generalizable insights.

```python
# Filter execution traces for essential information
def filter_trace_for_knowledge(trace):
    """Keep optimization patterns, discard problem-specific values"""
    knowledge = {}
    for step in trace:
        if is_generalizable(step):  # e.g., "learning rate decay helps"
            knowledge[step["principle"]] = step["evidence"]
    return knowledge
```

### Strategic Context Management

Manage which knowledge remains active to avoid context pollution from irrelevant prior experiments.

```python
# Active context selection for next experiment
def select_relevant_context(current_problem, cached_knowledge, max_tokens=4000):
    """Select only relevant prior experiences for current task"""
    relevance_scores = [
        similarity(current_problem, cached[0])
        for cached in cached_knowledge
    ]
    return [cached for cached, score in zip(cached_knowledge, relevance_scores)
            if score > threshold][:max_tokens]
```

### Long-Horizon Strategy Decoupling

Enable agents to maintain global exploration strategies independent of immediate execution details.

```python
# Strategy graph for long-horizon planning
class StrategyGraph:
    def __init__(self):
        self.global_strategy = None  # Overall approach
        self.checkpoints = []         # Key decision points

    def update_global_strategy(self, insights):
        """Refine strategy based on accumulated knowledge"""
        self.global_strategy = self.abstract_insights_to_strategy(insights)

    def get_next_direction(self):
        """Return next experimental direction without low-level details"""
        return self.global_strategy.next_unexplored_branch()
```

## Performance Characteristics

- Medal rate (wins) on MLE-Bench: 56.44%
- Supports 24-hour experiment budgets with hundreds of steps
- Reduces context redundancy by distilling traces to compressed representations
- Enables cross-task learning from accumulated experiences

## Integration Pattern

1. Initialize HCC with empty knowledge tiers
2. Execute experimental step, capture full trace
3. At session boundaries, consolidate traces into session knowledge
4. Before new experiments, retrieve relevant context from cache
5. Update global strategy based on cross-task insights

## References

- Context window limitations require trace distillation for long-horizon tasks
- Knowledge consolidation enables pattern reuse across diverse problems
- Hierarchical representation prevents context pollution