为什么内存架构比你的模型更重要

Source: Dev.to

大多数代理的失败并不是模型的失败，而是记忆的失败。

• 编码错误
• 存储噪声
• 检索混乱
• 修剪不对齐

如果你曾看到代理自信地检索出去年的策略，或因其上下文窗口被垃圾填满而产生幻觉，那就是在野外观察到的记忆漂移。本文为你提供一个结构化模型和代码模式，使记忆架构成为一等工程对象。

两个循环

内部循环 = 运行时行为
外部循环 = 架构演进

大多数框架只实现内部循环。这就是漂移悄然累积的原因。

class Agent:
    def inner_loop(self, task):
        encoded = self.memory.encode(task)
        self.memory.store(encoded)
        context = self.memory.retrieve(task)
        output = self.model.run(task, context)
        self.memory.manage(task, output)
        return output

    def outer_loop(self, logs):
        diagnostics = analyze(logs)
        self.memory.redesign(diagnostics)

内部循环负责学习。外部循环负责重新设计。如果两者缺一，你就相当于交付了一个从不升级学习方法的学生。

四间房

每个记忆系统都有四个组成部分。当出现问题时，调试房间——而不是代理。

class Memory:
    def encode(self, item):
        return embed(item)          # embedding model, chunking, feature extraction

    def store(self, vector):
        vector_db.insert(vector)     # vector DB, KV store, graph

    def retrieve(self, query):
        return vector_db.search(query, top_k=5)  # similarity search, reranking

    def manage(self, task, output):
        prune_stale()
        reindex()
        decay()

漂移检测器

def detect_drift(memory):
    return {
        "encoding_variance": variance(memory.embedding_stats),
        "storage_growth": memory.db.size(),
        "retrieval_accuracy": memory.metrics.retrieval_precision(),
        "pruning_errors": memory.metrics.prune_misses()
    }

如果检索准确率下降而存储增长激增，你就进入了经典的 slop 区域。

治理工具箱

治理并非合规，而是维护。

# === APPRENTICE LOOP (Weekly) ===
# Surface friction from runtime behavior
def apprentice_loop(agent, tasks):
    return [(task, agent.inner_loop(task)) for task in tasks]

# === ARCHITECT LOOP (Monthly) ===
# Redesign the structure that produced the friction
def architect_loop(agent, logs):
    agent.memory.redesign(analyze(logs))

# === FOUR ROOMS AUDIT (On Drift) ===
# Diagnose which room failed
def audit(memory):
    return {
        "encode": memory.encode_stats(),
        "store": memory.db.health(),
        "retrieve": memory.metrics.retrieval_precision(),
        "manage": memory.metrics.prune_misses()
    }

# === DRIFT WATCH (Continuous) ===
# Catch slop early
def drift_watch(memory):
    if memory.db.size() > MAX_SIZE:
        warn("Storage overgrowth")
    if memory.metrics.retrieval_precision() < THRESHOLD:
        warn("Retrieval drift")
    if memory.embedding_stats.variance < MIN_VARIANCE:
        warn("Encoding drift")

# === ARCHITECTURE LEDGER (Versioning) ===
# Track how memory evolves
def log_change(change):
    with open("architecture_ledger.jsonl", "a") as f:
        f.write(json.dumps(change) + "\n")

如果你不对记忆架构进行版本控制，你只差一次模式更改就会陷入混乱。

要点

随着代理变得更加自主，记忆系统成为真正的引擎——而不是模型、不是提示、也不是 RAG 流程。

架构即行为。

• 可预测的代理需要可预测的记忆。
• 可预测的记忆需要治理。
• 治理需要两个循环和四个房间。

关于本文背后的概念框架，请参阅 Substack 上的 The Two Loops 。