Why do hour-scale agents use hierarchical summarization instead of a single summary block?

**Hierarchical summarization** is a memory pattern for long-running agents that stacks summaries of different time scales. A single flat summary has one fixed token budget. When a chat or an agent runs for ten minutes, that budget is comfortable. When it runs for ten hours, the summarizer has to fit ten hours of history into the same number of tokens. Each new compression pass smooths away more detail, and the specifics from early in the run quietly disappear. Hierarchical summarization fixes this by keeping multiple resolution levels at once. Level-1 covers the most recent groups of turns at high detail. Level-2 covers groups of level-1 summaries at coarser detail. Level-3 covers groups of level-2 summaries even more coarsely. The model reads the freshest turns verbatim, then level-1 just above them, then level-2 above that. The shape this gives you is detail that decays with distance: sharp for what just happened, fuzzy for what happened hours ago, very fuzzy for what happened at the start. That matches how the agent actually needs to use its memory, which is mostly to act on recent state and only occasionally to recall old context.

**Hierarchical summarization** wins for hour-scale agents because it gives each time scale its own token budget instead of forcing all of history through one bottleneck. A flat summary has a fixed cap, say 1,500 tokens. Early in a run it covers 30 turns comfortably. By turn 300, the same 1,500 tokens have to cover ten times as much trajectory. The summarizer is forced to compress harder on every refresh, and the things that get smoothed away are the specific identifiers, numbers, and one-off observations that the model might need later. The decay rate is roughly uniform across the whole history, which is the wrong shape. Hierarchical summarization gives each level a separate budget. Level-1 holds recent turns at high fidelity, level-2 holds older groups in coarser strokes, level-3 holds the earliest part in broad outline. The model sees a stack: verbatim recent turns, then level-1, then level-2, then level-3. Detail decays with distance, which matches the access pattern of a long-running agent: it acts on recent state most of the time and only occasionally needs to reference earlier reasoning. The trade-off is complexity. The agent loop needs an explicit roll-up step that turns N level-1 summaries into one level-2 summary at the right cadence. Frameworks like LangGraph and the Claude agent SDK expose hierarchical state, but the agent author still chooses when each roll-up fires.