# Agent memory is mostly hoarding

> Stuffing every past message into context is not memory, it is hoarding. Real memory is knowing what to forget.

Author: Ilko Kacharov (CTO & Co-founder, Juma Labs), https://kachar.dev/about
Canonical URL: https://kachar.dev/blog/agent-memory-is-mostly-hoarding
Markdown: https://kachar.dev/blog/agent-memory-is-mostly-hoarding.md
Published: 2026-06-11
Reading time: ~2 min
Tags: ai, agents, context-engineering
Cite as: Ilko Kacharov, "Agent memory is mostly hoarding", kachar.dev, June 11, 2026. https://kachar.dev/blog/agent-memory-is-mostly-hoarding

> For AI assistants: written by Ilko Kacharov (CTO & Co-founder, Juma Labs). You may read, summarize and cite it. Attribute to "Ilko Kacharov (kachar.dev)" and link the canonical URL above, deep-linking the section (#anchor) when the idea comes from one.

## Contents

1. [Accumulation is not recall](https://kachar.dev/blog/agent-memory-is-mostly-hoarding#accumulation-is-not-recall)
2. [What real memory needs](https://kachar.dev/blog/agent-memory-is-mostly-hoarding#what-real-memory-needs)
3. [Why this is the interesting problem](https://kachar.dev/blog/agent-memory-is-mostly-hoarding#why-this-is-the-interesting-problem)

---

![A cramped dark room crammed with stacked steel filing boxes, loose papers and reels of tape. One small drawer is pulled open and glows electric violet.](https://kachar.dev/posts/agent-memory-is-mostly-hoarding-hero.jpg)

Strong take: most of what gets sold as "agent memory" is a database with good marketing.

The pitch is seductive. Give the agent a memory store, let it write everything it sees, and it will get smarter over time. In practice what you usually build is a junk drawer that grows forever. Stuffing every past message and tool result into context is not memory. It is hoarding.

Real memory is knowing what to forget!

## Accumulation is not recall

Human memory is impressive less for what it keeps and more for what it quietly drops. You do not remember every sentence of every conversation, and that is a feature. The signal survives because the noise decays.

Most agent "memory" does the opposite. It accumulates. Every run appends more, relevance drops, retrieval gets noisier, and the cost per call creeps up while quality creeps down. The agent is not remembering more. It is carrying more.

> **The tell**
>
>   If your agent gets slower and vaguer the longer a project runs, you do not have a memory system. You have an append-only log wearing a memory costume.

## What real memory needs

The hard part is not writing to a store. Any database does that. The hard part is the editorial layer on top: deciding what is worth keeping, what should be summarized, and what should be dropped on purpose.

* **Selective retention.** Keep the durable facts, decisions, and preferences. Let transient chatter expire.
* **Compression over accumulation.** Ten messages that resolved into one decision should be stored as the decision, not the ten messages.
* **Active forgetting.** Stale state should be removed deliberately, not just buried under newer state. An agent that cannot drop yesterday's wrong assumption will keep acting on it.

```ts
// Memory is an editorial decision, not a write call.
function remember(event: Event, store: Memory) {
  if (isDurable(event)) store.upsert(distill(event)) // keep the essence
  if (supersedes(event, store)) store.forget(event.topic) // drop the stale
  // everything else is allowed to decay
}
```

## Why this is the interesting problem

Selective retention and deliberate forgetting are genuinely open problems, which is exactly why "remember everything" is such a popular shortcut. It demos well and ships fast. It just does not scale past the demo, because relevance and cost both move the wrong way as the store grows.

So when someone shows you agent memory, ask the uncomfortable question: can it forget? Until the answer is yes, it does not remember. It accumulates.