window-memory

window-memory

Tomorrow, just say hi to your AI. It already knows where you left off:

"Last time you were fixing the login flow. It broke because the token expired. Your goal: ship by Friday. 3 days left."

You didn't explain anything. You didn't keep a notes file. Window Memory handed it the full picture, including the reason behind every decision.

npx -y window-memory init

Free. Local-first — runs on your own computer with your AI key. Works with Claude Code, Cursor, and Codex. Pro ($15/mo) adds cross-device sync, AI included (no key to set up), and team sharing.

One-time tip: if your editor was already open when you ran this, restart it once so it picks up Window Memory. After that, every new session catches up on its own — nothing else to do.

Get the most out of it

You don't operate Window Memory — you just build. But a few habits make it compound:

• Trust the "Last time you …" that opens each session instead of re-explaining your project.
• Ask before redoing. "What did we try for this?" / "Did this already fail?" — it checks past attempts so you and your AI don't loop back into a dead end.
• Keep your charter true. After a week or two it drafts your project's goal and feeds it into every session to keep your AI on-track. When you pivot, just tell your AI "update the charter — the goal is now X." It also flags when your work drifts off-goal.
• Share the failures (teams). A teammate's "tried X, it broke because Y" saves everyone from hitting the same wall.

Full guide → windowmemory.com/guide

What's new in 0.3.11

Clearer Free vs Pro messaging in the install banner and docs.

What's new in 0.3.9

Fixed: on Windows, the automatic catch-up now actually fires. The "say hi and it's caught up" hook (and the before-each-action recall) were built as a Windows cmd command, but your editor runs hooks through bash — so on Windows they errored out silently and the memory was never injected. They're POSIX-shell now, so opening a new session brings your last work back, on Windows too.

What's new in 0.3.8

Your memory now keeps up while you work — not just at the start. The mid-session catch-up used to lag and get skipped; now it fires reliably as you edit, run commands, and plan, so your AI keeps the why and the past failures in view through the whole build, not only the first message. Plus a new guide on getting the most out of it.

What's new in 0.3.4

When your AI checks git, it catches up on the why at the same time. The moment it looks at where things stand — status, diff, log, what's pushed — it also pulls the matching history from your memory: what you actually did and the reasons behind it. So you get the real picture of where the project is, not just a list of changed files.

What's new in 0.3.3

Window Memory now speaks your language — end to end. Pick English or Korean and your whole memory follows: the dashboard, the "last time…" catch-up, and the cards themselves, all in one consistent language.

A note from me: I build Window Memory on my own, from Korea, and I code in both Korean and English every day. Memory that came back half in one language, half in another always bugged me — so I made it speak each language properly. More of these small, honest fixes are coming. — the founder

Also: smoother switching between your computers on Pro — same projects, same names, wherever you open it.

What's new in 0.3.1

• Fixed: deleting a project now fully removes it. A deleted project's memory could survive on disk and come back — that's fixed. When you delete, it's gone for good.
• Fixed: on Pro, delete now clears the cloud copy too. Removing a project now also permanently wipes its synced copy from the cloud (previously the cloud copy could linger).

What's new in 0.3.0

• Nothing slips through anymore. Even if your computer was off, or you closed things mid-session, your work still gets remembered the next time you open it — no gaps.
• No more duplicates. The same decision won't show up twice. One decision, one card.
• Each card has the whole story. It now captures the full back-and-forth before remembering it, so you never get half a thought.
• A tidier dashboard. Empty, leftover projects clean themselves up, so your list only shows what actually matters.
• Use what you learned in your other projects (Pro). Building something new? Pull a decision or lesson from a past project you built with Window Memory into the one you're in now, so you stop solving the same problem twice. Your projects stay separate — you only bring things over when you want to.

Why I built this

I'm not a developer by background. I build with AI tools — Claude Code, Cursor, Codex — and the thing that hurt most was this: my AI forgot everything between sessions. I'd go in circles without realizing it — retrying things that had already failed, undoing decisions I'd made for a reason, burning tokens. By the time I noticed I was looping, I didn't even know where to start fixing it. If you didn't write the code yourself, that's a rough place to be.

So I built Window Memory. It doesn't just look at git or your code — it remembers how your project was actually built: the intent, the reason, the result, and the failures behind each step. So your AI keeps the context and stops walking you back into the same wall.

• Free, on your machine — one line (npx -y window-memory init) and the loop-breaker is on. Your key, your data.
• Pro — your memory follows you to every device, you watch new decisions land live on your phone, and you can reuse what you figured out in your other projects.
• Team — invite teammates and everyone's builds pool in one place: who built what, with which tool, and every wall they already hit. Your AI avoids the whole team's failures, not just your own.

The problem you already know

You spend half an hour telling the AI about your project. The next day you open it and it knows nothing. Not what you built, not why you built it that way.

So you do what everyone does. You write a CLAUDE.md or a project.md, you keep it updated by hand, and you hope the AI reads it before it starts working. It's a chore, and you forget to update it exactly when it matters most.

What Window Memory does

It watches your coding sessions in the background and keeps the context for you. It writes down what you did and, more importantly, the reason you did it. The next time you open any tool, that context is already there.

And when your AI drifts off your goal — or reaches for something you already rejected — it tells you. This is the part that isn't really "memory": it's not a notebook you query, it's a quiet check that keeps your AI building the right thing. That matters most when you can't read every line yourself. You stop repeating yourself, and you stop babysitting a rules file.

What you get

• Open a session and the AI is already caught up. It knows where you stopped and why your last decisions were made.
• It tells you when the AI drifts. When your AI starts wandering off your goal, or brings back something you already threw away, Window Memory points it out. This is the part that isn't just memory — it keeps your AI building the right thing, which matters most when you can't read every line yourself.
• It remembers the why, not just the what. "We used optimistic locking" is useless a week later if you forget why. Window Memory keeps the reason and what led to it.
• No more hand-writing a project file. Window Memory keeps the context on its own. It never touches your existing CLAUDE.md or .cursorrules, so if you like those, keep them. This runs alongside, not on top.
• Nothing to set up or tune. Your project's goal is fed to the AI on its own, every session. Set it once or let Window Memory draft it from your work, then adjust it from the dashboard. No config files to write, no settings to manage.
• A dashboard anyone can read. Open it any time to see what your AI has been doing, one decision at a time. You don't have to be a developer to follow it. If you set a goal and let the AI run, this is the window you watch to see it's going the right way.
• Same memory across tools on this machine — move from Claude Code to Cursor to Codex and pick up where you left off.
• Your memory follows you everywhere (Pro) — open the dashboard on your phone or another computer and stay caught up.
• Reuse across the projects you've built with Window Memory (Pro). Building something new? Pull a decision or lesson you worked out in a past project into the one you're in now, so you stop re-solving the same problem in every repo. Each project stays isolated by default — you bring things over on demand, nothing auto-mixes.
• It's an open layer, not a walled garden. Query your memory from your own tools - a local REST API and MCP, with semantic, meaning-based search. Issue scoped, rate-limited keys in one click for n8n, Zapier, or any script you write.

Set it up once

npx -y window-memory init

That sets everything up and opens the dashboard. After that, just work the way you already do. Window Memory runs in the background and starts again on its own every time you turn your computer on, so you never think about it.

Query it from your own tools

Window Memory is an open layer, not a walled garden, and this works on the free local setup.

• Local REST API at http://localhost:3847 - read events, full-text and semantic vector search, and pull a project's context.
• MCP server at npx window-memory mcp - your AI tools can call search_events, get_context, get_timeline_summary, and more.
• Scoped, rate-limited API keys with the wm_sk_ prefix - issue them from the dashboard in one click, with presets for n8n, Zapier, and any script you write.

Wire your project's memory into whatever you already run.

Plans

Free: runs on your computer — your AI key, your data. Good if you mostly work on one machine.

Pro ($15/month or $120/year): your memory follows you across computers, your phone, and teammates — AI analysis included, no key to set up. Open the dashboard on your phone from anywhere and watch what your AI has been doing in real time without opening your laptop. Your team shares the reason behind every decision, including the failures: "we tried X, it broke because Y." Nobody hits the same wall twice, and a new teammate gets an AI-written briefing of how the project got here and starts in minutes instead of weeks.

New accounts get a 3-day Pro trial — no key, no card.

Your data stays yours

Local-first. Secrets are stripped before anything is analyzed.

• Free: your AI key, your data, on your machine — nothing sent to our servers.
• Pro: AI included (no key to set up). We never store your raw sessions; only extracted summaries sync to your private cloud space. Your code never does.
• Your API keys are encrypted on your computer and never sent to us.
• We do not read, sell, or share your code or your conversations.

To remove everything, run npx window-memory uninstall.

License

Copyright 2026 Window Memory. All rights reserved. See LICENSE for the full proprietary terms.