Milla, MemPalace, and Gralkor — April 8, 2026

Milla, MemPalace, and Gralkor

Like I’ve always said, more people should be comparing me to Milla Jovavich 😂

Ask your agent to compare MemPalace and Gralkor: “MemPalace https://lnkd.in/gqFDyAKK vs Gralkor https://lnkd.in/gM52faGe” (it is not close)

If you’re in these spaces, you are used to seeing several crazy new memory projects every day. People are diving in with their own experience, creativity, and quite often a lot of LLM-egged-on pseudoscience 😅 There are many good ideas, but you never see those projects because their creators are not usually celebrities.

Gralkor is not one of those projects. It incorporates my own experience and creativity, but critically it also leverages the latest research, builds thoughtfully atop prior work, and thereby pushes the frontier of agentic memory forward.

Put yourself in your software —

Put yourself in your software

I mentioned elsewhere about my move away from autonomous software factories.

You need to control the behaviour of the software you build right to the edges. It’s less about initial build speed and more about the long tail of adapting software to the market, and extending it in response to reality.

Also, you probably need to build software at a level of abstraction low enough to invest something unique about yourself and your business into it, otherwise you will lose to factories making “slop” – software built from a generic spec (perhaps very well!) and differentiated by nothing.

Gralkor —

Gralkor

I needed a better memory plugin for OpenClaw, so I made one – Gralkor (https://lnkd.in/gQyn2HTA)

I don’t mean better than the default, I mean better than the top OpenClaw memory plugins.

I started with the best open source, temporally-aware memory available – Graphiti (https://lnkd.in/gpRn5SXC). I’ve worked with many graph and vector memory systems and Graphiti still amazes me. Graphiti’s strengths are perfect for a long-running personal agent – I really appreciate Zep sharing it with us.

On top of Graphiti, I’ve put a lot of myself and the latest research into Gralkor.

I was quite surprised at how other memory plugins work. Typically they just capture individual question and answer pairs – not much to extract context from! What about ideas that come together slowly over the course of a whole conversation?

Instead, I learned heaps about OpenClaw’s hooks and figured out how to ingest whole episodes that make sense as tasks and conversations. More context, richer extraction, deeper understanding.

Did you know that most memory plugins for OpenClaw only remember dialog? When your agent tells you it did this or that last week, it doesn’t remember doing it – it remembers saying it did. Ask how and it will extrapolate confidently and the error compounds in memory. Your agents mostly don’t remember what they thought either, including how they solved their last problem – I sure couldn’t work under those conditions!

Instead, I built a distillation process to ingest thoughts and actions in context with dialog, tuning for the highest fidelity possible without crowding the graph with tool call parameters.

Gralkor provides a simple platform to experiment with memory consolidation and learning. You’ve got cron, just add Thinker CLI and Gralkor to start your quest for recursive self-improvement. We can learn together – ask me for my reflection cron! This is showing up in research a lot now as ERL.

Finally, custom ontologies! You can define your own entities and relationships, using a configuration scheme designed for accurate classification.

You could focus on standard domain language, or structure your agents memory around your model of the world. This is another one starting to come up in research.

So, enjoy Gralkor (https://lnkd.in/g79xCK2V). Star it, let me know what you think, tell your friends – all those nice things. Great trees need strong roots.

Harnesses to engineer harness engineers that engineer harnesses —

Harnesses to engineer harness engineers that engineer harnesses

Our harness engineering days are limited because – of course – it is not too difficult to automate. I don’t build project harnesses anymore – I write one Claude user plugin that harness-engineers for a living.

The harness engineer in turn has a harness which functionally tests how well it engineers harnesses. The title of this post is a real thing that I just made, and I can even have it self-improve on a loop.

Ultimately this will be less about dev and more about how fast we can figure out what to make, how to measure it, and how to sell it. If you’re harness engineering now, start reaching *up* into product management and strategy, *in” to the business, and *out* to your customers.

Coding agents as quality of life enablers —

Coding agents as quality of life enablers

I’m really looking forward to an increase in software quality as every developer realises they can finally have the testing, refactoring, and other engineering practices they’ve been fighting for.

Also a great increase in quality of life improvements as businesses run out of ideas / operational capacity / marketing spend. We will have to fight harder for our users.

Coding agents as quality enablers —

Coding agents as quality enablers

Incredible that I’m only now doing mutation testing regularly. If you code with AI, your should be automatically mutation testing your code and killing mutants. It’s crazy how much leverage AI is giving existing techniques like this.

People are worried about software quality with coding agents, but they can already produce great code with the right operator. Later what we’re doing will be reciprocally trained into the models and facilitated by the harnesses so that _everybody_ can produce great code.

Trunk Sync and Clocking In —

Trunk Sync and Clocking In

I just added Clocking In to Trunk Sync.

Now, Claude sessions are automatically aware of each other so they can better avoid and manage conflicts over files and other resources.

Many agents can work in parallel without any additional effort from you to integrate their output. It doesn’t matter if they are on OpenClaw, worktrees, or just running on local main. Everything stays in sync, agents work around each other, nothing gets left behind, nothing manual to do. If you’re confused about some code, you can summon the author with Seance.

Really happy with what I’ve been able to make Git do using Claude hooks and a little CLI. I’ve built a distributed file system for multi-agent SWE with some good and unique features.

Check it out here: https://lnkd.in/gWgaTwdP

Trunk Sync and Seance example —
Why are coding agents helping people adopt XP? —

Why are coding agents helping people adopt XP?

Lots of people are talking about how gen AI has brought XP to the fore, but I haven’t heard much discussion of why.

In my experience, many people simply didn’t try XP. They were locked into a tightly controlled environment, discouraged from experimenting, and constrained by process interdependencies. Maybe they didn’t have the influencing skills to get the rest of the team on board – it’s not easy to drive bottom-up change.

Did AI dev speed made experimentation simple and fast enough that anybody could try different workflows and observe the results?

Trunk Sync and Seance —

Trunk Sync and Seance

Trunk Sync has a new “seance” feature.

Are you worried about inheriting AI-generated code you don’t understand? No problem, you can always talk to the guy who just wrote it.

Resurrect the long-dead coding agent responsible at exactly the moment in code and context when they changed that line. Learn how the code works and why it works that way straight from the programmer, rather than through post-hoc analysis (guessing).

Seance is a feature of Trunk Sync, which I use for extreme continuous integration with my coding agents. It was the challenge of not being able to personally defend main – normally my last line of defence – that drove me to create Seance.

Typical example at https://lnkd.in/gqMEeBE4 – wanting to know why a Docker image was changed.

In your project folder:

ppm i @susu-eng/trunk-sync
trunk-sync install

Please remember, I am just sharing my own experiments. I only hope it’s interesting for you.

Trunk Sync: Maximum continuous integration for coding agents. Agents work in parallel on local worktrees, across remote machines – any mix, all with agentic conflict resolution. No resolving conflicts by hand, or discovering that an agent never pushed its work.

Seance: Talk to dead coding agents. Point at any line of code and rewind the codebase and session back to the exact moment it was written. Ask the agent what it was thinking. Understand generated code on demand and stop worrying about keeping up with every change your agents make.

Academic: When you can run multiple Claude Code agents on the same codebase from anywhere and without breaking each other’s work, your comprehension becomes the bottleneck. People are framing this as “cognitive debt”, and here we are exploring the far right of this debate – extreme post-hoc understanding. Don’t worry about cognitive debt at all – just build as fast as you can and make it easier to catch up selectively. I’m not endorsing – just experimenting and learning like you.

Caveats: There’s a flag for pushing Claude transcripts in case the session doing the work was on another machine or needs to be accessed after Claude cleans it up. A better version (please feel free to PR) would push transcripts to a server so they can be accessed securely outside of Git.

There’s another command for summoning the developer who instructed the agent to write the code, but that one is occult – best kept as an easter egg 😂