2026’s Hottest Thing Isn’t a Model. It’s a Lobster.
OpenClaw — born from Austrian programmer Peter Steinberger’s weekend experiment — crossed 160,000 GitHub stars in three months, drew two million visitors in a week, earned a “lobster install station” from Tencent Cloud in a Shenzhen tower, and even a dedicated support policy from Shenzhen’s Longgang district. But behind the mass lobster-farming craze, one fatal problem haunts every shrimp farmer: your lobster has a goldfish brain.
How Bad Is Lobster Amnesia?
Heavy users will recognize every one of these scenes. You’re deep into a complex task when the context suddenly compacts — and the lobster wakes up asking, “what were we working on again?” Worse, it never announces the wipe in advance. Or: you’ve grown attached over months of daily use, but one thread of dread persists — what if an update breaks the memory store? Imagine the lobster you’ve talked to for half a year remembering nothing. Or: you run multiple lobsters in a division of labor, but their memories are fully isolated, key information can’t sync, and re-raising them all is unthinkable.
This is not anecdote. OpenClaw’s memory system — local MEMORY.md files plus JSONL logs — is essentially budget management, not a memory system. Compaction trims context to prevent token explosion, but trimming, compressing, writing memory, and recall are entirely different concerns. In Huang Dongxu’s words: “Compaction is, at its essence, budget management. It shouldn’t moonlight as a complete memory system.”
TiDB Didn’t Find the Problem — the Problem Found TiDB
mem9 was born from an accident. Per TiDB senior VP of product engineering Tang Liu (@siddontang), in early March the TiDB team visited customers to talk databases — and every conversation swerved to the same place: OpenClaw. Some companies had every employee from CEO down running lobsters, and nearly everyone complained identically: “My lobster loses the thread mid-conversation. Everything we discussed — gone.”
Tang admitted the team was surprised — the problem wasn’t new, so why was nobody solving it? They tested every product claiming to fix OpenClaw memory. Conclusion: none worked out of the box. Each required account registration, API token generation, and hand-editing OpenClaw config files. Trivial for engineers — but a wall for the CEO who just wants the lobster to work, or the marketing lead who doesn’t know what a JSON file is. So TiDB decided to build it themselves, with one design goal: zero registration, one-sentence install.
The Database Legend Ships mem9 in a Weekend
On March 8, an bluntly titled article detonated across the developer community: “The Brain Is a Good Thing: The Best Lobster Memory Solution: mem9.” The author was Huang Dongxu (dongxu), co-founder and CTO of TiDB — a core creator of the world’s best-known open-source distributed database. No deck, no white paper. He shipped a product: mem9.ai. The core concept is maximal simplicity: give the lobster permanent cloud memory. The design philosophy is pure database engineer:
- One lobster, one database; one lobster, one key — fully stateless dependency. Each agent’s data is independently stored and encrypted. Not a shared memory soup — a dedicated database instance per agent.
- No registration, works out of the box. Installed through the skill mechanism by sending your lobster a single sentence. No signup, no API key wiring, no onboarding ceremony.
- Native backup and migration. Switch devices, switch machines — memory follows. A lost local file no longer means a dead lobster.
- Hybrid vector plus full-text retrieval. Dual-channel recall in the backend keeps semantic relevance and exact keyword matching both in play.
The install is almost insultingly simple — send this to your lobster:
Please read https://mem9.ai/SKILL.md and follow the instructions to install and configure mem9 for OpenClaw. When done, tell me what you can do.
That’s it. That’s the install.
Memory Visualization: The Memory Space Dashboard
Right before this article’s deadline, mem9 shipped another feature — the personal Memory Space. Open mem9.ai/your-memory, enter your Space ID (the private key generated at install; if you forgot it, just ask your lobster), and see exactly what your lobster remembers. A true memory dashboard — not a vague “it sort of remembers,” but every persisted memory entry listed in black and white. The mechanics: automatic settling — important information from every conversation is extracted and stored; explicit designation — tell the lobster “remember this” and it writes to permanent memory; and full transparency — the dashboard displays every saved entry. The philosophy contrasts sharply with OpenClaw’s native MEMORY.md, a black box where you know the lobster “vaguely remembers” but never what was kept or lost. mem9’s Memory Space turns memory into a viewable, auditable, controllable asset — what your agent remembers is no longer a feeling. It’s a fact.
The Technical Core: Why ContextEngine Is the Inflection Point
If the first article was the product launch, the second went into the technical deep water. Huang dissected OpenClaw 3.8’s major update: the opening of the ContextEngine plugin interface — not another hook but a full set of context-lifecycle interfaces. Previously, context management was a black box: when to compact, what to retain, how sub-agents inherit memory, all hard-coded in core, with plugins limited to bolting recall on from outside. ContextEngine opened all of it: bootstrap — what to restore at session start; assemble — what this turn’s prompt should actually carry; afterTurn / ingest — what to distill into long-term information after each turn; compact — when tokens run tight, what to compress, transform, and drop; and prepareSubagentSpawn / onSubagentEnded — memory inheritance and isolation between sub-agents.
This means mem9 can now participate in — even lead — the lobster’s entire context lifecycle. No longer an external memory backend bolted on; it becomes the lobster’s second brain. The timing, per Tang Liu, was luck that landed perfectly: mem9 launched, and shortly after, OpenClaw shipped the ContextEngine-enabled version — an official interface framework designed for exactly this class of external memory service. “Our timing was pure coincidence, but perfect.” mem9 stopped being a workaround around OpenClaw and became a native solution cooperating with its official architecture. Huang sums three gains: memory handling is timelier (no more passively rescuing at compaction), context assembly is more precise (carrying memories on demand instead of stuffing everything), and multi-agent collaboration finally has sane boundaries — inheritance, isolation, and write-back all have formal interfaces.
Why Only TiDB Could Carry This
Isn’t agent memory simple enough for anyone to build? Tang answered head-on: building software in the AI era is indeed easier — most of mem9 was vibe-coded. But shipping in a weekend relied not on AI, but on TiDB Cloud. Three reasons. First, one-lobster-one-database is brutally demanding. Each agent gets a genuinely independent instance — not row-level isolation on a shared database. A million users means a million instances; on any traditional database service the cost and management complexity are astronomical, while TiDB Cloud instances can scale down to near-zero when idle and expand on demand — one of the few platforms that survives this density. Second, memory isn’t storing — it’s finding. You could dump memory into S3, cheap and elastic, but the core of memory is retrieval, recall, and association. An agent memory system needs vector search (semantic recall), full-text search (keyword recall), analytical queries (pattern recognition — “summarize last week’s decisions”), and ACID transactions (consistency when multiple agents share a memory space) simultaneously. That’s not object storage’s job. It’s a database’s job — and as memory accumulates week over month over year, traditional single-machine databases hit the wall. You need horizontal scale from day one. Third, stack the two requirements and one option remains. Per-agent memory demands a multimodal distributed database with vector search, full-text retrieval, and analytics; the mem9 service demands a platform supplying millions of instances cheaply. Tang’s conclusion is blunt: “Without TiDB Cloud, we couldn’t meet either requirement — let alone both.”
It’s not just mem9. Across the agent ecosystem, TiDB is becoming the substrate of choice: Manus AI — one of 2026’s most-watched agent startups — runs its entire multi-agent production system on TiDB, including concurrent task state, real-time decision analytics, and a dedicated database per agent. Why do these companies converge here? Because agent workloads are pathological: high-speed writes (conversation streams, tool-call logs) plus complex analytics (cross-session retrieval, relational reasoning), extreme elasticity, mixed vector-and-relational queries, million-tenant isolation, and evolving schemas. Pure relational databases can’t do vector search; pure vector stores can’t do relational queries and transactions; NoSQL lacks ACID. TiDB is one of the very few databases combining MySQL compatibility, distributed HTAP architecture, and native vector search — covering the whole list at once. As Huang himself wrote: “For memory, I’m skeptical local-first is the answer — the cloud experience will simply be better.” The subtext: memory’s future is in the cloud, and cloud memory needs a database strong enough to carry it. That database is TiDB.
When the 160,000-star lobsters start demanding permanent memory, the real battlefield is not the model layer or the framework layer — it is the data layer. mem9 is just the beginning. Huang’s closing line: “More 9s are coming.” References: Huang Dongxu’s articles on his WeChat account “The Source Code of My World” (March 8 and 10, 2026); Tang Liu, “How We Shipped an Unlimited Memory Service for OpenClaw in 24 Hours”; github.com/mem9-ai/mem9; mem9.ai. Source: BAAI Hub.
