Dryft: What if AI memory worked like an ecosystem instead of a filing cabinet?

Source: Dev.to

Overview

I’m a vegetable farmer in Western Canada running a regional food hub. I’m not a developer, but I spend a lot of time thinking about how systems work, how pieces interact, and what happens when they don’t.

The Problem with Current AI Memory

The pattern I keep seeing—both in AI agents and in many tech systems—is isolation. Memory today is essentially a static field:

• Write things to files.
• Search for similar text.
• When the context window fills, compress.
• Important stuff disappears.
• Old decisions sit at equal weight to current ones.
• Nothing ages, connects, or dies.

In nature, memory works differently.

• Reinforcement – Things that matter get stronger.
• Decay – Things that don’t fade.
• Relational bonding – Related items bind together.
• Predation – The system removes what it can no longer afford to carry.

It’s not just storage; it’s ecology.

Dryft: An Ecological AI Memory System

Dryft treats memories as a living population (a herd) that self‑regulates.

Why It Matters for Agents

Agents that manage work and life inevitably accumulate memory bloat:

• A project deadline query one week, a recipe the next, a code architecture the week after.
• Hundreds of entries pile up, and a trivial fact (e.g., “how long to boil an egg”) sits at the same weight as a critical architectural decision.

In Dryft, the egg memory fades because it stops being referenced, while the architecture decision stays strong through repeated activation. The ecology decides what to keep, not the user.

Core Issues in Agent Memory (and Dryft’s Solutions)

Architecture of Dryft

+-------------------+   +-------------------+
| Foundational Layer|   |   Grass Layer     |
| (permanent core) |   | (substrate for    |
|                   |   |  new general      |
|                   |   |  knowledge)       |
+-------------------+   +-------------------+

        |                       |
        v                       v

+-------------------+   +-------------------+
|   Main Herd       |   | Evaluation Herd   |
| (operational      |   | (opinion /        |
|  memories)        |   |  evaluative)      |
+-------------------+   +-------------------+

        |                       |
        v                       v

+-------------------+   +-------------------+
| Dormancy Staging  |   | Temporal Layer    |
| (incubator for    |   | (time‑aware       |
|  new signals)     |   |  reasoning)       |
+-------------------+   +-------------------+

• Foundational Layer – Permanent core knowledge.
• Grass Layer – Substrate that feeds new memories (decomposition output).
• Main Herd – Operational memories (the “cattle”).
• Evaluation Herd – Separate flock for evaluative/opinion memories (the “sheep”).
• Dormancy Staging – Incubator for new signals before they join the herd.
• Temporal Layer – Provides time‑aware reasoning and lineage tracking.

Conflict Detection & “Humane Dispatch”

• The system identifies contradictory memories.
• It surfaces the conflict conversationally.
• Users can confirm removal (“humane dispatch”).
• Wrong memories are not decomposed because they have zero substrate value.

Benchmarks & Results

The custom benchmark reflects my own usage patterns; LOCOMO provides a more general comparison.

Takeaway

Dryft demonstrates that ecological principles—fitness, bonding, predation, decay, and decomposition—can turn a static, ever‑growing memory store into a self‑regulating, lean, and context‑aware system. By letting the herd decide what lives and what dies, we get:

• Higher retrieval relevance over time.
• Natural emergence of relationships without manual graph building.
• Automatic removal of stale or irrelevant information.

If you’re using agents to manage work and life, consider an ecological memory model like Dryft to keep your system lean, relevant, and alive.

Overview

• Dryft is an experimental memory system that demonstrates emergent behavior and ecological design principles.
• Benchmarks show it outperforms comparable systems (e.g., Mem0 66.9 % vs. OpenAI Memory 53 %).
• Main gaps:
  • Temporal‑extraction failures (relative dates not resolved).
  • Predator‑culling of memories that later appear in the benchmark.

These issues are fixable. The predator‑culling trade‑off is intentional: in real‑world use we prefer to prune stale memories, even if it costs points on a benchmark that treats every query equally.

Key Observations

• Emergent Behaviors – Not explicitly coded:

  • Memories that hit zero fitness can spontaneously recover when they become relevant again.
  • Memories form clusters through bonding, mirroring how I naturally think about topics.

• State of the Project –

  • Not production‑ready, but the architecture works and the benchmarks validate it.
  • Scaling it into an agent‑framework plug‑in requires a larger development effort than I can handle alone.

• My Role – I’m a systems thinker, not a developer or project manager. I bring:

  • A design methodology that consistently yields results.
  • 15 years of experience observing complex, self‑organizing living systems.

• Ecological Framing – This isn’t decorative; it’s the source of every feature. The architecture emerged from watching how populations self‑regulate, not from reverse‑engineering existing memory systems.

Open‑Source Release

I’m releasing Dryft under the MIT License because I want it to be useful in real applications. AI memory will be crucial for everyone, and current solutions feel like “filing cabinets pretending to be brains.”

• Take it, run with it, and improve it.
• If you’re interested in extending the ecological approach, I’d love to stay involved. The design methodology is my primary contribution; the biological intuition is a way of thinking that can’t be fully captured in a README.

Feedback—both praise and criticism—is welcome. If you build something with Dryft, a credit would be appreciated, but my main goal is to see it used in the wild.

Repository

🔗 GitHub:

Core Files

License

MIT License

Feel free to do whatever you want with the code.