- Home
- Skills
- Agents & Orchestration
- Agent Memory over Tailscale
More screenshots
Works with the AI Agents you already use
Agent Memory over Tailscale
Shared, project-scoped semantic memory for Claude Code and Codex synced over Tailscale.
$9
Agent Memory over Tailscale
Example session with this skill installed
Search my past project history to find out why we decided to use sqlite-vec instead of MongoDB for this implementation.
- Read your context and instructions
- Compiled the agent memory over
I searched this project's shared memory for the database decision.
$ python3 memory.py search "why sqlite-vec instead of mongodb"
● Use sqlite-vec, not MongoDB [entry · github.com/acme/checkout-api · relevance 0.67]
Self-hosted Mongo has no native vector search; Atlas would put data outside the tailnet.
Rationale: One SQLite file on the hub keeps vectors, FTS and sessions together with no extra service.
What was decided
| Decision | Use sqlite-vec, not MongoDB |
| Why | Self-hosted MongoDB has no native vector search, and MongoDB Atlas would move your data off your own machines |
| Trade-off accepted | One SQLite file on the hub holds vectors, full-text search and sessions, so there is no extra database to run |
| Scope | This project only (github.com/acme/checkout-api) |
This decision is pinned, so I'll treat it as settled and won't re-open the database choice unless you ask.
Next steps
- Run
python3 memory.py threadsto see unfinished work from earlier sessions in this project. - Run
python3 memory.py briefat the start of each session for a short summary of recent work, decisions and open threads. - If you change direction later, record it with
python3 memory.py decide "<title>" "<what changed>" --rationale "<why>"so the next agent, on any of your machines, sees the new decision.
Connects securely to your tools. The creator never sees your data.
About this skill
Your coding agents forget everything between sessions, and a session on your laptop knows nothing about the one on your desktop. Agent Memory gives every Claude Code and Codex session on your Tailscale network one shared, project-scoped memory, so a new session starts from a few hundred tokens of context instead of a cold start or a re-read transcript.
What it does
- Project brief: a short summary of recent sessions, decisions in effect and open threads for the project you're in, scoped by git remote so unrelated work never leaks in.
- Search past work: semantic + keyword search over session summaries and pinned decisions, answering "why did we choose X?" without digging through transcripts. Returns an explicit "no relevant context" instead of weak matches.
- Pinned decisions: record conclusions ("use sqlite-vec, not Mongo") so the next agent, on any machine, doesn't re-argue settled questions.
- Cross-project search: deliberately widen to every project when you want to find how something was solved elsewhere.
- Setup doctor:
memory.py doctorchecks the hub URL, hub health, shared key, Tailscale and the session watcher, and prints the fix for anything wrong. - Guided setup: the skill walks your agent through installing the hub (Docker, Linux, macOS or Windows), exposing it with Tailscale Serve, and adding a watcher on each device.
How it works
- A small watcher on each device captures Claude Code and Codex sessions, redacts secrets locally, and sends compact events to your hub.
- The hub (free, open-source, MIT) stores everything in one SQLite file and writes session summaries.
- Your agent runs
python3 memory.py briefat session start,searchmid-task, anddecidewhen a choice is worth keeping.
What's included
SKILL.md: when and how the agent should use memory, plus setup and troubleshooting stepsmemory.py: zero-dependency client (Python stdlib only) with thedoctordiagnosticreference/setup.md: step-by-step setup for every platform, MCP config and a troubleshooting tablecommands/memory.md: optional/memoryslash command for Claude Code
Privacy
Self-hosted: your sessions stay on your machines and your tailnet. The only optional outside call is to NVIDIA NIM for embeddings and summaries, and only if you add a free API key. Without it, keyword search and extractive summaries still work.
Known limitations
- Needs the hub running on one always-on machine.
- The project key comes from the git remote or path, so the same repo checked out without a remote in two places can get two keys. The brief points you to related projects when that happens.
- Keep secrets out of what you write. The watcher redacts common secret formats, but don't rely on it alone.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.
Requires self-hosted hub and Tailscale. Project keys depend on git remotes or paths. Python 3.10+ required. Manual setup of environment variables like AGENT_MEMORY_URL needed.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 16 days ago
- Software
Python 3.10+agent-memory-over-tailscale hubTailscale
Git
- Optional
Docker
Get the free hub at github.com/ethanrxla/agent-memory-over-tailscale. Tailscale is for multi-device use; Docker can run the hub.
Permissions
Shell: runs the bundled memory.py client. Network: talks only to your own hub (AGENT_MEMORY_URL), on localhost or your tailnet. Environment variables: reads AGENT_MEMORY_URL and AGENT_MEMORY_SHARED_KEY. The agent asks before running any setup command that installs a service or changes Tailscale settings.