Say Goodbye to Losing OpenClaw Configs—Mindkeeper Beta Invitation

You repeatedly tune the prompts in SOUL.md and finally find the version that makes the Agent respond just right—only to fumble a single line three days later and completely change its personality. Three people on your team edit AGENTS.md at the same time, and after the conflict is merged, no one remembers the original logic. The audit department asks, “Which version of the rules did this AI decision rely on?” and all you can do is stare blankly at “update” and “fix” commit messages in your Git history…

You realize that an AI Agent’s configuration files deserve to be taken seriously, not treated as a pile of Markdown you can discard at any time.

Mindkeeper was born to solve exactly this problem. It isn’t a code version management tool, nor is it a knowledge base like Confluence—it’s a “time machine” built specifically for AI Agent configuration files. It understands the subtle change of a single line of prompt in SOUL.md, can track how adding or removing a memory in MEMORY.md affects the Agent’s behavior, and can even let the Agent review its own history, compare differences, and proactively roll back when it makes a mistake.

Mindkeeper v0 sincerely invites everyone to try it. PRs and issues are welcome, as is feedback in the community Q&A board: https://github.com/seekcontext/mindkeeper

Why Git Isn’t Enough: AI Configs Need “Semantic-Level” Version Control

Throwing AGENTS.md into a Git repository is most people’s first instinct, but it’s far from enough. Git is designed for code; it cares about syntactic correctness and merge conflicts, whereas the core of an AI configuration file is semantic impact. If you change “please be concise” to “please be extremely concise,” Git only shows a one-line diff, but the Agent’s output length might plummet from 200 tokens to 50—an impact that’s invisible in Git’s history.

Even trickier is OpenClaw’s workflow. The Gateway automatically rewrites these files in the background, and the Agent itself also modifies MEMORY.md. You might forget to commit while focused on debugging, or the Gateway’s auto-save might overwrite your manual changes. Traditional Git completely fails in the face of such “non-human modifications.” Mindkeeper solves this with a shadow repository design: it uses isomorphic-git to maintain an independent Git history in the .mindkeeper/ directory, your files stay in place, and every change—whether manual or automatic—is captured by a 30-second debounce window and turned into a commit with a semantic summary.

How it works: Mindkeeper uses isomorphic-git (pure JavaScript, no system Git required) to maintain a shadow Git repository alongside your workspace. The Git data is stored in the shadow repository at <workspace>/.mindkeeper/, while your files remain in their original location.

~/.openclaw/workspace/
├── AGENTS.md              ← tracked, stays in place
├── SOUL.md                ← tracked, stays in place
├── MEMORY.md              ← tracked, stays in place
├── memory/
│   └── 2026-03-04.md      ← tracked, stays in place
├── skills/
│   └── my-skill/SKILL.md  ← tracked, stays in place
└── .mindkeeper/           ← git history data (hidden, auto-managed)

Two Modes: Let the AI Manage Its Own History, or Take Full Control Yourself

Mindkeeper offers two usage modes that are essentially two interfaces to the same engine.

OpenClaw plugin mode suits scenarios where you want the Agent to have “self-awareness.” Once installed, the Agent gains five tools:

• mind_history — view the change timeline
• mind_diff — compare version differences
• mind_rollback — roll back files after confirmation
• mind_snapshot — create a checkpoint before a risky edit
• mind_status — show the current tracking status

You can directly ask, “What changed recently in SOUL.md?” and the AI will generate a readable summary instead of dumping a raw diff on you. Even cooler, when the Agent notices its recent behavior is off, it can proactively suggest: “I noticed a change in my reply style—would you like to roll back to the version from three days ago?” This introspective ability upgrades the Agent from a passive tool to an active collaborator.

Standalone CLI mode suits scripted workflows or CI/CD integration. Each command accepts a --dir <path> option to specify the workspace to operate on. If you omit the --dir option, Mindkeeper defaults to the current working directory. This means you can use Mindkeeper to manage multiple Agent workspaces, or embed it into an automated testing pipeline: create a snapshot before each test run, and automatically roll back to a known stable version when a test fails.

openclaw mind status              # See what's tracked and pending
openclaw mind history SOUL.md     # Browse SOUL.md change history
openclaw mind snapshot stable-v2  # Save a named checkpoint

Install:

npm install -g mindkeeper

Both modes share the same core engine and shadow storage design, so you can switch seamlessly. Plugin mode suits day-to-day interaction; standalone CLI mode suits batch operations and automation. There’s no right or wrong—only the right fit for the scenario.

Technical Architecture: An Extensible Design Built for Hackers

Mindkeeper’s code structure is itself a hacker-friendly manifesto. The core tracking logic lives in packages/core/src/tracker.ts, implemented on isomorphic-git, which means it doesn’t depend on a system-installed Git and can run in any Node.js environment. The storage layer git-store.ts cleverly points the Git data directory to .mindkeeper/ while the workspace stays clean, avoiding .git conflicts and achieving version isolation at the same time.

File watching uses chokidar plus a debounce mechanism, paired with a lockfile to prevent duplicate monitoring. The diff engine is based on jsdiff, but its output is structured into semantic blocks for easy LLM consumption. Commit message generation supports both template and LLM modes; the latter, under OpenClaw plugin mode, calls the Gateway’s model to turn a raw diff into a readable summary like “removed the limit on response length, now allowing more detailed explanations.”

The plugin system is exposed in packages/openclaw/src/tools.ts, where each tool is a pure function that accepts parameters and returns a structured result. This design lets the community extend it easily—for example, adding mind_branch to support multi-version personality experiments, or mind_merge to combine the best configurations of different Agents. The plugin API isn’t fully stable yet, but the code is simple enough that you can submit a PR to modify it directly.

Quick Start: Get Your Own Time Machine in Three Minutes

npm install -g mindkeeper
mindkeeper init --dir ~/.openclaw/workspace
mindkeeper watch --dir ~/.openclaw/workspace

Now open your OpenClaw session, change anything in SOUL.md, and within 30 seconds of saving, Mindkeeper will automatically create a snapshot. Run mindkeeper history SOUL.md to see the change history. Want to roll back? mindkeeper rollback SOUL.md <commit-hash>—the tool will preview the diff first and only execute after confirmation.

If you use OpenClaw plugin mode, it’s even simpler:

openclaw plugins install mindkeeper-openclaw
# After restarting the Gateway, just ask the AI:
# "What changed in my personality file?"

The Agent will call mind_history and mind_diff to generate a natural-language answer. You can even have it automatically snapshot before modifying a config: “Before you change AGENTS.md, create a checkpoint called ‘pre-optimization’.” This kind of meta-operation capability makes complex tasks safe.

Community Building: We Need Your Real Scenarios

Mindkeeper is an MIT-licensed open-source project (github.com/seekcontext/mindkeeper), but unlike the “dump the code and walk away” model, we rely heavily on community feedback to evolve. The current version (v0.1.x) solves the “having history” problem, but the complexity of the real world far exceeds imagination.

We especially need the following kinds of contributions:

• Real-scenario testing: Use it in your OpenClaw workflow for a month and file the pain points you encounter as Issues. Problems like “Gateway auto-overwrite causes history loss” or “conflicts during multi-device sync” can only be discovered by real users.
• Plugin development: If you have unique memory management needs—say, “automatically tag important memories based on conversation sentiment” or “two-way sync with Notion”—please try implementing them with the plugin API and share them.
• Performance optimization: The current SQLite query slows down at millions of commits, and chokidar has performance overhead under very large file trees. Performance geeks are welcome to profile and optimize.
• Documentation and examples: Write blog posts, record videos, and share your Mindkeeper workflow—this is more valuable than code contributions.

The roadmap is already public: v0.2 focuses on a Web UI and complete snapshot rollback, v0.3 does cloud sync, and v0.4 introduces an AI proactive mode. But these priorities may be adjusted at any time based on community needs. We promise to respond to all Issues and PRs within 48 hours, and technical discussions are fully open.

Conclusion: AI Config Is Code, and It Deserves to Be Taken Seriously

The AI development paradigm of 2026 is shifting from “tuning parameters” to “configuration engineering.” Files like SOUL.md and AGENTS.md are no longer temporary drafts but core code that defines AI behavior. They need version control, they need code review, and they need CI/CD integration. Mindkeeper is the first tool to truly put this philosophy into practice.

It isn’t perfect: the shadow repository design may produce data redundancy in extreme cases, LLM-generated commit messages occasionally hallucinate, and the plugin API isn’t stable enough yet. But these problems are precisely the reason the open-source community exists. We believe that when enough developers throw their own memory management needs into the mix, Mindkeeper will grow into the Git of the AI era—not managing code, but managing intelligence itself.

Now, go give your Agent a time machine. Then tell us how much more interesting the world becomes when it can remember who it is, where it came from, and why it changed.

Sincere beta invitation: at github.com/seekcontext/mindkeeper you can submit PRs and issues, or share suggestions in the community Q&A board.

Your AI config deserves to be remembered by time.