# Your Agent Needs a Wiki and a Recording, Not a Bigger Desk
**作者**: Vox
**日期**: 2026-05-17T16:06:32.000Z
**来源**: [https://x.com/Voxyz_ai/status/2056043700757705122](https://x.com/Voxyz_ai/status/2056043700757705122)
---
Every agent builder eventually hits the same wall. You can pile on context all you want. The agent still forgets.
This piece covers GBrain and Lossless: what they are, why and when you'd use them, what using them feels like, and how to wire them into your agent.
Quick glossary first:
- Agent memory: Your AI agent's overall ability to remember things. Covers what it currently sees, what it can look up, and what it can dig up from earlier.
- Context window: Everything the model can directly see in the current turn. Like paper spread out on its desk. Bigger window, bigger desk.
- GBrain: A search/index layer on top of your wiki / markdown repo. Lets agents query "facts that stay true across any conversation" (people, projects, customers, policies, decisions) before acting.
- Lossless: Like a full meeting recording. The raw messages of the current conversation are kept intact. Even when the model only sees a summary, it can dig back to the original.
- Context engine: The slot inside an agent runtime that handles "how conversation history gets compressed, and how to fetch it back". Lossless plugs in here.
- OpenClaw / Hermes: Two agent runtimes. Think of them as the "operating system" you run your agents on. GBrain can be reached from both through CLI, MCP, skills, or plugins.
Here's what that wall looks like in practice:
> Me: "Remember last time with Acme? We decided not to discount below X."
> Agent: "Which customer is Acme? Which decision?"
It read every word. It just didn't have anywhere to look it up.
Bigger context only makes the desk wider. It doesn't give the agent a wiki, and it doesn't give it a recording.
The tools that let agents reach those two layers are called GBrain and Lossless. Let's take them one at a time.
## What they are
GBrain is the query layer on top of a company wiki / Notion.
When a new hire shows up on day one, you don't make them read every Slack message in history. You hand them a Notion link: customer list here, policy there, last quarter's goals over there.
The wiki holds the facts (people, projects, companies, decisions, timelines, and how they all connect). GBrain is what makes that wiki queryable from an agent. It indexes the markdown, builds the connections, and lets the agent ask before acting.
The wiki lives in your repo. GBrain sits outside the runtime, always reachable.
Lossless is like a full meeting recording.
You sit through a 2-hour meeting. The secretary writes a 5-minute summary afterward. The summary loses 95% of the detail, but it's enough for a quick skim.
Then 30 minutes later your boss asks: "What was that number you said at minute 47, was it 12 or 21?" The summary won't save you. You need to go back and play the recording.
Lossless is that recording. It keeps the raw messages of the current conversation intact. What the model sees right now is a compressed summary (because the window can't hold everything), but it can pull up the original.
Simple version:
- GBrain = company knowledge base (across conversations)
- Lossless = current meeting recording (within this run)
Two common misconceptions worth calling out:
1. "I shoved 30 days of conversations into the model, that should be enough, right?": That does half of Lossless (keeping the conversations) and none of GBrain (nothing's organized by person, project, or decision, and you can't query for a specific fact). The model can read it, sure, but that doesn't mean it can find the line that matters.
2. "I'm using a vector DB to store all the history": A vector DB is a storage/search layer. It can be part of a memory system, but it doesn't automatically give you either pattern. GBrain and Lossless are two patterns built on top of storage, not storage by themselves.
## Why you'd use them, and when
Why you'd use GBrain: After running agents for a while, you notice the real cost is re-teaching the agent "how we do this kind of thing at this company" every single time. Tokens are the cheap part. Your team writes those things as markdown docs in a repo. GBrain indexes them so all your agents share the same brain. A new agent taking over a role doesn't have to redo onboarding.
When you'd actually use it:
- A new agent talking to an old customer or old project for the first time
- The same agent picking up across days, returning to a task from 2 weeks ago
- Multiple agents collaborating, A finishes something and hands it to B, B needs to know the context
- Swapping agents on the team, the new one takes the old one's seat
Common thread: "between conversations".
Why you'd use Lossless: Every agent runtime eventually has to truncate or compress history at some point. Otherwise the window can't hold it. Once truncated, that detail is normally lost for good. Lossless makes the compressed parts searchable and re-openable. The original doesn't disappear the moment the model summarizes it.
When you'd actually use it:
- A single long conversation (50+ back-and-forths)
- After the model auto-compresses history (older stuff gets merged into a summary)
- The user suddenly references something specific from 30 minutes ago
- Debugging: you want to see what the agent was actually basing that decision on
Common thread: "within a conversation".
If your agent use case wraps up in a few rounds, Lossless won't change much for you.
If your agent only ever serves one customer or one project, GBrain won't change much for you.
The moment both layers really start paying off: when the agent, like any coworker, has to work across conversations, across tasks, across team members.
## What it feels like in practice
Without GBrain, an agent treats every old customer like a stranger:
> Agent: Which customer is this? What did we talk about before? What's the policy?
With GBrain, the opener looks like this:
> Agent: I see this is Acme. Last time you decided not to discount below X. This request is X + 10%, that's fine. Want me to update the customer note too?
It checked the wiki before walking into the room.
Without Lossless, in a long conversation, after a while you say "change it based on that schema we just talked about" and you get:
> Agent: Which schema? Can you say it again?
Because the window can't hold everything, the old stuff got compressed away.
With Lossless:
> Agent: You mean the bit from 35 minutes back. We initially decided to use UUID (a kind of ID format), then 12 minutes later you switched to ULID (another kind). Want me to apply ULID?
It can rewind the recording.
## How to wire them into your agent
These two tools go down two completely different paths.
Lossless plugs into the "context-processing layer" inside the runtime. Runtimes like OpenClaw leave a slot here for handling how the conversation gets compressed when it runs long, and how to dig the original back out when needed. The default usually just truncates: too much, drop it. The lossless-claw plugin swaps that hard truncation for a structured summary that stays searchable, with the original text still recoverable.
In OpenClaw, one config line does it: point contextEngine at lossless-claw.
Hermes has the same kind of slot too. The Hermes path is lossless-hermes-py: install it with `hermes plugins install mssteuer/lossless-hermes-py`, then set `context.engine: lossless-hermes`.
GBrain plugs in differently. Its core lives outside the runtime: a brain repo, a database, and a CLI/MCP surface the agent can call into.
- Your code repo has markdown pages holding the "facts that don't change much"
- GBrain indexes those markdown pages so they're searchable, and builds connections between people, projects, and decisions
- The agent reaches GBrain through CLI, MCP, skills, or runtime plugins, usually before acting
So Lossless is a context engine inside the runtime. GBrain is the shared brain layer the runtime can call into. They sit in different places, but they're filling the same gap: "what should I know before I take this action?"
## 5-row diagnostic: next time your agent "forgets", run through this
Don't start by asking whether the context was big enough. Walk through these 5 layers in order:
- Capture (did it make it in?): Did this fact ever enter any system?
- Lossless (did the conversation survive?): Did the earlier conversation get preserved, or did compression eat it?
- GBrain (can it be fetched across conversations?): Can you query across conversations by person, project, or decision?
- Ranking (did the right one surface?): Before acting, did the right fact surface to the top?
- Task (was the task clear?): Did the current task tell the agent why this fact matters?
A lot of the time you'll find the bug lives in the third or fourth layer, not the first two.
## Wrap-up
Bigger context can't fix the memory bug. What it does is make the workbench wider.
The real fix is giving the agent two things:
- GBrain: the query/index layer on top of your wiki, across conversations
- Lossless: the recording within the current conversation
The two together make the agent feel like a coworker who knows how your company actually runs, and remembers where you left off.
So which one is your agent right now? The intern with a huge desk but no way to look anything up? Or the coworker with a smaller desk who knows to check the wiki and can replay what was just said?
Next: which layer are you going to wire up first?
## References
- GBrain: shared brain layer. Indexes markdown knowledge across sessions, so agents can query people, projects, and decisions before acting.
- lossless-claw: OpenClaw context-engine plugin. Compresses conversation history into a structured summary while keeping the original text searchable and re-openable.
- OpenClaw: agent runtime. The runtime lossless-claw plugs into.
- Hermes: agent runtime. Also has a Lossless-style context-engine path through lossless-hermes-py.
More of what I'm building lives at voxyz.ai.
## 相关链接
- [Vox](https://x.com/Voxyz_ai)
- [@Voxyz_ai](https://x.com/Voxyz_ai)
- [59K](https://x.com/Voxyz_ai/status/2056043700757705122/analytics)
- [lossless-claw](https://github.com/Martian-Engineering/lossless-claw)
- [GBrain](https://github.com/garrytan/gbrain)
- [lossless-claw](https://github.com/Martian-Engineering/lossless-claw)
- [OpenClaw:](https://github.com/openclaw/openclaw)
- [Hermes:](https://github.com/nousresearch/hermes-agent)
- [voxyz.ai](https://voxyz.ai/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [12:06 AM · May 18, 2026](https://x.com/Voxyz_ai/status/2056043700757705122)
- [59.2K Views](https://x.com/Voxyz_ai/status/2056043700757705122/analytics)
- [View quotes](https://x.com/Voxyz_ai/status/2056043700757705122/quotes)
---
*导出时间: 2026/5/18 14:31:07*
---
## 中文翻译
# 你的 Agent 需要的是 Wiki 和录音，而不是更大的桌子
**作者**: Vox
**日期**: 2026-05-17T16:06:32.000Z
**来源**: [https://x.com/Voxyz_ai/status/2056043700757705122](https://x.com/Voxyz_ai/status/2056043700757705122)
---
每个 Agent 开发者最终都会撞上同一堵墙。你可以拼命塞给它上下文。Agent 还是会忘。
这篇文章将介绍 GBrain 和 Lossless：它们是什么、为什么以及何时使用它们、使用起来的感觉如何，以及如何将它们接入你的 Agent。
先来快速了解一下术语：
- Agent 记忆：你的 AI Agent 记忆事物的整体能力。涵盖了它当前看到的、可以查阅的，以及可以从过去挖掘出的内容。
- 上下文窗口：模型在当前轮次中能直接看到的所有内容。就像摊在桌子上的纸张。窗口越大，桌子越大。
- GBrain：构建在你的 wiki / markdown 仓库之上的搜索/索引层。它让 Agent 能够在行动前查询“在任何对话中都成立的真理”（人员、项目、客户、政策、决策）。
- Lossless：就像完整的会议录音。当前对话的原始消息被完整保留。即使模型只看到了摘要，它也能回溯到原始内容。
- 上下文引擎：Agent 运行时内部的一个插槽，用于处理“对话历史如何被压缩，以及如何将其取回”。Lossless 就接入在这里。
- OpenClaw / Hermes：两个 Agent 运行时。可以将它们视为运行 Agent 的“操作系统”。两者都可以通过 CLI、MCP、技能或插件访问 GBrain。
以下是这堵墙在实践中的样子：
> 我：“记得上次和 Acme 吗？我们决定折扣不能低于 X。”
> Agent：“Acme 是哪个客户？哪个决定？”
它读到了每一个字。只是它没有任何地方可以查找。
更大的上下文只是把桌子变宽了。它没有给 Agent 一个 wiki，也没有给它录音。
让 Agent 能够触及这两层的工具叫做 GBrain 和 Lossless。让我们一个一个来看。
## 它们是什么
GBrain 是构建在公司 wiki / Notion 之上的查询层。
当新员工在第一天入职时，你不会让他们阅读历史上每一条 Slack 消息。你会给他们一个 Notion 链接：客户名单在这里，政策在那里，上个季度的目标在另一边。
Wiki 保存着事实（人员、项目、公司、决策、时间线，以及它们之间的联系）。GBrain 让这个 wiki 可以被 Agent 查询。它索引 markdown 文档，建立联系，并让 Agent 在行动前进行询问。
Wiki 存在于你的仓库中。GBrain 位于运行时之外，始终可访问。
Lossless 就像完整的会议录音。
你坐完一个两小时的会议。秘书事后写了一个 5 分钟的摘要。摘要丢失了 95% 的细节，但对于快速浏览来说足够了。
30 分钟后你的老板问：“你在第 47 分钟提到的那个数字是多少，是 12 还是 21？”摘要救不了你。你需要回去播放录音。
Lossless 就是那个录音。它将当前对话的原始消息完整保留。模型现在看到的是一个压缩摘要（因为窗口装不下所有内容），但它可以调出原始内容。
简单来说：
- GBrain = 公司知识库（跨对话）
- Lossless = 当前会议录音（本次运行内）
有两个常见的误区值得指出：
1. “我把 30 天的对话都塞进了模型，这应该够了吧？”：这完成了 Lossless 的一半（保留对话），但没有完成 GBrain 的任何部分（没有按人员、项目或决策组织，也无法查询特定事实）。模型当然可以阅读，但这并不意味着它能找到关键的那一行。
2. “我在用向量数据库存储所有历史”：向量数据库是一个存储/搜索层。它可以是记忆系统的一部分，但不会自动提供这两种模式。GBrain 和 Lossless 是构建在存储之上的两种模式，而不是存储本身。
## 为什么以及何时使用它们
为什么使用 GBrain：在运行 Agent 一段时间后，你会发现真正的成本在于每次都要重新教 Agent “我们在公司是如何处理这类事情的”。Token 只是廉价的部分。你的团队已经把这些内容写成了仓库里的 markdown 文档。GBrain 对它们进行索引，让你的所有 Agent 共享同一个大脑。一个接手某个角色的新 Agent 不需要重新进行入职培训。
你实际上会在何时使用它：
- 一个新 Agent 第一次与老客户或老项目对话
- 同一个 Agent 跨天继续工作，回到两周前的任务
- 多个 Agent 协作，A 完成了某件事并移交给 B，B 需要了解背景
- 团队中交换 Agent，新的接替旧的位置
共同点：“在对话之间”。
为什么使用 Lossless：每个 Agent 运行时最终都必须在某一点截断或压缩历史。否则窗口装不下。一旦截断，那些细节通常会永久丢失。Lossless 使被压缩的部分可搜索且可重新打开。原始内容不会在模型总结它的那一刻消失。
你实际上会在何时使用它：
- 单次长对话（50+ 轮来回）
- 在模型自动压缩历史之后（旧内容被合并为摘要）
- 用户突然引用 30 分钟前提到的具体内容
- 调试：你想看看 Agent 实际上是基于什么做出那个决定的
共同点：“在对话内部”。
如果你的 Agent 用例只需几轮就能结束，Lossless 对你来说改变不大。
如果你的 Agent 只服务于一个客户或一个项目，GBrain 对你来说改变不大。
当这两层真正开始产生回报的时刻是：当 Agent 像任何同事一样，必须跨越对话、跨越任务、跨越团队成员进行工作时。
## 实际使用中的感觉
没有 GBrain 时，Agent 会把每个老客户当作陌生人：
> Agent：这是哪个客户？我们之前谈了什么？政策是什么？
有了 GBrain，开场白是这样的：
> Agent：我看这是 Acme。上次你决定折扣不能低于 X。这次请求是 X + 10%，没问题。需要我也更新一下客户备注吗？
它在进屋之前先查了 Wiki。
没有 Lossless 时，在长对话中，过了一会儿你说“根据我们刚才讨论的那个 schema 进行修改”，你会得到：
> Agent：哪个 schema？你能再说一遍吗？
因为窗口装不下所有内容，旧的东西被压缩掉了。
有了 Lossless：
> Agent：你是说 35 分钟前的那一点。我们最初决定使用 UUID（一种 ID 格式），然后 12 分钟后你改成了 ULID（另一种格式）。要我应用 ULID 吗？
它可以倒带录音。
## 如何将它们接入你的 Agent
这两个工具走的是两条完全不同的路径。
Lossless 接入运行时内部的“上下文处理层”。像 OpenClaw 这样的运行时在这里留有一个插槽，用于处理当对话过长时如何压缩，以及如何在需要时挖掘原始内容。默认通常只是截断：太多，扔掉。lossless-claw 插件用结构化摘要替换了这种硬截断，摘要保持可搜索，且原始文本仍可恢复。
在 OpenClaw 中，一行配置就能搞定：将 contextEngine 指向 lossless-claw。
Hermes 也有同样的插槽。Hermes 的路径是 lossless-hermes-py：使用 `hermes plugins install mssteuer/lossless-hermes-py` 安装，然后设置 `context.engine: lossless-hermes`。
GBrain 的接入方式不同。它的核心位于运行时之外：一个大脑仓库、一个数据库，以及一个 Agent 可以调用的 CLI/MCP 接口。
- 你的代码仓库里有包含“不会经常变化的事实”的 markdown 页面
- GBrain 索引这些 markdown 页面，使其可搜索，并在人员、项目和决策之间建立联系
- Agent 通过 CLI、MCP、技能或运行时插件访问 GBrain，通常在行动之前
所以，Lossless 是运行时内部的上下文引擎。GBrain 是运行时可以调用的共享大脑层。它们位于不同的地方，但填补的是同一个缺口：“在采取这个行动之前，我应该知道什么？”
## 5 行诊断：下次你的 Agent “忘记”时，过一遍这个
不要一开始就问上下文是否足够大。按顺序过一遍这 5 层：
- 捕获（它进来了吗？）：这个事实是否进入过任何系统？
- Lossless（对话保留下来了吗？）：早期的对话是否被保留了，还是被压缩吃掉了？
- GBrain（可以跨对话获取吗？）：你可以按人员、项目或决策跨对话查询吗？
- 排序（正确的那个浮上来了吗？）：在行动之前，正确的事实浮到顶了吗？
- 任务（任务清晰吗？）：当前任务是否告诉了 Agent 为什么这个事实很重要？
很多时候，你会发现 bug 出在第三或第四层，而不是前两层。
## 总结
更大的上下文无法修复记忆 bug。它做的是让工作台更宽。
真正的解决方案是给 Agent 两样东西：
- GBrain：构建在你的 wiki 之上的查询/索引层，跨对话
- Lossless：当前对话内部的录音
这两者结合在一起，让 Agent 感觉像一个真正懂得公司如何运作，并且记得你之前停在哪里的同事。
那么，你的 Agent 现在是哪一个？是有一个巨大桌子但无法查阅任何东西的实习生？还是那个桌子更小，但知道查阅 Wiki 并能重播刚才所说内容的同事？
下一步：你要先接入哪一层？
## 参考
- GBrain：共享大脑层。索引跨会话的 markdown 知识，以便 Agent 在行动前查询人员、项目和决策。
- lossless-claw：OpenClaw 上下文引擎插件。将对话历史压缩为结构化摘要，同时保持原始文本可搜索且可重新打开。
- OpenClaw：Agent 运行时。lossless-claw 插入的运行时。
- Hermes：Agent 运行时。也有通过 lossless-hermes-py 实现的 Lossless 风格上下文引擎路径。
我正在构建的更多内容位于 voxyz.ai。
## 相关链接
- [Vox](https://x.com/Voxyz_ai)
- [@Voxyz_ai](https://x.com/Voxyz_ai)
- [59K](https://x.com/Voxyz_ai/status/2056043700757705122/analytics)
- [lossless-claw](https://github.com/Martian-Engineering/lossless-claw)
- [GBrain](https://github.com/garrytan/gbrain)
- [lossless-claw](https://github.com/Martian-Engineering/lossless-claw)
- [OpenClaw:](https://github.com/openclaw/openclaw)
- [Hermes:](https://github.com/nousresearch/hermes-agent)
- [voxyz.ai](https://voxyz.ai/)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [12:06 AM · May 18, 2026](https://x.com/Voxyz_ai/status/2056043700757705122)
- [59.2K Views](https://x.com/Voxyz_ai/status/2056043700757705122/analytics)
- [查看引用](https://x.com/Voxyz_ai/status/2056043700757705122/quotes)
---
*导出时间: 2026/5/18 14:31:07*