Skip to content
Four-Layer Progressive Memory Architecture for Self-Evolving Conversational AI Agents

Four-Layer Progressive Memory Architecture for Self-Evolving Conversational AI Agents

Huolala introduces a four-layer progressive memory architecture for conversational AI agents that transforms raw dialogue into structured cognitive profiles, enabling cross-channel memory, real-time personalization, and automatic strategy evolution, achieving 1.7pp conversion lift and 75% profile coverage in experiments.

Huolala Tech
Huolala Tech
Huolala Tech

Background

Huolala users interact across multiple touchpoints (App, mini-program, H5, phone, instant messaging) and exhibit long conversion journeys spanning days or weeks with 3–5 session interruptions. The system must remember the user's stage, previous refusals, true intent, and emotional state to deliver personalized communication strategies. Without memory, neither understanding nor effective action is possible.

Why a Memory System Is Needed

The Octopus Tragedy

Octopuses are individually intelligent but cannot transmit wisdom across generations; each must relearn everything. Current dialogue systems repeat this tragedy: every conversation starts from zero, cross-channel context is lost, and personalized insights scattered across thousands of sessions are never aggregated.

Real Incident Review

Analysis of 50 deleted instant-messaging conversations revealed that user churn stemmed not from surface-level strategy or prompt issues but from the lack of cross-channel, cross-session memory. The AI could not recall prior refusal reasons and mechanically applied "state A → strategy B" rules, pushing users away.

How Top Consultants Remember Users

"I don't need the client to say 'I refused three times'; from tone, reply intervals, and excuses I know whether they're truly busy, price-sensitive, not interested, or one more push will close."

Deconstructing this expert behavior reveals a four-layer cognitive chain:

Raw signals (voice, unprocessed facts)

Per-message intent/emotion judgment

Contextual decision: push now or wait

Long-term cognition: who the user is, preferences

Key insights: memory must be continuous (capture the full change process, not just outcomes) and layered (store raw data, observations, judgments, and long-term profiles in progressive layers).

Industry Common Practices and Their Limits

Most systems use a "pass-state" mode: flattening key events into flat tags (e.g., user_state=not_ordered, refusal_reason=busy, intent=high) injected as prompt variables. This works for simple tasks but fails for complex scenarios due to:

Data flattening: only conclusion tags stored, no process evidence (tone, refusal frequency)

Emotion irretrievable: literal current message only, cannot correct with history (e.g., "ok ok" as perfunctory)

Cross-session discontinuity: only last refusal recorded, not interruption stage/context

Cross-channel isolation: phone and IM store separate memories, treating same user as two strangers

Coarse personalization: cannot distinguish "truly busy" vs. "excuse", "price-sensitive" vs. "hassle-averse"

No self-evolution: strategy effect is a black box, optimization relies on manual review with 2–3 week cycles

Low token efficiency: irrelevant fields fully injected, key information missing, full history resent each turn

Four-Layer Progressive Memory Architecture

Core idea: upgrade "flat tags" to a progressive refinement pipeline "raw data → perception → judgment → long-term profile" where each layer builds on the previous.

Architecture Overview

L0 real-time storage → L1 near-real-time analysis (ms per message) → L2 real-time scheduling (per message) → L3 24h scheduled + real-time micro-adjustments
From "raw data" to "perception (intent understanding)" to "judgment" to "long-term cognition", each layer builds on the one above

Layer Definitions

L0 Data Foundation — Record only, no judgment: raw messages, full dialogue transcripts, event streams (100% scene fidelity)

L1 Perception Layer — Observe only, no decision: per-message intent (coarse + fine), emotion, backtrack signals, behavior completion

L2 Decision Layer — Sole scheduler: stage state machine, strategy library, rule library — decides "which path to take"

L3 Profile Layer — Long-term memory: 6 core user features (price sensitivity, trust, operation proficiency, preferred time slots, busy tags, reply style)

L0 Data Foundation — Record Only

Raw messages: every user/AI message text, timestamp, message ID

Full dialogue transcript: complete conversation flow for backtracking

L1 Perception Layer — Observe Only

Intent (coarse-grained + fine-grained)
Intent classification hierarchy
Intent classification hierarchy

L2 Decision Layer — Sole Scheduler

Decision layer state machine and strategy routing
Decision layer state machine and strategy routing

L3 Profile Layer — Offline Accumulation

24h scheduled: every 02:00 full recompute of all 6 dimensions (covering UPDATE) In-session real-time: every ≥5 user messages, immediate recompute of busy tag and reply style (high-frequency dimensions)
Profile layer computation schedule
Profile layer computation schedule

Cross-Channel Memory Integration

Identity layer: user ID as primary key linking phone and IM sessions

Profile layer: L3 profiles are channel-agnostic; price sensitivity, trust, etc. shared across channels, merged during nightly recompute

Stage bridging: phone-end user_state written to L0; IM opening reads last user_state to decide entry goal (order/claim/activate/share)

Memory Mechanism in Action

Decision & Strategy Generation Example

User Mr. Li sends "Why does it still cost money?":

Decision flow for price objection
Decision flow for price objection

Strategy Self-Evolution

Strategy evolution loop
Strategy evolution loop

Evaluation Metrics

Conversion: task conversion rate = converted users / reached users

Dialogue efficiency: average messages per successful conversion; AI response latency (message arrival → AI reply sent)

User experience: churn rate = churned / new users

Personalization: profile coverage = users with updated profiles / active users

Strategy self-evolution: strategy elimination rate = deprecated strategies / total strategies per cycle; strategy advancement rate = executions leading to next stage within 24h / strategy usage count

Experimental Results (2-week A/B test, account split)

Experiment info: Period: 2 weeks; Method: Account split

Conversion: Task conversion rate: Common Memory Strategy 58.3% → Progressive Memory Architecture 60.0% (+1.7pp)

Dialogue efficiency: Avg messages: 18.4 → 12.1 ; AI response latency: 0.25s → 0.45s (+0.2s)

User experience: Churn rate: 2.8% → 1.2% (-1.6pp)

Personalization: Profile coverage: — (no profile capability) → 75%

Strategy self-evolution: Strategy elimination rate: — (manual review only) → 1% (2 strategies deprecated); Strategy advancement rate: 72% → 80%

Summary: The progressive architecture trades a 0.2s per-turn latency increase for +1.7pp conversion, -1.6pp churn, and 75% profile coverage — a worthy full rollout.

Conclusion

Cognitive shift: The greatest gain is not just metric lifts but a paradigm shift. Octopuses must relearn each generation; AI can stand on accumulated shoulders, each generation understanding humans better.

Memory establishment: Moving from "passing tags" to "building memory" — AI's next breakthrough lies not in more accurate recognition but deeper understanding. Upgrading from L1 single-turn intent to L0-L3 cross-temporal reasoning returns context and time to AI, turning mechanical execution into empathetic communication with automatic strategy evolution.

Capability elevation: The "layered memory + cognitive flywheel" foundation applies across the full user lifecycle (acquisition, activation, retention, win-back) and across phone, IM, and any agent scenario requiring long-term understanding and continuous dialogue — evolving AI from single-scene tools into cognitive infrastructure that grows smarter with use.

Authors: AI Application Team | Zheng Qixin, Wu Hualong, Zhang Guangfa

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

PersonalizationAI agentsConversational AIMemory ArchitectureHuolalaSelf-Evolving SystemsCross-Channel MemoryProgressive Memory
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.