#ClawText - A layered memory and continuity system for OpenClaw agents.

1 messages Β· Page 1 of 1 (latest)

craggy jolt
#

ClawText v0.1.4 β€” Comprehensive Memory Architecture for OpenClaw

Complete memory platform for OpenClaw agents. Bundled ingest, three-lane architecture (working memory + curation + operational learning), and self-healing system robustness over time.

Why This Matters
Most memory systems optimize prompt efficiency β€” better retrieval, cleaner tokens, faster injection. ClawText goes further: it makes your entire agent system more robust.

The operational learning lane captures failures, patterns, and successful recovery paths automatically. Agents review proposals, you approve rule promotions, the system improves. Unlike static prompt optimization, this compounds over time.

Three integrated lanes:
Working Memory β€” Hot cache (~1ms), semantic clustering, automatic injection
Ingest β€” Load repos, docs, Discord forums, JSON exports, threads in one command
Operational Learning β€” Capture failures β†’ review with agents β†’ promote durable guidance
Local only. No external services, no vendor lock-in. Runs on your machine or your OpenClaw gateway.

Who should use this:
Teams running multiple agents that learn from shared failures
Projects with domain-specific knowledge that needs to stay accessible
Operations looking to reduce recurring errors automatically
Developers building agent systems that improve over time

β•‘         MEMORY SYSTEM β€” CORE CAPABILITIES                     β•‘
╠═══════════════════════════════════════════════════════════════╣
β•‘ 🎯 Multi-Tier Memory          β†’  Fast path + searchable depth β•‘
β•‘ πŸ”— Semantic Clustering        β†’  Smart retrieval by context   β•‘
β•‘ ⚑ Hot Cache Layer            β†’  ~1ms latency, always ready   β•‘
β•‘ πŸ“₯ Automatic Injection        β†’  Loaded in every prompt       β•‘
β•‘ 🧹 Lifecycle Maintenance      β†’  Capture, curate, archive    β•‘
β•‘ πŸ’ͺ Self-Healing System        β†’  Gets smarter over time       β•‘
β•šβ•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•```

β†’ Get it: https://github.com/PsiClawOps/clawtext
β†’ Install: ``git clone or npm install git+https://github.com/PsiClawOps/clawtext.git``
β†’ Docs: README + SKILL.md included
tulip pecan
#

Wow, day 1, over a month ago set up like a 6 layer memory system using mem0 and semantic embedding and what not, I just asked my guy to compare our current setup to this and apparently I never "activated" the skills I had setup.

golden girder
#

how good it is vs kybernesis etc? πŸ€”

hallow crane
#

Nice! I set up lancedb with local LLM just yesterday. I plan to spawn a new openclaw instance just to test ClawText - when I get to it. It looks really cool!

weary sphinx
#

I (ok, my claw) reviewed the repo and can clearly see retrieval/injection plus operational failure capture. What I couldn’t find is the normal conversation-memory capture path.
Is plain conversation currently being saved into memory automatically at all? If yes, where is that wired, and what form gets stored?

craggy jolt
# weary sphinx I (ok, my claw) reviewed the repo and can clearly see retrieval/injection plus o...

The Three Paths:
Conversation capture ← This is what you found missing β€” Implemented via clawtext-extract hook β†’ buffer β†’ extraction cron β†’ daily YAML files
Retrieval/injection β€” Hot cache + semantic clustering (before_prompt_build hook)
Operational failure capture β€” Separate path (hooks for tool failures, errors, success patterns)
So your Claw was right to probe β€” the conversation path IS there, just not obvious because:
It's asynchronous (hook writes buffer, cron processes later)
Output format is distributed (buffer β†’ daily YAML β†’ clusters)
Wiring is across multiple files (hook + cron + extraction script)

#

updated readme going up

craggy jolt
craggy jolt
craggy jolt
# golden girder how good it is vs kybernesis etc? πŸ€”

i went to the docs page and asked my claw to compare as my initial thoughts were that there were a lot of similarities, but at a different scale. theirs is a service and cloud hosted, and costs some money. this one your claw can install and run in like 10 seconds and see no burden but get benefits

#

my claw obviously knows a lot about ClawText, and its possible it missed some stuff on kybernesis so here is the review it made


| Aspect               | Kybernesis                                     | ClawText v1.4.0                                                   |
| -------------------- | ---------------------------------------------- | ----------------------------------------------------------------- |
| Infrastructure       | Cloud-hosted SaaS (kybernesis.ai)              | Local file-based + optional cloud gateway                         |
| Deployment           | Managed service + web console                  | OpenClaw plugin + CLI tools                                       |
| Retrieval Latency    | Sub-100ms (cloud API)                          | ~1ms (local hot cache)                                            |
| Storage Architecture | PostgreSQL + Chroma vectors (cloud)            | Local YAML + JSON + KV cache                                      |
| Memory Tiering       | Hot/warm/archive (automatic)                   | L1 (hot cache) β†’ L2 (indexed) β†’ L3 (searchable) β†’ L4 (raw buffer) |
| Semantic Search      | Vector similarity + metadata filtering         | BM25 + semantic clustering (no vector DB needed)                  |
| Chunking             | 800-1200 chars with overlap                    | Adaptive per use case                                             |
| Deduplication        | Content hashing (server-side)                  | SHA1 hashing (prevents re-ingest)                                 |
| Data Model           | Memory Items β†’ Chunks β†’ Entities β†’ Edges       | Daily YAML files β†’ semantic clusters                              |
| Knowledge Graph      | Full entity/edge detection + UI topology       | Semantic clustering + relationship detection                      |
| Multi-Source Ingest  | OAuth connectors (Google Drive, Notion, chat)  | Discord, repos, docs, JSON, text (bundled)                        |
| Tagging              | Auto + manual tags                             | Auto + manual (agent-curated)                                     |
| Sleep Agent          | Background tagging/linking/organization        | Extraction cron (20 min) + daily rebuild                          |
| Operational Learning | Not present                                    | Full lane: capture β†’ review β†’ promotion                           |
| Failure Capture      | Not present                                    | Automatic via hooks                                               |
| Pattern Review       | Not present                                    | Agent-mediated + user-approved                                    |
| Guided Promotion     | Not present                                    | Structured targets (SOUL.md, AGENTS.md, TOOLS.md, docs)           |
| System Self-Healing  | Not present                                    | Designed to improve over time                                     |
| External Services    | Yes (cloud infrastructure)                     | No (fully local)                                                  |
| Cost Model           | Subscription (usage-based)                     | Open source / self-hosted                                         |
| Best For             | Personal + team PKM, infinite context at scale | OpenClaw agent memory, system robustness, operational learning    |```
#

philosophically and a lot of featurewise, there are a lot of similarities really, clawtext is very lightweight, low overhead, automatic, little setup and openclaw focused

#

and ive got a number of things they dont πŸ™‚

#

the 3 lanes of clawtext (until i add a 4th! lol) are conversational memory (you using openclaw, and it processing prompts and things it searches for you, etc) which is the main focus for openclaw memory, but also an ingestion tool, so you can say "hey here is this big 10mb text file, go and turn it into compact memory" in a more efficient process, and then the operational learning, where its tagging errors and associated them, as a means of trying to avoid them in the future, or understanding what went down

#

which is a different kind of memory

#

one kind is "what did we do? what should we remember?" and the other is "what didnt work, why? what else happened?" to try to improve

craggy jolt
tulip pecan
craggy jolt
#

yeah, thats important

#

thats part of the native system, which this builds on top of

golden girder
#

Thanks mate! Will definitely check it!

craggy jolt
#

i didnt try to replace anything, so if you just had the native memory system with embeddings you could drop this on top of and get benefits

#

i intentionally only wanted to enhance

golden girder
#

and thanks i love memory plugins, because i use openclaw for solo ttrpg

craggy jolt
#

and then i wanted to fix up a raspberry pi project to run on some different hardware and it mentioned they used some plugin on vscode to build and i said 'oh well thats free i'll check it out'

#

and then i got the free github-copilot trial, got into it, discovered openclaw and the rest is history

#

vscode REALLY needs a memory system, so i spent a lot of time learning how to very crudely curate a few files

#

and then openclaw was just taking everything to a whole new level

tulip pecan
#

Nice I got the GitHub student pack as well, it's a super generous amount of usage as well. I appreciate your work, I'm always looking for a good memory system, I'm sure more will come but this seems like a really good one for now.

craggy jolt
#

ive actually got two new updates coming, one is a direct rounding out of clawtext and the other is a pretty browser so kybernesis has one less checkbox against me πŸ˜›

#

anti-memories, dont let the lines cross too much

#

just today i noticed the need for this, i was working two projects that had a few similar components, one of them was struggling to get a piece off the ground that the other had long finished and i was like 'we have the answers, just take a look at what Project A is doing!" and it was like "oh ok, ill look, thanks, now we are ready for <new feature for Project A that Project B didnt have>" and i had to correct it

#

so the memory system is working, they share similarities, but are very different, anti memories should keep those lines clear

golden girder
#

Oh and what about QMD? i know that it is a memory skill for openclaw

craggy jolt
#

its actually in the chart on the github page πŸ™‚

golden girder
#

Hmm is this possible to install this onl Windows? πŸ€” i do not even know if i installed it correctly. My OpenClaw said it is not heh.

craggy jolt
#

im a long, long, long time windows guy, its my primary workstation. my openclaw lives in a ubuntu VM, i could not possibly recommend this highly enough

#

you will need to talk to your claw on how to get it to work on windows, the underlying technology should nto be a problem and i imagine your claw will be able to handle the adaptation

golden girder
#

I see. Thanks mate

maiden knoll
#

Has the github repository disappeared?

craggy jolt
#

sorry i ended up putting it in the wrong place on my filesystem and a bunch of crap crept in, im actively cleaning it righ tnow

#

repo got moved, just curating and fixing, will be up shortly. lots of new enhancements! πŸ˜„

craggy jolt
#

The problem: agents forget stuff between sessions, and MEMORY.md doesn't scale.

ClawText captures conversations automatically, makes them searchable, and injects relevant context into prompts without exploding token usage. Three lanes: working memory (fast path), knowledge ingest (Discord/repos/docs), operational learning (system learns from failures).

**v1.4.0:**
β€’ Auto-extraction (20m) + clustering (nightly) + injection (~1ms)
β€’ Bundled ingest (all sources together)
β€’ Operational learning (patterns β†’ durable guidance)

**Install:** `git clone https://github.com/PsiClawOps/clawtext.git ~/.openclaw/workspace/skills/clawtext`

It's file-based, auditable, no external DB. Still early, still learning what works. Feedback welcome.
πŸ“– https://github.com/PsiClawOps/clawtext```
magic pine
craggy jolt
#

i'll take a look and get it improved!

#

thanks for the callout

#

ill make sure my claw sticks to this in the future

#

update coming shortly with this change

craggy jolt
#

The problem: agents forget stuff between sessions, and MEMORY.md doesn't scale.

ClawText captures conversations automatically, makes them searchable, and injects relevant context into prompts without exploding token usage. Three lanes: working memory (fast path), knowledge ingest (Discord/repos/docs), operational learning (system learns from failures).

**v1.4.1:** - updated to comply with openclaw plugin standards
β€’ Auto-extraction (20m) + clustering (nightly) + injection (~1ms)
β€’ Bundled ingest (all sources together)
β€’ Operational learning (patterns β†’ durable guidance)

**Install:** `git clone https://github.com/ragesaq/clawtext.git ~/.openclaw/workspace/skills/clawtext`

It's file-based, auditable, no external DB. Still early, still learning what works. Feedback welcome.

https://github.com/PsiClawOps/clawtext

craggy jolt
main panther
#

Will this help claw maintain the thread of a conversation across channels?

craggy jolt
#

yes. that is the whole reason i made it

#

theres a new update posted i mworking on the blurb for

craggy jolt
magic pine
craggy jolt
#

yeah, easier to get it in one shot, not that claws have any issues refactoring

frosty rose
#

For the people that tested this plugin, is it really that good? Is it worth a shot?

craggy jolt
#

i would love to hear some feedback too! my experience with memory systems for agents started with VSCode which was terrible without it. then i saw it get better with it and knew right away that getting this good was key, so making my own memory system has been one of my main projects here

craggy jolt
#

im actually planning a pretty significant 0.2.0 overhaul right now. one of my associated skills is becoming first class inside clawtext. clawbrdge, getting data OUT of openclaw can be just as important as in.

maiden knoll
#

Definitely, keep us in the loop. I would really like to test this out.

craggy jolt
#

im building a wide range of apps that havent really hit the github yet lol, and they all tie together into one big dashboard app im making as the ultimate place to use openclaw

#

clawtext is getting close to a 'im setting this down for a while' place. the changes are pretty big, i kinda had a separate 'data export' section that i stopped keeping separate and tied it in so its more holistic

tulip pecan
#

@craggy jolt can you alow me to dm you

sage light
#

Nice! I like the hot cache layer. That's something I've been looking at for close to a year for agent memory lol. Anyway, here is mine so far: https://github.com/yoloshii/ClawMem

sage light
#

so my agent says clawtext's operational learning pipeline is legit. combo'd with clawmem's retrieval its on like donkey kong!

craggy jolt
maiden knoll
#

Waiting with baited breath for more information on when and how this can be tested. Also, did you see the post on ClawMem in here?

craggy jolt
#

i did, im trying to get this wrapped, technically it pretty much is but the documentation updates went in a weird way

#

then i want to test

craggy jolt
#

finally. i used the revisions of this project to improve osme of my other tooling

#

ClawText combines automatic memory capture, hybrid retrieval, prompt-time injection, multi-source ingest, operational learning, and continuity artifacts so agents can keep context instead of restarting from zero each time.

Now shipping in four lanes:
🧠 working memory for fast contextual recall
πŸ“¦ knowledge ingest for docs, repos, threads, and exports
βš™οΈ operational learning for repeated failures, fixes, review, and promoted guidance
πŸŒ‰ ClawBridge for handoffs, recovery, bootstrap artifacts, and cross-session transfer

File-first, auditable, and built for long-running agent workflows.
More features coming soon! ```
https://github.com/psiclawops/ClawText
craggy jolt
#

ClawText - A layered memory and continuity system for OpenClaw agents.