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: "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. "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.