One memory. Every AI tool you use.

Stop re-explaining
your codebase to every AI.

Switch from Claude to Cursor, hit a usage limit, open a new chat — and you're back to explaining your stack, your conventions, your decisions, from scratch.

Persistly stores that context as real commits in your own GitHub repo, so any AI tool you connect reads it automatically, before it replies.

No credit card. 2-minute setup.
Memory lives in your GitHub repo, not ours Works across Claude, Cursor, Copilot & more Free while in beta
✕ Re-pasting the same project summary into every new chat
✕ Claude and Cursor making conflicting decisions on the same file
✕ Losing all context the moment you hit a usage limit
persistly.map — every decision, logged
read before every reply
a3f9c2e2 min agopersisted
+ theme.js — decision: CSS variables for dark mode
~ settings.jsx — added toggle, matched ProfilePage style
Read by Claude Desktop before responding. No prompt needed.
f11a08dyesterdaypersisted
+ api/rateLimit.js — added, tied to existing auth middleware
- hardcoded 100ms retry delay — replaced with backoff
Same memory, read by Cursor in a different session.

Runs over MCP (Model Context Protocol) — the open standard AI tools use to read and act on outside data. Connect once; every tool you use shares the same memory.

This isn't Cursor's or Copilot's built-in memory. Built-in memory dies the moment you close that app or switch tools. Persistly's memory is a file in your repo — it survives tool switches, machine switches, and model switches, because it was never tied to any one of them.
Works with
Claude Desktop Claude Code Cursor VS Code Copilot Windsurf Goose
Three tools. Zero memory. Until Persistly sits in the middle
Same setup, same tools — watch what changes when they share one memory.
Without Persistly With Persistly
Every tool starts from zero. One shared memory, always in sync.
Persistly
Sitting idle Reads context first
What's the context?
Got it — full context
Claude
Claude Full context, automatically
What should I do?
Right where I left off
Cursor
Cursor Same memory, new session
No memory of this project
Every change, logged
GitHub
No memory of past decisions Every decision, a commit
Step 1 · 30 seconds
Point it at a repo
Connect a GitHub repo and describe the project once. Persistly writes a persistly.context file into it — that's the memory, and it updates as the project changes.
Step 2 · 1 paste
Wire up your AI tools
One config, pasted into Claude Desktop, Cursor, Copilot, or Windsurf. Each one gets the same tools to read and write memory — no per-tool setup.
Step 3 · automatic
Stop repeating yourself
Every reply starts with full project context, pulled automatically. Every file the AI writes lands as a real commit in persistly.map — visible, revertible, yours.
Built by one developer, in the open
No investors, no growth team, no fabricated "10,000 developers trust us." Persistly is a solo-built tool, free while in beta, because the person building it needed it to exist. If it breaks, that's on one person to fix — and they will.
Questions
How is this different from my AI tool's built-in memory?

Built-in memory lives inside that one tool. Persistly's memory lives in your GitHub repo as real commits, so it's still there when you switch from Claude to Cursor, switch machines, or hit a usage limit and open a different AI entirely.

Does my code ever leave GitHub?

No. Persistly reads and writes directly to the repo you connect. There's no separate copy of your code sitting in a Persistly database — the repo is the source of truth.

What happens if I stop using Persistly?

Nothing disappears. Everything Persistly writes is a normal commit in your own repo, so your project history stays exactly where it is, in your GitHub account, whether or not you keep using Persistly.

Do I need to change how I code?

No. You keep working in Claude, Cursor, or whichever tool you already use. Persistly runs in the background over MCP — it reads context before the AI replies and logs changes as it works.

Is it free?

Yes, free while in beta. If paid tiers come later, existing usage patterns won't be pulled out from under you without notice.

Free while in beta. Your repo stays yours whether you keep using this or not.

Free to use · Built for developers switching AI tools mid-project
Spaces
Persistly

Welcome to Persistly

Create a Space and connect your GitHub repo. AI will read and write your files automatically — with full project memory.

📋 Overview
🗺️ Persistly Map
🔌 Connect AI
Space Info
Name—
GitHub Repo—
Brand—
Industry—
Tone—
cortex.context View on GitHub ↗
Loading…
cortex.map auto-updated by AI
🔗 Your Personal MCP URL
This URL connects Claude Desktop or Cursor directly to your Space. It's unique to you — no downloads, no local setup.
Generating your URL…
🖥️ Claude Desktop Config
Replace the entire contents of your Claude Desktop config file with this. Requires Node.js installed (nodejs.org).
📁 Config file:
Windows: %APPDATA%\Claude\claude_desktop_config.json
Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
Loading…
!
Fully quit Claude Desktop (system tray → right click → Quit) then reopen. Look for 🔨 hammer icon.
✓
That's it — just talk normally. Claude reads your project automatically and saves changes to GitHub as it works.
⚡ Cursor Config
Create or open ~/.cursor/mcp.json and paste this:
Loading…
🤖 Connect Other AI Tools
Claude Desktop and Cursor are set up above. Click any tool below for its exact setup steps.
🪟 VS Code (GitHub Copilot)
VS Code uses a different config key (servers, not mcpServers) and requires Agent mode.
1
Create .vscode/mcp.json in your project, or run MCP: Open User Configuration from the Command Palette for a global setup.
2
Paste this:
Loading…
3
Open Copilot Chat → switch mode to Agent → click the 🛠️ tools icon to confirm Persistly tools are listed.
🌊 Windsurf
1
Open ~/.codeium/windsurf/mcp_config.json (Mac/Linux) or %USERPROFILE%\.codeium\windsurf\mcp_config.json (Windows). Use the gear icon in the Cascade panel → MCP Servers if you'd rather not find it manually.
2
Paste this:
Loading…
3
Click Refresh Servers in the Cascade MCP panel.
⌨️ Claude Code (CLI)
1
Run this in your terminal (inside your project folder):
Loading…
2
Start a session with claude as usual — Persistly tools will be available.
🪿 Goose
1
Run goose configure → Add Extension → Command-line Extension.
2
When asked for the command, paste:
Loading…
💬 ChatGPT
ChatGPT connects to remote MCP servers through its own UI rather than a config file, and currently expects either no auth or full OAuth — not a custom header — so the setup below is best-effort and may not expose write access the same way Claude/Cursor do. Requires a paid plan (Plus/Pro/Business) with Developer Mode enabled.
1
Settings → Connectors → enable Developer Mode if not already on.
2
Add custom connector → paste your MCP URL (shown at the top of this page) as the server URL. Leave auth as "none" — token-based header auth isn't supported in ChatGPT's connector UI yet.
3
In a new chat, click + → More → Developer Mode → select Persistly as a source.
⚠️ Claude.ai (web) does not yet support adding custom remote MCP servers as of this writing — only Claude Desktop and Claude Code do.
🛠️ Tools Available to AI
read_context()
Called automatically first — reads all files, cortex.context, and change history
save_progress(path, content, is_new)
One call saves the file to GitHub and updates the change history — no separate map call needed
ask_codebase(question)
Ask a targeted question — routed through Groq, returns a short answer instead of full file dumps to save tokens
read_file(path)
Read one specific file from GitHub
update_context(content)
Updates cortex.context when project goals or stack change
list_files()
Lists all files in the GitHub repo
delete_file(path)
Deletes a file from GitHub
⚡ Claude is told to call read_context automatically when it connects — you no longer need to ask it to.
1
Details
2
GitHub
3
Repository
Create a Space
A Space is a persistent AI memory for one project or client.
🏢 Brand Context (optional)