Your Agent Needs a Wiki and a Recording, Not a Bigger Desk

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: Like a company wiki / Notion. Holds "facts that stay true across any conversation": people, projects, customers, policies, decisions. The agent goes there 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. Both tools plug into them.

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 fill those two gaps are called GBrain and Lossless. Let's take them one at a time.

What they are

GBrain is like 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.

GBrain is that Notion. It holds facts that stay true across any conversation: people, projects, companies, decisions, timelines, and how they all connect.

It doesn't live inside any single chat. It sits outside, always available.

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 layer. It can back both GBrain and Lossless. But having a vector DB doesn't automatically give you either. Those are two different patterns built on top of it.

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. GBrain captures those things as markdown documents that all your agents share. 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 also has its own context-processing slot, but I haven't dug up the exact equivalent config from its repo yet. So I'm only writing the OpenClaw path here, the one I can actually verify. I'll add the Hermes one once I track it down.)

GBrain plugs in differently. It lives outside the runtime entirely:

• 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 a CLI or tool call, before acting

So Lossless is a plugin inside the runtime, GBrain is a shared brain outside the runtime. They sit in different places, but they're filling the same gap: "what should I know before I take this action?"

One honest aside: on my current runtime, openclaw plugins inspect lossless-claw still shows plugin not found. The gbrain command-line tool isn't installed either (the system can't find it). My local check script reports missing pieces. The contract file in the repo (docs/gbrain-integration.md) was written a while back, but the local wiring is still in progress. What I described above is what it looks like once it's working. Builder progress report. Not a finished demo.

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 company 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 (Martian Engineering). The runtime lossless-claw plugs into.

• Hermes: agent runtime. Also has a context-engine slot, but I haven't verified the exact equivalent config yet.

More of what I'm building lives at voxyz.ai.