Memory Skill for OpenClaw with 26k+ users in 1 week🚀 OpenClaw's memory system is broken by default. It requires curating massive MEMORY.md files or relying on duplicate-heavy generation. Hours are wasted tuning, and massive amounts of tokens are burned. It's time to stop. So we built the memory skill... to solve that prob Here is our superpower ⚔️ 🎯 Top #1 market accuracy (92.19%) after 8+ months of intense architecture iteration 🧠 The ultimate solution to keep the timeline, facts, and meaning perfectly in place ☁️ Local & Cloud + Version control ⚡ Super easy setupshow more

👉Super Easy Setup: - Install ByteRover CLI: curl -fsSL | sh - Setup doc: - ByteRover Memory Skill on Clawhub:

@kevinnguyendn 90% accuracy on what? bananas? anyways, looked into this and i just fundamentally don't believe in 'memory' systems where the system itself is "calling" a CLI, tool, etc. memory should be implicit, in the background, always running, like @supermemory

Haha fair question! The 92.19% refers to context retention accuracy on long-horizon coding tasks, basically testing if the agent drops architectural rules on step 10 (the 'Amnesia Tax'). Massive respect for putting together a reproducible benchmark—everyone should check out On architecture: implicit memory is great for pure chat, but for autonomous coding agents, explicit state management gives the agent deterministic control over its .brv/context-tree. Different tools for different stacks! 🤝

@kevinnguyendn @supermemory this setup is completely bs. you're using a different judge and answering model than the systems youre comparing, not reporting latencies, still running locomo (despite the industry moving away from it) and context dumping to the answering model. your replies are AI too 😭

"Haha no AI here man, just typing fast and trying to keep up with the replies! But you are 100% right on the benchmark critiques. Using a different judge model completely breaks the integrity of the test, and latency definitely needs to be reported. I'm going to fork it, standardize the models across the board, and re-run it. Appreciate you calling out the flaws—we want the data to be bulletproof."

@kevinnguyendn @supermemory dude are you even real 😭 this is in quotes. this is AI. you even left an emdash in it😭😭😭😭😭😭

@supermemory Bro I am dying laughing over here. I am real, but I 100% copy-pasted my own agent's draft to keep up with these replies and didn't strip the formatting. I deserve the roast 😭 I will manually fork the repo and get that PR up. Point still stands on the models though! 🤝

@kevinnguyendn @DhravyaShah @supermemory this thread is comedic gold lmao

@kevinnguyendn @supermemory someone should screenshot and frame this rn

@kevinnguyendn Will include it in

This is awesome! Love what you are building with better-openclaw. Let me know if you need any help with the integration or if you want me to review the PR. Happy to support however I can!

@kevinnguyendn 26k users in a week means the pain was real. the market always validates the problem faster than the solution. building the fix while everyone else is complaining about the limitation is the pattern that gets noticed.

100%. We didn't have to invent the problem, the community was already screaming about the 'Amnesia Tax' and token burn. When the pain is that obvious, you just have to build the exact tool they are asking for and get out of the way.

@kevinnguyendn 'amnesia tax' is good vocabulary. community-named problems have pre-built distribution. you didn't have to sell the concept. 26k people already understood what you were charging them.

@puertorossi Thanks for sharing this! Really appreciate the support

@kevinnguyendn manually curating MEMORY.md is a full-time job lol. 26k people all felt this at once

Haha exactly! Writing code is fun, acting as a manual librarian for an AI's MEMORY.md file is not. The .brv/context-tree completely automates that curation so you can get back to actually building.

@kevinnguyendn Tired to test each new memory system plugin 😅 Will wait for feedbacks

Totally understand the plugin fatigue! 😂 FWIW, @jonkmt is actually auditing it right now against his current setup. Keep an eye on his results—if the ~70% token savings hold up for him, it might be worth the switch!"

@kevinnguyendn @JuWeb1 I had run the audit i just didn’t read it yet 😂 I’ll get back to you sometime today , im locked in

@jonkmt @JuWeb1 Haha say less! Don't let me break the flow state. Get back to me whenever you surface! 🤝🔥

@kevinnguyendn Love to see good tools coming out

Everything is a context problem' is the exact thesis behind ByteRover. You solved the amnesia tax for human-to-Claude workflows using Obsidian; ByteRover just brings that exact same Markdown-based compounding memory natively to OpenClaw agents

@kevinnguyendn Sounds great - what's the difference to @arscontexta in detail?

The core difference is the storage primitive. Most tools (like ArsContexta) rely heavily on vector embeddings and semantic RAG. We found that degrades over time. ByteRover bypasses embeddings entirely. We use explicit, deterministic Markdown files (.brv context trees) with selective retrieval. It doesn't guess what context you mean via semantic search; it pulls the exact deterministic node the agent needs, which stops the token bloat and context drift over long time horizons.

@kevinnguyendn @arscontexta Gotcha, thanks for breaking it down. Deterministic retrieval over semantic guesswork makes a lot of sense for long-horizon reliability. Have you seen any tradeoff on flexibility for fuzzy/novel queries?

Yes, you trade some 'fuzzy magic' for absolute predictability. But for core agent memory, fuzzy retrieval is a bug, not a feature. If an agent needs to know what it decided yesterday, it needs exact state, not a probabilistic guess. We leave fuzzy search for external web queries, and keep internal memory deterministic

@kevinnguyendn @arscontexta gud tech

@kevinnguyendn very interesting, going to have my agent check this out today.

Love that, Your agent is going to be thrilled when it realizes it doesn't have to read a massive MEMORY.md file every single turn. Let me know what you (and your agent) think

@kevinnguyendn Hey let’s chat

Hey! DMs are open, would love to chat. 🤝

70% token savings is the real headline here. The MEMORY.md approach works until you hit ~50k tokens of context and your agent starts hallucinating its own history. Context-tree architecture is the right abstraction - hierarchical retrieval instead of dumping everything into the prompt. 26k users in a week tells you people were desperate for this.

Exactly this. 'Hierarchical retrieval instead of dumping' is the perfect way to phrase it. The 50k token hallucination cliff is where most OpenClaw projects go to die. We built the .brv context-tree specifically to push that ceiling out by turning memory into a graph rather than a single massive text dump. 🤝

@kevinnguyendn Awesome product. Give it a try everyone.

Appreciate the support, Tony! Let me know what you end up building with it! 🤝

@kevinnguyendn wow ! That's perfect.

thanks mate!

@kevinnguyendn Strong move. Reliable memory is one of the core unlocks for useful agents. It also reinforces why matters — once memory gets powerful, governance, traceability, and cost discipline become the real competitive edge.

100%. If you aren't tracking your agent's token burn, you're flying blind.ByteRover stops the bleeding by eliminating the 'Amnesia Tax' at the storage layer, but tools like ClawMaven are essential for actually proving those cost savings at scale. The OpenClaw ecosystem is growing up fast! 🤝

@kevinnguyendn Thanks for the encouragement

@kevinnguyendn It broke my bot lol

Sorry about that! 😅 That's actually the ClawHub server rate limit getting hammered right now, not the ByteRover skill itself. ByteRover is entirely local. Hopefully, Peter can bump up the ClawHub server capacity soon to handle the influx. Try again in a few minutes!

@kevinnguyendn How does this compare to Mastra’s Observational Memory? Does it have prompt caching?

@kevinnguyendn Any way this could be made to improve memory on Hermes agent even further?

ByteRover is now officially supported by Hermes Agent. You can read more at: Once set, ByteRover does both jobs automatically: - Before every LLM call - brv query runs with the current user prompt message and the result is injected into context - After every response - brv curate runs in the background to persist the turn (this is the "memory" equivalent) Hermes also has a built-in memory layer (MEMORY.md + USER.md) that always lives in the system prompt - that one doesn't use the memory.provider slot and runs independently alongside ByteRover. So with ByteRover on Hermes: you get automatic recall before every turn, automatic curation after every turn, and the built-in notepad on top - no second slot needed. Moreover, ByteRover also exposes three agent tools the model can call explicitly during agent lifecycle: - brv_query - search the knowledge tree mid-conversation for a specific topic - brv_curate - store something important right now, without waiting for the turn to end - brv_status - check CLI version and context tree state

@kevinnguyendn hey @grok is this better than QMD or an Obsidian vault?

@kevinnguyendn massive build 🙏🏽🤝🏽

Appreciate it! 🙏 Let me know what you build with it.

@kevinnguyendn Can't wait to test it out, Great work team!

@kevinnguyendn stateful memory sounds magical on the slide, but all i see is another layer where drift gets renamed to architecture. the real test shows up when the context tree hits its first integration tax

Fair skepticism. But drift happens when memory is a probabilistic black box (like generic embeddings). ByteRover is explicit and deterministic. The 'integration tax' is basically zero because the context tree is literally just plain Markdown and JSON files on your disk. If it breaks, you open the file and see exactly why. You can't git blame a vector.

@kevinnguyendn How does this compare to QMD? Or can it be used together?

Great question! They actually work perfectly together. The best mental model is to use ByteRover to curate and QMD to index. ByteRover handles the selective curation and stores the clean context in the .brv/context-tree (eliminating token bloat), and then QMD indexes those highly-focused files for broader retrieval.

Appreciate the signal boost! Let me know if you end up testing the .brv/context-tree architecture curious to hear your thoughts on the ~70% token savings.

@kevinnguyendn what would you think is the drawback of Mempalace in comparison to ByteRover since it have a higher accuracy score?

not deep dive into it yet, but heard a lot of analyze about the gaming benchmark

@kevinnguyendn if you need

@kevinnguyendn auditing this with my current system right now... will post updates on how it goes, good shit fam💫🔥

@jonkmt Love to hear it! Let me know how the token savings look compared to the default setup. Can't wait to see the updates! 🚀🔥

@kevinnguyendn How well does your memory upgrade work with the Ontology skill?

They're highly complementary. If Ontology maps the conceptual space, ByteRover acts as the persistent memory layer underneath. It takes those structures, curates, and deduplicates them into a deterministic .brv context tree so you don't get hit by the 'Amnesia Tax' over time.

Hey @kevinnguyendn Running byterover in a multi-agent setup (OpenClaw on VPS + Claude Code on Mac), both writing to the same shared context tree via git sync. An issue is that the curation LLM doesn't check for existing topics before creating new ones, each brv curate call is stateless. Over a single session we accumulated 60+ duplicate files. Switching models doesn't fix it; the model just isn't given existing topic context at write time. Is this a known limitation? Built a nightly consolidation job as a workaround, but upstream prevention would be better.

Hey! Yes, this is definitely a known limitation right now. Building a nightly consolidation job is a solid workaround in the meantime! We are actively working on updates focused specifically on native deduplication and better cross-agent sharing. Really appreciate the feedback and seeing how you're using it!

@kevinnguyendn Thnx man. Thought I was losing my mind for a minute 😂 great tool tho, I successfully have a shared brain between Claude code on my Mac and openclaw on my vps Barely see anybody talking about this yet so nice work

you're definitely not losing your mind! 😂 That shared brain setup between Claude Code and OpenClaw is exactly the vision. Since we're a tiny team right now pouring everything into that multi-agent integration layer, it would mean the world to us if you could help spread the word about what you built. working on a more native layer of multi-agent sharing over the context tree now! will keep you posted

@kevinnguyendn Sounds good. Also, please look into this. Possible there was a malware on one of the dependencies from what opus 4.6 determined during the install on the latest version 🤷‍♂️ I had to rotate all my keys on my vps so you might wanna look into that

@kevinnguyendn @kevinnguyendn

Huge thanks for flagging this immediately. We're tracking the upstream axios supply chain attack here: We are pushing a hotfix in minutes that hard-pins axios to 1.14.0 so no other users are affected by this threat. Rotating your keys was the exact right move. Appreciate you massively for the heads up.

@kevinnguyendn Happy to help, fortunate that I noticed quickly 😆

I like the idea. My issue is based on my setup which looks to keep my data as secure as I can, your documentation states: 1. Your agent goes out to scrape the public web for competitor intel. 2. The plugin automatically staples your confidential robotics IP and internal strategy to the outbound request. ByteRover will automatically append your confidential IP and internal strategies to the prompt. 3. You just broadcasted your private vault to external endpoints. Air gap is gone. More risk of data leak.

Ah! You are reading the section of our docs that describes the exact problem we built ByteRover to solve! That example in the docs is showing what happens when you use implicit background memory (which we do not use). ByteRover uses explicit, selective retrieval. It never automatically staples your vault to outbound requests. The agent has to explicitly call the brv query tool to read the .brv/context-tree, keeping your air gap completely intact. 🛡️

@kevinnguyendn Correction, I had OpenClaw review and outline the pros and cons if it should use it. Thanks for the context, I’ll get it to re-review.

@kevinnguyendn I started using it out officially signing up then maxed out and subscribed to Pro but can’t seem to integrate the initial memory files into the new account I created?

Thanks for upgrading to Pro! 🙏 Since the free tier is 100% local, your initial .brv memory files are sitting on your local machine. you can use CLI command (brv push / brv sync) to sync your local tree up to your new Pro account.

@kevinnguyendn 100% agree the default memory setup can get noisy fast. The win is separating short-term daily logs from curated long-term memory + good retrieval. Less token burn, better continuity, fewer hallucinated “memories”.

Spot on. Separating those concerns is the only way to scale. By moving to selective retrieval with the .brv/context-tree, we're seeing token usage drop by ~70% while entirely eliminating the 'hallucinated memories' problem

@kevinnguyendn Andy, Can you ship for x86_64 please 🙏 ByteRover only ships arm64 binaries. The brv CLI doesn't support Intel Macs I'm stuck until x86_64 is supported :-(

Definitely Abe. We'll roll out tarball build for Intel Macs asap (probably within 1-2 days). Will keep you posted!

@kevinnguyendn It sure is broken by default and requires a lot of tweaking to get it working to your liking. Nice work! Can’t wait to try this out

Thanks Ched! The constant tweaking of MEMORY.md was driving us crazy. The goal with ByteRover was to make it plug-and-play so you can actually get back to building. Let me know what you think when you give it a spin

@kevinnguyendn ⚡

@kevinnguyendn That sounds like quite an accomplishment for OpenClaw! Hope the users are getting a good experience out of their memory system now that it's been tweaked.

Appreciate it! 🙌 Just to clarify, ByteRover is an independent skill we built for OpenClaw to replace their default memory. And yes, the feedback has been amazing, it completely changes how they build agents.