More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Agent Memory over Tailscale

    1

    Shared, project-scoped semantic memory for Claude Code and Codex synced over Tailscale.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agent Memory over Tailscale

    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

    DecisionUse sqlite-vec, not MongoDB
    WhySelf-hosted MongoDB has no native vector search, and MongoDB Atlas would move your data off your own machines
    Trade-off acceptedOne SQLite file on the hub holds vectors, full-text search and sessions, so there is no extra database to run
    ScopeThis 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 threads to see unfinished work from earlier sessions in this project.
    • Run python3 memory.py brief at 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 doctor checks 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

    1. A small watcher on each device captures Claude Code and Codex sessions, redacts secrets locally, and sends compact events to your hub.
    2. The hub (free, open-source, MIT) stores everything in one SQLite file and writes session summaries.
    3. Your agent runs python3 memory.py brief at session start, search mid-task, and decide when a choice is worth keeping.

    What's included

    • SKILL.md: when and how the agent should use memory, plus setup and troubleshooting steps
    • memory.py: zero-dependency client (Python stdlib only) with the doctor diagnostic
    • reference/setup.md: step-by-step setup for every platform, MCP config and a troubleshooting table
    • commands/memory.md: optional /memory slash 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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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 hubTailscaleGit
    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

    Terminal / Shell
    Read Files
    Network Access
    Environment Variables
    Write Files

    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.

    Listed16 days ago

    What's inside

    Frequently Asked Questions

    A new session normally starts cold: you re-explain the project or the agent re-reads files and old transcripts. With Agent Memory it runs one command and gets a few-hundred-token brief of recent sessions, decisions in effect and open threads for this project, from every device on your tailnet. Pinned decisions also stop agents from re-opening choices you already made.

    Session capture works with Claude Code and Codex CLI. Reading memory works with any agent that follows SKILL.md and can run a shell command, since the client is a single stdlib-only Python script. Clients that prefer tools can use the included MCP server config instead.

    Python 3.10+, the free open-source agent-memory-over-tailscale hub on one always-on machine (Docker, Linux, macOS or Windows), and Tailscale if you use more than one device. An NVIDIA NIM API key is optional: it adds semantic search and written summaries through NVIDIA's hosted API. Without it you still get keyword search and extractive summaries.

    No, it is scoped per project by default. The project key comes from the git remote (or path), so a session in one repo never pulls context from another. You can widen deliberately with global-search when you want to look across projects.

    Yes. global-search searches session summaries and pinned decisions across every project on your hub, so you can find how a problem was handled elsewhere. It searches summaries and decisions, not raw source code.

    The hub is free and open source. This skill is the agent side, ready to install: SKILL.md tells your agent when and how to use memory, memory.py is the zero-dependency client with a doctor command that diagnoses setup problems, and reference/setup.md is a step-by-step guide for every platform that your agent can follow to set everything up for you.

    New in Agents & Orchestration