DEV Community: Andy | AI产品专家

DNA Memory: Making AI Agents Learn, Forget, and Evolve Like a Human Brain

Andy | AI产品专家 — Sat, 21 Mar 2026 21:36:47 +0000

Most AI memory systems solve only one problem: storage.

They help an agent remember previous messages, retrieve context, or search old notes. That is useful — but it is not the same as learning.

Human memory is not a database.

It has structure.
It forgets.
It reinforces what matters.
It summarizes patterns.
It turns scattered experiences into reusable judgment.

That is the idea behind DNA Memory.

GitHub: https://github.com/AIPMAndy/dna-memory

The problem

If you have worked with AI assistants or autonomous agents for a while, you have probably seen the same failure mode:

the agent stores too much low-value information
old context accumulates without prioritization
repeated mistakes are not converted into durable lessons
user preferences are remembered inconsistently
"memory" becomes a dump, not an evolving system

Most memory layers are built like logs.
Very few are built like cognition.

What DNA Memory tries to do differently

DNA Memory is a lightweight memory evolution system for agents.

Instead of treating memory as a flat key-value store, it treats memory as something that should move across layers and change in importance over time.

1. Three-layer memory architecture

DNA Memory uses three layers:

Working memory: temporary context for the current task or session
Short-term memory: recent important facts, preferences, and lessons
Long-term memory: stable knowledge and high-value patterns

The goal is simple:

not everything deserves to become long-term memory.

2. Reinforcement and forgetting

Memories are weighted.

used memories can be strengthened
stale memories can decay
low-value memories can eventually be removed
stable, important memories can be promoted into long-term memory

That makes the system closer to how humans actually retain knowledge.

3. Reflection

The most important part is not storage — it is reflection.

DNA Memory includes a reflect step that reviews high-value short-term memories and looks for repeatable patterns.

That means agent experience can gradually become:

a preference rule
an operational skill
a recognized failure pattern
a reusable long-term memory

4. Better recall

A memory system is only useful if retrieval is practical.

The latest version now supports:

multi-keyword AND recall
type-based filtering like type:error or type:skill
SQLite FTS5 full-text search
fallback search when FTS5 is unavailable

So instead of just dumping everything into memory, recall becomes much closer to how an operator actually searches for prior experience.

A small but important engineering choice

One thing I changed recently was unifying the storage around a single SQLite memory store.

That solved a very real systems problem:

old JSON-based memory artifacts and newer runtime state were drifting apart
daemon behavior and memory data source were inconsistent
recall quality suffered because the active store and the historical store were split

After the cleanup, the system now has:

a cleaner SQLite-based primary store
FTS5 recall indexing
a daemon that reads the current SQLite operation history
safer .gitignore defaults so real memory databases are not pushed to GitHub by mistake

Not flashy — but this kind of systems hygiene is what makes memory layers actually usable.

Why this matters for agents

I think the next step for AI agents is not just better reasoning per call.
It is better continuity across calls.

A capable agent should:

remember what the user repeatedly cares about
learn from mistakes instead of replaying them
gradually build operating taste and judgment
compress noisy experience into durable patterns

That is where memory becomes a true product advantage.

Not “more context.”
But better memory behavior.

Example workflow

A useful loop looks like this:

Recall related memory before acting
Execute the task
Remember newly learned preferences, skills, or errors
Reflect on repeated patterns
Promote stable memories into long-term memory
Decay what no longer matters

That turns raw interaction history into something closer to accumulated experience.

What is already implemented

Current DNA Memory includes:

remember / recall / stats CLI
reflect / promote / dedupe flow
SQLite-backed memory store
FTS5 recall search
background daemon for automatic reflect and decay
launchd-based auto-start support on macOS

What is still missing

There is still a lot to improve:

better semantic retrieval beyond keyword/FTS recall
stronger Chinese tokenization and ranking
richer memory graph visualization
more robust migration / import / export tooling
shared memory spaces for multi-agent systems

So this is not a finished “memory platform.”
It is a working direction.

Repo

If you are building AI assistants, autonomous agents, or long-running automation systems, you may find the approach useful.

GitHub: https://github.com/AIPMAndy/dna-memory

If this resonates, I’d love feedback on one question:

What should an agent remember — and what should it deliberately forget?

How I Built an AI Investment Agent to Turn Trade Logs into Actionable Research

Andy | AI产品专家 — Sat, 21 Mar 2026 15:17:09 +0000

Most retail investors don't really have an investing system.

They have scattered notes, screenshots, a few Excel sheets, and some vague memories like:

"I bought this because the story sounded good."
"I sold too early again."
"I knew this was risky, but I still did it."

The problem is not just stock picking.
The real problem is that most people never build a proper feedback loop for their own decisions.

That is why I built ai-invest-agent — an open-source AI investment review system designed to help investors record trades, review decisions, and turn messy trading behavior into structured learning.

The problem I wanted to solve

Most investing tools focus on one of these:

market data,
portfolio tracking,
news aggregation.

But very few tools focus on a more important question:

How do you actually improve your investing decisions over time?

In practice, many investors repeat the same mistakes because they don't systematically review:

why they entered a trade,
whether the thesis was valid,
whether the position sizing made sense,
whether the exit decision was emotional or disciplined.

I wanted something that works more like an investment reflection engine, not just a dashboard.

What ai-invest-agent does

At its core, the project combines three things:

1. Trade logging

You can record buy/sell decisions from A-shares, Hong Kong stocks, and US stocks.

ai-invest-agent --ticker 1810.HK --action buy --price 15.5 --shares 1000

This creates a structured record instead of leaving the decision buried in chat history, screenshots, or memory.

2. AI-powered review

The tool helps summarize your investing behavior and look for patterns such as:

win rate,
return attribution,
overtrading,
poor timing,
recurring mistakes.

Example:

ai-invest-agent --report 2024-01

This is the part I care about most.
The goal is not to make AI tell you what stock to buy.
The goal is to make AI help you become a better decision-maker.

3. Stock-level analysis

You can also run quick AI-assisted stock analysis:

ai-invest-agent --analysis AAPL

This gives you a lightweight view of strengths, risks, and key signals — useful as an input, not as a replacement for judgment.

The philosophy behind it

I don't think AI should replace investors.

I think AI should help investors do three things better:

remember what they actually did,
analyze why it worked or failed,
improve their next decision.

In that sense, this project is less about prediction and more about decision quality.

That is also why I describe it as an AI investment review system, not just an AI stock picker.

Why I made it open source

There are two reasons.

First, investing systems are deeply personal

Different people have different styles:

value investing,
momentum,
event-driven,
macro,
long-term conviction.

So the tool should be extensible, hackable, and customizable.

Second, open source creates better thinking

If more builders and investors contribute to the project, the system can evolve into something much more useful:

better review prompts,
better reporting structure,
better risk frameworks,
better integrations with data sources.

Current project structure

The repository is still intentionally simple:

ai-invest-agent/
├── agents/           # AI agent modules
│   ├── analyzer.py   # stock analysis
│   └── reporter.py   # review reports
├── data/             # data storage
├── scripts/          # CLI tools
└── tests/            # tests

The current focus is clarity and iteration speed rather than overengineering.

What I want to improve next

A few directions I want to explore:

better trade journaling templates,
stronger review frameworks,
risk scoring,
portfolio-level reflection,
smarter alerts for earnings and position management,
cleaner English documentation and onboarding.

Why this may matter

A lot of AI tools in investing are trying to be louder, faster, and more "intelligent."

I think a more useful direction is:

help people build a repeatable decision system.

If AI can help investors review better, think more clearly, and avoid repeating the same errors, that is already valuable.

Try it

GitHub:

AIPMAndy/ai-invest-agent

If you're interested in:

AI for investing,
decision journaling,
portfolio review,
open-source financial tooling,

I'd love your feedback.

And if you find the direction interesting, feel free to star the repo, open an issue, or contribute.