How to run Pai/LifeOS on multiple machines - but have one memory layer

[luccomo]

Anyone managed to get a single memory plane when running claude/Pai on multiple machines
I tried the Git approach but it's messy
Thanks all

[stratofax]

TL;DR: Two components to share memories: a git-versioned Markdown "slipbox" for long-term shared knowledge, and a local ntfy message bus for real-time coordination. The trick that keeps Git from getting messy: I never sync the raw memory plane, only a curated long-term layer.

The reason Git felt unwieldy is almost certainly that you were syncing the memory plane itself. I don't. Instead, I keep each agent's short-term memory local and sync a separate, deliberately curated long-term memory layer that's fully version controlled. That one split removes almost all of the mess: no conflicts over transient memory state, no per-machine noise — just the knowledge worth keeping. And each agent can still maintain their own local memories and configuration.

Here's the whole system. I run several PAI/LifeOS agents (v4 and v5, with v6 rolling out on a new VM right now) across different machines, and I share knowledge between them without sharing the memory plane directly. The system consists of two parts: a shared repo and a message bus.

1. A shared knowledge repo — the "slipbox."

I keep a Wiki/Slipbox/Zettelkasten repo of Markdown files, cross-linked and organized into sensible folders (I use Obsidian as my primary editor, with occasional forays into vim), and clone it onto every machine running LifeOS. I ask my agents to offload their memories into new Markdown files in this slipbox and keep just a link to each in their memory, so they can refer to these offloaded memories any time. That lets me share checklists, technical notes, writing style guides, coding standards — whatever I want — across every machine.

I think of this as my agents' long-term memory, and there's a huge benefit to keeping it separate from (but linked to) the short-term memory plane: only the most valuable, reusable memories get stored this way, and transient learnings can be safely ignored instead of cluttering the shared knowledge base. GitHub keeps it all under version control and lets multiple agents contribute.

2. A local message bus — ntfy.

I also built a small messaging bus on top of the excellent [ntfy](https://ntfy.sh/) project, so my agents can talk in a group chat that I can watch too. All an agent needs to connect is a curl command — no MCP server to stand up or expose. It's local-only and authenticated (over Tailscale), so there's no internet-facing endpoint to attack the way an open MCP server can be. (I still treat message contents as untrusted input, with the same discipline as any text an agent reads.)

The notification layer massively increased the value of the slipbox. Now, when one agent posts a new doc to the slipbox, it can notify the others immediately and solicit review, feedback, and edits in real time.

A few features worth calling out:

• Specialties beat a clone army. Each agent has different capabilities and perspectives, and because they run on isolated machines/VMs, each can have a different level of access to shared resources — external APIs, file servers, specific local tools. I find that far more useful than N copies of the same agent. But best of all, the different perspectives mean each agent gives valuable and unique feedback or analysis. This invariably leads to higher-quality output.
• It's completely agent-agnostic. This works across multiple LifeOS versions, but also with vanilla Claude Code installs and even other LLMs in different TUIs — for example, OpenCode running a local Gemma model.
• Onboarding is trivial and non-invasive. I can add a new agent with a simple onboarding process and without touching the existing agents. A new agent just shows up in the group chat with access to the slipbox.
• Every agent has its own voice. Each one reads out (text-to-speech) the opening of any message it posts to the chat. When I hear them all talking back and forth, I know they're really getting stuff done. Not gonna lie — that's my favorite feature now.