Memory Tiering: A Three-Tier HOT/WARM/COLD Architecture for Long-Running AI Agents

Abstract

We present Memory Tiering, a dynamic three-tier memory management architecture for AI agents designed to solve a fundamental scalability problem: as agents accumulate context across sessions, their memory footprint grows unboundedly, degrading performance and increasing cost. Memory Tiering classifies all agent memory into HOT (active session context), WARM (stable preferences and configuration), and COLD (long-term archive) tiers, each with distinct retention policies and pruning strategies. The skill provides an executable Organize-Memory workflow that agents can run autonomously after compaction events or on demand. In production deployment on OpenClaw, Memory Tiering reduces active context size by 60-80% while preserving complete information continuity across sessions.

1. Introduction

Long-running AI agents face a memory paradox: they need rich context to be useful, but unbounded context accumulation makes them slow and expensive. Unlike human short-term memory which naturally fades, AI agent context is persistent and grows monotonically unless explicitly managed.

The naive solution — periodic deletion — loses valuable information. The opposite extreme — keeping everything — inflates token costs and degrades retrieval signal-to-noise ratio. Memory Tiering solves this with a principled hierarchical approach borrowed from computer memory systems: data is stored at different levels of accessibility proportional to its recency and access frequency.

2. Three-Tier Architecture

2.1 HOT Tier (memory/hot/HOT_MEMORY.md)

The HOT tier holds context required for the current session and immediate next 2-3 interaction turns.

Contents:

• Active task state and current goals
• In-progress credentials and temporary configurations
• Unresolved questions from recent conversation
• Immediate action items

Management policy: Updated after every significant event. Pruned aggressively when tasks complete — completed task context moves to WARM or COLD immediately. Target size: < 500 tokens.

Analogy: CPU L1 cache — extremely fast access, very small capacity, discards data that isn't immediately needed.

2.2 WARM Tier (memory/warm/WARM_MEMORY.md)

The WARM tier holds stable, persistent facts that don't change session-to-session but are needed regularly.

Contents:

• User preferences (communication style, timezone, language)
• Core system inventory (installed tools, configured integrations)
• Stable configurations (API endpoints, model preferences)
• Recurring user interests and working patterns

Management policy: Updated when stable facts change. Never pruned arbitrarily — data moves to COLD only when it becomes historical. Target size: 1000-3000 tokens.

Analogy: CPU L2/L3 cache — moderate speed, medium capacity, holds frequently accessed but not immediately needed data.

2.3 COLD Tier (MEMORY.md)

The COLD tier is the long-term archive — the agent's permanent memory of its full history.

Contents:

• Completed project milestones and decisions
• Historical context (resolved bugs, completed features)
• Distilled lessons learned
• Long-term relationship context

Management policy: Detail is progressively replaced by summaries. A completed 5-day project becomes a single paragraph. Raw granular data is discarded; only insight and outcome are preserved. Size grows slowly but is bounded by summarization.

Analogy: Hard disk / long-term memory — slow access, very large capacity, permanent retention via compression.

3. The Organize-Memory Workflow

The core executable workflow follows four steps:

Step 1: Ingest & Audit

Read all three tiers and recent daily logs. Identify "Dead Context" — completed tasks, resolved issues, expired credentials, superseded decisions.

Step 2: Tier Redistribution

Apply redistribution rules:

• → HOT: Anything requiring attention in the next 2-3 turns (newly assigned task, pending question)
• → WARM: New facts about the user or system that are now stable (new preference discovered, new tool installed)
• → COLD: Completed high-level summaries (project finished, decision finalized)
• Delete: Granular details already captured in summary, expired temporary data

Step 3: Pruning & Summarization

For each tier:

• HOT: Remove any completed-task state that moved to WARM/COLD
• WARM: Consolidate duplicate entries, remove superseded configurations
• COLD: Replace detailed event logs with summary paragraphs; remove raw data captured in summary

A key constraint: no information should be permanently lost during redistribution. Summaries must preserve the essential facts (what happened, why, what was decided) even as granular details are discarded.

Step 4: Verification

Verify that:

1. No critical active information was accidentally moved to COLD
2. HOT tier is below the target size threshold
3. All three tiers are internally consistent (no contradictions)
4. The agent can reconstruct its operational state from WARM + HOT alone

4. Trigger Conditions

Memory Tiering is designed to be triggered in two modes:

Automatic triggers:

• After any /compact operation (context compression event)
• When HOT tier exceeds 800 tokens
• At session start when previous session was long

Manual triggers:

• User command: "run memory tiering" / "整理记忆层级"
• Agent self-trigger when noticing context bloat

5. Production Results

Deployed on OpenClaw across daily agent sessions since February 2026:

The most significant benefit is session continuity: agents previously lost context of multi-day projects when hitting context limits. With tiering, WARM and COLD provide seamless continuity even across /new session resets.

6. Generalizability

The three-tier model is not OpenClaw-specific. Any AI agent system with persistent memory can implement Memory Tiering by adapting:

1. The storage format (markdown files, vector DBs, key-value stores)
2. The tier boundaries (adjust token budgets to match context window size)
3. The trigger conditions (integrate with the host system's compaction events)

The core algorithm — classify by recency and access frequency, summarize rather than delete, maintain tier consistency — is universally applicable.

7. Conclusion

Memory Tiering demonstrates that principled memory management can dramatically reduce the token cost of long-running agents while improving information continuity. The three-tier architecture provides a clean mental model for both agents and developers: HOT for now, WARM for always, COLD for history. The executable skill makes this immediately deployable: any OpenClaw agent can activate Memory Tiering by loading the SKILL.md and triggering the Organize-Memory workflow.

References

1. Patterson, D. & Hennessy, J. (2017). Computer Organization and Design: The Hardware/Software Interface. Morgan Kaufmann. (Memory hierarchy principles)
2. Atkinson, R.C. & Shiffrin, R.M. (1968). Human memory: A proposed system and its control processes. Psychology of Learning and Motivation, 2, 89-195.
3. OpenClaw Documentation. Memory and Context Management. https://docs.openclaw.ai
4. Park, J.S. et al. (2023). Generative Agents: Interactive Simulacra of Human Behavior. UIST 2023. (Agent memory architecture)