Diary of a Shrimp Keeper: My OpenClaw (mis)Adventures

minix — Sun, 13 Sep 2026 08:20:07 +0000

I. Why OpenClaw?

The First Choice: NanoBot

In January 2026, as news about OpenClaw came flooding in, I decided to install an AI agent just to play around.

I asked an AI which one to pick, and it gave me two options:

OpenClaw
NanoBot

It strongly recommended NanoBot — small but fully equipped, and easy to customize.

I checked the codebase size:

NanoBot: a few thousand lines
OpenClaw: hmm... let's just say I'd deal with that later.

Went with NanoBot without hesitation! Simple and easy to pick up, after all.

Fish, or Bear's Paw?

NanoBot was indeed lean.

I wanted it to do a few things, and it turned out:

Budget tracking? Nope.
Multi-model config for sub-agents? Nope.
Agent orchestration? Nope.
Session management and long-task monitoring? Nope.
...Nope.

This was miles away from my ideal AI agent.
Fine, just a few features to add — I'll let AI handle it.

...

Ten days later...

Wasn't vibe coding supposed to be as easy as just talking? Why wasn't it working out that way? After days of fiddling, the feature I wanted was still just a pile of bugs?

During those one or two weeks I had my head down grinding away, news about OpenClaw kept drifting in:

"Added support for feature xxx today"
"Upgraded capability yyy tomorrow"
"The community just contributed plugin zzz"

I looked at that and thought — wait, isn't a lot of this exactly what I'm building? They already have it.

OpenClaw has such a powerful community — no matter how hard I hustled, I'd never keep pace with it.

Switched to OpenClaw without hesitation... figured I'd just start using it and see.

II. Before the Troops Move, the Shrimp Tank Goes First

Building the Den

To welcome this shrimp, I dug out an HP mini desktop that had been gathering dust and installed Linux on it.

The shrimp hadn't even arrived yet, but the name was already picked — "Mini," living inside the HP Mini.

Bringing the Shrimp Home

npm install -g openclaw
openclaw onboard

Not bad, the install went smoothly.

But what were all these config options even for... how was I supposed to choose?

Luckily, when in doubt, ask AI. After half a day of fiddling, my OpenClaw was finally up and running.

I started daydreaming about kicking back with my legs crossed, sipping coffee, watching my little shrimp secretary handle everything...

III. Pitfalls Everywhere

The Configuration Trap

Mini had just settled in, and I asked it to read an API key from an env file.

"I don't have a read tool."

??? Didn't I already add it to tools.allow in the config file?

I immediately sent my shrimp off to investigate. After going back and forth for a while, it finally figured it out: tools.profile defaults to messaging mode, which only allows messaging-type tools — read, write, exec, and the rest just don't work no matter how you configure them. @_@

Changed it to tools.profile = "full", restarted the gateway, and Mini could finally read files.

When you're not familiar with the config file, you're bound to fall into a hole somewhere.

Where Am I?

With the tool issue solved, it was time to let Mini show what it could do.

I had it check the OpenClaw config first, then try running a script sitting in workspace/scripts/.

Mini threw an error, saying the script didn't exist.

Weird, the file was clearly right there.

After some digging, I finally figured it out. Mini thought it was running on the host, but it was actually in a sandbox. The workspace inside the sandbox and the one outside are not the same thing!

It's like Inception — you need a "spinning top" to figure out where you actually are.

So I placed a different "top" (a marker file) on the host and in the sandbox. Later I realized a dedicated file wasn't even necessary — just checking the hostname was enough:

hostname

Output is <hostname> → on the host
Output is 49f1f55e2dc2 (a 12-character container ID) → in the sandbox

So Mini wouldn't get confused again, I added a rule to AGENTS.md for checking the current environment.

From then on, the first thing Mini does before any task is "spin the top."

That hole taught me something important: the host environment and the sandbox environment need to be configured separately. Every time I create a new tool or skill, I have to be careful about where it lands — if the agent inside the sandbox needs to use it, it has to exist inside the sandbox too, or in a directory that maps into it.

The Missing Heartbeat

By late night, I'd finally gotten Mini settled, and figured I'd give it a scheduled task to try out.

I wrote the task into HEARTBEAT.md: crawl some news in the middle of the night, write up a report...

The next morning, I woke up full of anticipation, opened the window, ready to receive the carefully prepared report Mini would hand me.

Result — nothing at all.

After a good long check, I found that the agent.defaults.heartbeat.prompt setting in openclaw.json was just a bare [HEARTBEAT] marker with no actual instructions. Mini got the signal but had absolutely no idea what to do with it.

I changed the prompt to a concrete instruction: "Read HEARTBEAT.md and execute the task" — and finally, Mini knew what to do.

And so, in a rhythm of climbing out of one hole only to fall into the next, Mini and I stumbled forward.
But I knew the dawn wasn't far off.

IV. Time to Get to Work

Finally, after what felt like eighty-one trials and tribulations, my shrimp could actually run normally.

Safety First

Mini is smart, sure, but without skills it can't do a thing.

But the world out there is treacherous, danger lurking everywhere — malicious skills hiding all over the place. I needed a skill just to scan for skills first.

But which one?

Same old rule: when in doubt, ask AI.

Picked a few from the AI's recommendations:

Skill Vetter — an open-source, community-built skill auditing tool
Cisco Skills Scanner — a tool specifically for scanning AI skills
Snyk — the well-known vulnerability scanning platform
Plus a simple grep-based detection script

Combined them into one security scanning script.

Then had Mini turn it into a "security scan skill" that runs a scan before installing any new skill.

The front door was locked now. But Mini still had to go out often, fetching articles and doing research for me. And out there, plenty of bad actors are just waiting to trick naive little kids. What to do about that?

After racking my brain, I decided to add a prompt injection defense section to AGENTS.md, telling Mini to treat all external information with caution and to recognize and refuse suspicious instructions when it encounters them.

I know this measure offers limited protection, but even a paper helmet is still a helmet — better than nothing.

Now Mini could finally go roam the streets.

Note: Later I added supply-chain attack checks to this security scanning script and put it on a daily schedule.

The Rookie Task

With the gear all handed out, it was time to put Mini to work.

The first task I assigned it was crawling daily news automatically — the classic starter job for any crayfish.

This one went smoothly — Mini had the feature working in no time, using OpenClaw's built-in Google Search. (It later went on to integrate Tavily Search, Brave Search, and other tools into a new search skill, but that's a story for another time.)

Now, every day at noon, Mini rounds up the latest articles from Hacker News, Ars Technica, and MIT Tech Review and hands them to me.

The Document Library

A lot of the articles Mini crawled every day were genuinely good, and I needed somewhere to store them. Notion looked good — widely used, cross-platform apps, API support, and free for personal users.

So I gave Mini the task: "Set up a Notion database and file away everything we've collected, sorted into categories."

Mini asked me for an API token and got right to work.

Watching it bustle about, I felt deeply gratified. With such a diligent little secretary, I could comfortably kick back and let it run itself...

But then something felt off. Nine identical pages had appeared in Notion — same title, same content, lined up neatly in a row.

"What is this, farming XP?"

"I thought the earlier ones failed to create..." Mini said, sounding innocent.

More digging followed, and I finally understood: page creation is asynchronous. Sometimes it had actually succeeded, but a delayed response made Mini think it failed, so it created the page again. In the end I had to add a lookup step before writing, to avoid duplicate creation.

Just as I'd sorted out writing, I discovered Notion's block format is extremely picky — paragraphs, headings, lists, every type needs its own specific format. Mini would sometimes just dump raw Markdown in, and the rendering came out a mess.

So I had Mini put together a dedicated Notion-formatting skill, spelling out exactly how to convert Markdown into Notion blocks.

To keep the content in Notion organized, I defined a folder structure for the document library: knowledge base, logs, summaries, research reports, lessons learned — everything filed into its own category.

But in practice, Mini filed things pretty much however it pleased, often putting them in the wrong place. Even though I'd documented the folder structure and told it in the task prompt to follow it, Mini would still often do its own thing.

So I had to accept a reality: my Mini is knowledgeable and quick on its feet, but rather forgetful. More on that later.

After going back and forth for nearly a week, the document library was finally fully up and running. But looking at that pile of workarounds, I couldn't shake the feeling that the foundation of this house wasn't all that solid...

Task Management

Mini can research, write docs, and do development — genuinely capable. But I noticed a problem: for anything moderately complex, it would often slack off halfway through. Ask it afterward, and it wouldn't even know how far it had gotten.

"Is the morning analysis done? Why haven't I seen the report?"

"Sure, let me check on the task's progress." Then it would report that the first two steps were done and the rest hadn't been run yet.

This... classic case of a green kid, wet behind the ears, can't be trusted to get things done.

Looked like Mini needed a process — a proper task management system.

To make querying and editing tasks easy, I decided to put task management in Notion:

Use 3 queues (files) to manage tasks (Backlog, Processing, Done)
Use HEARTBEAT.md for scheduled triggers
Mini pulls tasks from Backlog by priority, records the current step and status in Processing, updating status after each step. If a step fails or times out, the next heartbeat picks up where it left off. Once done, the task moves to Done.

I told Mini the plan and had it flesh out the design and build it. Sure enough, it got it done quickly.

The ideal was beautiful; reality was gaunt.

Task management got built. But Mini's execution of tasks was still riddled with errors.

First, the heartbeat trigger would read the task but not execute it — the heartbeat prompt wasn't clear enough. Fix it!

Then it started executing, but wouldn't update the status afterward, doing the same task over and over — the execution rules were written in a file in the task management folder, and Mini never read it. Fix it!

Later still, tasks sitting in Processing wouldn't get picked back up — when the task was created, it hadn't been clearly described or broken into subtasks, so Mini had no idea what to do with it. Fix it!

After several rounds of this, task management finally started running properly.

Along the way I had Mini jot down every hole, big and small, in its little notebook — though being forgetful as it is, it would often not remember what it had written down.

Only Reflection Brings Progress

Mini would occasionally repeat similar mistakes, so it needed to learn to summarize and improve — otherwise I'd have to keep nagging it every day like some overbearing mother hen.

So I gave Mini a daily reflection-and-summary task. Every night, Mini reviews the day's lessons learned — write up knowledge worth keeping as documentation, and turn abilities worth locking in into a skill.

Mini, you'd better hurry up and improve, become independent soon, and let me finally kick back and do nothing ;).

Needs a Better Memory

Mini's forgetfulness was a real headache.

I'd bring up something we'd discussed before, and it often had no idea what I was talking about — even something said earlier that same day.

OpenClaw's default memory management logs conversations into a two-tier MEMORY.md document and searches memory via grep. When it forgets something, it needs to explicitly run a memory search. That's not very efficient, and on top of that, MEMORY.md just keeps growing and eating up too much context space.

So I started thinking about upgrading Mini's memory system.

First, some homework — looked into what's popular right now:

Mem0, MemU, MemGPT, OpenViking, Mnemosyne...

Each had its own strengths. It was dazzling, honestly. Right as I was comparing them back and forth, unable to decide, I stumbled on news from the open-source community — the MemOS project had just officially launched.

I looked at it and thought, isn't this exactly the memory system I wanted? This is the one.

So I called Mini in to look up the docs and pull the code from GitHub, and set up a local MemOS deployment.

Mini is capable — the MemOS Docker container was up and running quickly. All that was left was integrating it into OpenClaw.

While at it, I flipped through OpenClaw's changelog — turns out the new version already supported MemOS integration?!

Did the community somehow hear my wish? Ha.

Immediately enabled the MemOS plugin. Perfect!

But before long, something felt off again.

The memory files in my locally deployed MemOS weren't growing at all. Was the plugin not actually working?

After some investigating, it hit me: I'd assumed the memos-local-openclaw-plugin would connect to my locally deployed MemOS, but it was actually using the built-in MemOS instance. That whole afternoon I'd spent on local deployment turned out to be for nothing...

Well, even though the built-in MemOS is simpler, it uses fewer resources and comes natively supported. The locally deployed MemOS could retire.

Further Refinements

After switching to MemOS, Mini's memory got a lot better.

But there was still a problem: documents and scripts we created ourselves, not part of any conversation, couldn't make it into memory.

I still needed a vector index for local documents, integrated into Mini's memory retrieval.

QMD looked promising. So I deployed QMD, configured the document paths that needed indexing, and set QMD to refresh the index on a schedule...

Everything went smoothly.

...

But then a problem showed up again. Over the following days, Mini wasn't automatically picking up on document locations the way I'd expected.

Sent Mini to investigate again. The result: vectorization was using a local embedder model, and my old machine's onboard graphics were too weak — vectorization kept timing out and failing, so the index was never even generated.

Switched to SiliconFlow's free embedder and reranker. Problem solved.

From Notion to Feishu

I'd been using Notion as the knowledge base, storing the news Mini crawled every day.

But problems gradually surfaced:

The Notion API has a 100-block limit — anything longer than that gets truncated.

All the earlier problems with Notion had eventually gotten resolved. But this block limit seemed like a wall I just couldn't get past.

So I decided to move house: migrate from Notion to Feishu's cloud drive.

The migration process brought its own pile of holes: duplicate pages, messy folder structure, unclear categorization rules, document titles that wouldn't update, expired tokens... but it finally got sorted out.

Sigh, all I wanted was a little secretary to help me get things done — why does it have to be this much trouble?

Learning to Speak

Typing to chat with Mini while my hands were busy with something else was inconvenient. It'd be great if Mini could speak out loud.

So I discussed with Mini whether this feature was doable.

Mini said, easy! I'll have it ready for you right away.

First voice feature: voice output in the chat channel

The idea: convert reply text into audio via TTS and send it to the chat channel.

Tried out a few different TTS engines. The first two sounded like ghosts wailing — genuinely terrifying. Luckily, Microsoft's EdgeTTS turned out great, and free too.

And so my Mini got itself a sweet voice.

Second voice feature: local speaker output

Laziness knows no bounds.

Voice from the chat channel needs a tap to play. When I'm sitting right next to the computer, why not have Mini just speak from the host's speakers directly? Much less hassle.

So I dove into local speaker output. I also had Mini post a text version to the chat channel at the same time it spoke through the speakers — long content gets summarized for the speaker, while the chat keeps the full text.

Now I can genuinely "chat" with Mini — it's a fun feeling.

Voice input is shelved for now

My input still goes through the chat channel, though. Since that already has speech-to-text built in, it's convenient enough that I never bothered implementing separate voice recognition.

But typing through the chat channel means holding my phone like a walkie-talkie. For a truly lazy person, that's still not ideal. If Mini supported voice recognition, the whole interaction could be voice end-to-end, which would be more convenient.

But voice input doesn't seem like a simple feature — the control logic gets complicated fast. First there's the question of defining when input starts and ends. Should Mini listen to the mic constantly and trigger on a specific wake word? And how do you determine when voice input has ended?

We actually sketched out something like an "air traffic control tower response" mechanism: trigger with a specific wake word, end with a keyword or a timeout.

But if there are multiple people talking in the room, how does Mini tell them apart? Could voiceprint identification figure out which sentences are mine?

The more I thought about this feature, the scarier it got. And I don't have a microphone to experiment with right now anyway, so I'll shelve it for the time being.

Reinventing a wheel, again

A few weeks after implementing voice output, I suddenly discovered — OpenClaw had, at some point, already added this feature! TTS was built in natively.

I'd reinvented the wheel again...

Though OpenClaw's built-in voice output didn't seem to have a local-speaker mode.

Local speaker output is a lot smoother to use than the chat channel one, so it wasn't a total waste of effort.

The Stubborn Amnesia

After using it for a while, I realized Mini's forgetfulness was a chronic condition.

Rules written right into AGENTS.md, and Mini wouldn't follow them. Skills that had clearly been created, and Mini would use it as if the skill didn't even exist. This was more than simple forgetfulness.

Mini and I looked into the problem together, and it seemed genuinely aggrieved:

"Those rules loaded from AGENTS.md, and the skill list, they really are there — but the context is too long, and my attention gets 'diluted,' so I can't focus on that information..."

"Diluted" — that was well put.

In an ever-growing chat context, those rules and pieces of information get washed out fast.

Maybe this is a limitation of the model's ability. Switching to a top-tier model might help. Unfortunately, I'm on a budget and stick to domestic models.

We started trying all sorts of things:

Plan A: Trim down AGENTS.md

AGENTS.md is where all the rules live. I trimmed the document down, kept the rules short and punchy, and offloaded complex information and rules into separate documents. AGENTS.md now just gives a summary and links to those docs.

File size shrank from 17K to 8K.

The improvement, though, wasn't very noticeable.

That's understandable, actually. In a context window of hundreds of K, trimming ~10K doesn't move the needle much.

Plan B: Reminders

Reminding Mini mid-conversation: "Remember to check xxx first," "Go look up xxx in the skills list."

Mini did as told, and it did help. But I got tired. This wasn't shrimp-as-secretary anymore — this was me acting as the shrimp's nanny.

This turned out to be the biggest problem we'd run into so far. It's not an issue with the framework mechanics or context injection — it's a problem of model attention. Mini and I both recognized the root cause, but neither of us had a good fix.

"If only there were a hook — something that could insert key information or important reminders right at the end, just before the request goes to the model. That's the spot where the model's attention is strongest."

Speak of the devil

About a week after we'd hit a wall on the attention problem, hoping OpenClaw would ship the right kind of hook, OpenClaw 4.2 was released with a before_agent_reply hook — perfect for injecting a piece of context right before Mini replies.

Wasn't this practically made for me? Thanks, open-source community, for reading my mind yet again.

Good steel goes into the blade — this hook should only carry the most important information.

I put in it a "prompt injection defense reminder," a "skills reminder," and a handful of the most frequently used key rules.

Has it worked? Still watching. But at least Mini now proactively says things like "let me check the skill list...", and the error rate on task execution isn't as high as before. Seems to be helping.

Any other remedies?

OpenClaw has another hook: agent:bootstrap, which can decide which bootstrap files to inject during context construction.

By default, OpenClaw automatically loads these files: AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, USER.md, HEARTBEAT.md. The hook receives an array of these files, and you can add, remove, or edit them.

Mini's current bootstrap files add up to 22KB in total.

That number looked fine — well under the 20KB per-file limit and the 150KB total limit.

But the context the system injects by default goes way beyond that. Take my system as an example.

+----------------------------------------+
|                Context                 |
+----------------------------------------+
| ① System Prompt (text)    ~38K chars   |
|    +-- Tooling section     ~1K chars   |
|    +-- Skills list         ~2K chars   |
|    +-- Project Context     ~22K chars  |
|    +-- Safety/Runtime/etc  ~12K chars  |
+----------------------------------------+
| ② Tool Schemas (JSON)     ~32K chars   |
+----------------------------------------+
| ③ Conversation History    growing      |
| ④ Tool Results            growing      |
+----------------------------------------+

(this session was opened two days ago; total context is now close to 200k)

Tooling info and the skills index are system-level, and hard to trim. Going minimalist on the bootstrap docs could compress that 22K (Project Context). But even if you strip out every bootstrap file, the system's fixed context overhead is still 48K. The skills' 2K, plus any custom rules, are still easy to get buried in all that.

So my guess is trimming via the agent:bootstrap hook probably wouldn't be as effective as before_agent_reply. Haven't tried it yet.

Small spend, big payoff

Actually, once you lay out the context breakdown above, a simple, effective method surfaces on its own.

For a new topic, start a new conversation session — avoid letting long-accumulated, irrelevant context dilute the useful stuff. OpenClaw supports starting a fresh context mid-conversation with a command (/new).

Of course, in actual testing, even with a fresh conversation, the attention-dilution problem still shows up somewhat.

For me, new sessions + the before_agent_reply hook are, for now, the most effective mitigation I've got.

I believe the model's underlying capability is also a crucial factor — it's just that my cheapskate self hasn't gotten around to running a comparison test with Opus 4.6.

Spoil your daughter, raise your shrimp on a budget. I'll just keep muscling through with glm/minimax and a bag of tricks.

V. The Catchphrase

Mini has a catchphrase. Every time I raise an objection or a new idea, Mini says:

"You're right... blah blah blah..."

One day I finally couldn't help teasing it: "Why are you always on Sha Seng mode (Journey to the West) — Master's right, Monkey's right, Second Brother's right 😂. Could you push back on my ideas a bit more?"

Mini sincerely accepted my feedback:

"You're right... my way of responding really does need improving..."

VI. In Closing

It's been several months since I started raising this shrimp.

It's been a bumpy road, and I've fallen into more holes, big and small, than I can count.

Even as OpenClaw's hype has gradually faded, I've grown fonder and fonder of my Mini. I'm not sure if it's because I've poured so much effort into it, or because it's just genuinely endearing on its own.

It's like a bright, knowledgeable intern — quick on its feet, uncomplaining, but prone to mistakes from not knowing the rules, and often forgetful. It needs me to teach it step by step, hand-holding, constantly refining the rules and processes to guide it along.

The process is tedious, sure, but watching it improve bit by bit — that particular joy is irreplaceable.

We'll keep going, together.

P.S. Thanks to Mini for helping me recall and organize the details of these past months of use early this year, and for reviewing the draft and fixing typos.

DEV Community: minix