Token-Saving Memory Plugin Sick Memory: Just ¥0.9 per Day

After raising an AI character for a while, the most frustrating part isn't that the model isn't smart enough—it's that every new conversation requires it to get to know you all over again. You spend a lot of money, and it forgets who you are the moment it turns around. Sick Memory, introduced by Bilibili creator "大肥鱼呀" (Da Fei Yu Ya), is aimed squarely at this pain point—it wants AI to truly remember you while keeping down the token cost of repeatedly loading old content into context.

Two Ways Old Solutions Die: Dump Everything or Summarize

Before Sick Memory, memory solutions roughly split into two camps. One camp stuffs entire chunks of old chat history into the context, with costs climbing higher as the conversation goes on. The other writes diary-style summaries—seemingly cheaper, but losing the context of why something was said at the time. Essentially, both make the same trade-off: either expensive or distorted.

Sick Memory takes a third path—building a unified hub. No matter which platform a message comes from, identity, drawing, and speaking boundaries are first clarified in the hub. Facts aren't overwritten, but understanding of the same matter can have versions: you tell it "the interview moved to Thursday," the old original wording stays, and the new understanding connects to a new version.

The context window is the upper limit on the total tokens a large model can "see" in a single inference, including system prompts, historical dialogue, and current input. Stuffing entire old chats into the context is expensive because tokens are billed by input length, and the attention mechanism's computational cost grows approximately quadratically with sequence length—the more turns, the higher the cost. Summary-style memory compresses tokens but is a lossy compression: the summarization model cannot predict which detail will be asked about later, and easily erases key qualifiers like time, people, and conditions, leading to answers that seem to remember but are actually distorted. This is the technical root of the "either expensive or distorted" trade-off, and the starting point Sick Memory tries to circumvent with structured memory plus on-demand retrieval.

Memory Isn't Distributed Evenly—It's Ranked by Relevance

Sick Memory's memory mechanism has a key judgment: memory isn't distributed evenly. What's relevant to the current topic, what you've mentioned repeatedly, and what carried strong emotion at the time gets prioritized.

When the user asks about the interview, it first uses clues in a sentence and connections to related memories to find candidates, then checks whether the evidence is sufficient. When necessary, it can look back at the corresponding valid memory by original wording number, but it won't shove entire old chats directly into the current conversation. Finally, it judges how far this memory can go, bringing in only the part the answer needs.

The core logic of this pipeline is: finding something doesn't mean you can say it casually. In the video, the creator mentions borrowing ideas from how operating systems handle terminals—when a new message arrives, first judge whether the current task should yield, then put the work to be done back into the corresponding memory. For example, if it's about to reply on QQ and a new message arrives, it handles the new one first, and the other memory won't be interrupted along with it.

"Ranking by relevance" here typically involves two steps: vector retrieval and reranking. First, each memory is encoded into a vector and stored in an index; at query time, the vector of the current utterance is used for similarity recall of a batch of candidates, then rules or a small model rerank the candidates by relevance, timeliness, and evidence completeness, sending only the top few into the context. "Looking back by original wording number" means memories are stored as original fragments with unique IDs; retrieval hits the index rather than the original text, and when needed the original wording can be retrieved by ID for verification, avoiding secondary distortion from retrieval summaries. This "recall first, verify, then trim" pipeline is a common engineering practice for current memory-augmented generation (RAG for conversational memory) and a key step in controlling token costs.

Dream Organization: Queuing Up the Energy Left Over from the Day

Sick Memory has a mechanism called Dream. It's not about making the AI dream out of thin air, but about queuing up the energy left over from the day by importance and organizing what's worth remembering within a budget. More stable duplicate content can be merged, outdated understanding connects to new versions, and unfinished items are left for next time.

Models may be used here, but daily queries won't make extra model calls just to find a single memory—this is the key design for controlling costs.

The Dream mechanism corresponds to offline consolidation of memory: during online conversation, only lightweight writes are done, deferring heavy work like organizing, deduplication, merging, and expiration tagging to background batch processing, so it doesn't consume the latency and cost budget of real-time responses. "Organizing within budget" means consolidation itself has token or compute limits; the system must decide by importance which memories are worth spending model calls to merge and which to shelve for now. This resembles the analogy of memory consolidation during human sleep: daytime experiences are temporarily stored, then screened, compressed, and integrated with old knowledge offline. In engineering terms, it moves expensive model calls from "every query" to "low-frequency organization," which is the core design for controlling long-term memory costs.

Personality Isn't a Single Setting—It's the Accumulation of Verifiable Behavior

Many AI characters fix their persona with a single line like "you are a gentle person." Sick Memory doesn't plan to do that. It focuses on verifiable behavior: whether it admits not knowing, whether it corrects mistakes, whether it protects your privacy. Only as these behaviors accumulate does the AI gradually form an impression of itself. What changes afterward is the same personality line continuing to the next half, rather than recreating "it" anew with every window switch.

Cost: The Real Context Behind ¥0.9

The "¥0.9 per day" in the video title needs to be viewed in a specific context. According to usage records shown by the creator, the original screenshot was ¥5.59, later around ¥2 for daily use; for high-intensity use on a relay station there's also a record of just over ¥0.8, and the account is actually settled in RMB. The creator explicitly states these conditions differ and cannot be directly calculated as Sick Memory reducing costs by some percentage—there are currently no same-benchmark screenshots.

What's really being saved is the cost of "repeatedly loading large amounts of old content just to get to know me." In other words, what Sick Memory does isn't make the AI forget more—it's make it remember selectively, with evidence.

A "relay station" generally refers to a third-party API proxy service that aggregates and forwards interfaces from multiple models, settled in RMB or credits, often cheaper than official direct connections, but with billing standards, model versions, and caching strategies that may differ from official ones. Therefore, differences in amounts across screenshots may come from usage intensity, channel unit prices, whether prompt caching is hit, and different ratios of input to output tokens. Prompt caching bills repeated prefixes at a discount, significantly affecting the actual cost of "repeatedly loading old content"—which is why a unified benchmark is essential when evaluating a memory solution's cost savings. When comparing costs, the model, channel, conversation turns, and cache settings should be fixed; otherwise the numbers aren't comparable.

Getting Started

Currently you can experience the memory library and memory star map through the Estabot and QQ paths; more entrances may appear later, but the project hopes users always encounter the same "it." For users who raise AI characters long-term and care about token costs, this is a solution worth watching.

One-line Summary

Sick Memory uses a unified hub and on-demand retrieval to let AI remember you selectively, with evidence, cutting the token cost of repeatedly loading old content.

Paragraph Summary

The article introduces Sick Memory, recommended by Bilibili creator "大肥鱼呀," targeting the pain points of AI characters forgetting users with every new conversation and repeatedly loading old content to drive up token costs. It abandons the two old approaches of "stuffing the context" and "diary summaries," instead using a unified hub to distinguish identity, drawing, and speaking boundaries—facts aren't overwritten but understanding can have versions. Memory is ranked by topic relevance, repetition frequency, and emotional intensity; it first finds candidates, then verifies evidence by original wording number, bringing in only what the answer needs. The Dream mechanism organizes and merges memories offline within budget, with no extra model calls during daily queries. Personality accumulates through verifiable behaviors like admitting not knowing and correcting mistakes. The article stresses that ¥0.9/day must be understood in light of usage records under different conditions—it's not a same-benchmark comparison.