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.
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-adjustmentsFrom "raw data" to "perception (intent understanding)" to "judgment" to "long-term cognition", each layer builds on the one aboveLayer 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)
L2 Decision Layer — Sole Scheduler
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)
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?":
Strategy Self-Evolution
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
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
