Keel
An AI assistant whose memory belongs to you
154 followers
An AI assistant whose memory belongs to you
154 followers
Keel is a local-first desktop app for macOS and Windows that captures what matters from your conversations into plain markdown files on your disk. Bring your own model - Claude, GPT, OpenRouter, or Ollama. Your context stays with you, not the vendor. Open source, MIT. https://keel-labs.github.io/
Hey Product Hunt 👋
I built Keel because every AI tool I tried had the same problem: my context lived inside someone else's product. The notes, the history, the slowly-built understanding of my projects - all trapped behind one vendor's login. The day that model gets deprecated or that company changes direction, my brain goes with it.
Keel flips that. Your memories live on your disk, in plain markdown, in a folder you own. You can open them in any editor, back them up, version-control them, move them between machines. The model is the part that's interchangeable - Claude today, GPT tomorrow, a local Llama on a flight. The assistant changes; your context doesn't.
A few things worth knowing:
It's a real desktop app for Mac and Windows (Electron + React + TypeScript).
Bring your own API key. No telemetry. No account. No cloud sync (yet).
It's a v1 beta - Apple Silicon only, no Windows/Linux yet, no mobile.
It's a one-person project. I'll read every comment here today; I can't promise to build every feature (yet).
Would love your feedback. Thanks for taking a look.
"Memory belongs to you" is the right framing — but the under-discussed piece is that the memory only compounds value if it's *structured* enough for the assistant to find. Unstructured logs become a noisy haystack the AI re-reads every time; structured memory becomes a template library the AI composes from. We've seen exactly this dynamic on Eloquens (https://www.eloquens.com/channel...) where project-finance model templates work as portable memory across deals — every new mandate is partially solved by what previous mandates already encoded. Question for Keel: do you expose any schema/structure layer so memory can be queried as templates, or is it still primarily unstructured retrieval?
@samir_asadov Good distinction - structured memory composes, unstructured memory just accumulates.
Keel today is structured-by-convention, not schema-by-type. Every project and knowledge base has a defined shape (index, sources, synthesized concepts, open questions, outputs) plus an AGENTS.md that encodes editing rules the assistant follows when reading or writing. Retrieval leans on that map rather than pure embedding soup.
What we don't have yet - and what your Eloquens example is really pointing at - is a typed template layer: "this is a Deal Memo, here are its slots, compose a new one from prior instances." That's a meaningfully different primitive, and it's the natural next step on top of the organized-markdown base.
@medhaforcebewithyou Typed-template-layer is the unlock. Convention-by-shape (index, sources, synthesized concepts, etc.) works for the assistant but a human user reaches for it differently — the moment you give a deal modeler a "Deal Memo" template with named slots, retrieval changes from "find the relevant note" to "populate these specific gaps from the corpus." That's the difference between an AI assistant and a junior associate.
The project-finance parallel is exact: a tax-equity flip memo has ~12 canonical sections; a merchant-power deal has ~9; revenue-of-time sensitivities have a different shape again. Once those typed shapes exist, every prior deal becomes a contribution to the next one rather than just a searchable history. Excited to see where you take this — the on-roadmap mention is the right next move.
The "memory belongs to you" framing is really compelling. Curious about how the memory extraction works in practice. Does it capture everything from every conversation, or does it intelligently decide what's worth remembering? Because the signal-to-noise ratio in my AI chats is probably 20% actual decisions and insights and 80% back-and-forth debugging. Storing all of that would be noisy - storing just the conclusions and key context would be gold.
@ben_gend Yes, totally!! Keel doesn't dump conversations into your workspace - that would be the noisy version you're describing. Instead, the assistant decides in the moment what's actually worth keeping: a decision, a fact about a project, a new task, a useful conclusion. Those get summarized and routed into the right project folder.
You can also explicitly capture anything (a URL, a snippet, a thought) when you want to force the issue. So it's intelligent-by-default, manual-when-you-want-it.
@francesco2689 when you set up Keel, you have to pick a folder on your computer - that is the folder where all the content and context gets saved. You can browse them directly via your file browser and make edits / use a text editor of your choice. I have a commit coming soon that lets you browse and edit within Keel itself, using a knowledge browser.
The markdown-on-disk approach is underrated. Most "local AI" tools still phone home for context storage, which defeats the point. One thing I'm curious about: how does Keel handle memory across different models? If I switch from Claude to Ollama mid-project, does the context transfer cleanly or do you lose the thread?
@christian_knaut Yeah, the markdown-on-disk thing was the one of the main reasons of building this - your context stays on your device.
On switching mid-project: the conversation should transfer cleanly. Chat history is stored provider-agnostically (SQLite under your workspace), and on each turn it's reformatted for whichever provider is active - Claude, OpenAI, or Ollama. So you can answer a turn with Claude, switch to a local Llama via Ollama for the next one, and the model sees the full prior thread.
Two honest caveats:
Claude's "thinking" blocks don't persist — they're rendered live in the UI but not saved, so a different model won't see them. The final answers do carry over.
Tool definitions are re-adapted per provider, so a tool call made by Claude becomes plain message history for Ollama (which may not have the same tool wired up).
Beyond the chat thread itself there's also a workspace-wide layer - your markdown files are embedded and pulled in via RAG, and Keel auto-extracts durable facts into a keel.md memory file after each chat. That part is model-independent, so it follows you across providers too.
tl;dr: switch freely, the thread should stay intact; but Claude's chain-of-thought port over to another model.
Caveat: It's still in beta, so there may be a few rough edges. If you try it, let me know if it didn't work as expected.
The "memory stays with you, not the vendor" angle is exactly right. We run multiple AI workflows across a B2B services operation and the biggest friction isn't the model — it's that context resets with every session. I've tried solving this with prompt templates and shared docs but neither is clean. Curious how you're handling sync when the same underlying question comes up across different users on the same team?
@thekrew Totally hear you - context reset is the real tax. Yes, great use case - multi-user sync is on the roadmap!
Hey Medha — 'the day the model gets deprecated, my brain goes with it' should be on the homepage. As a fellow solo founder, looking forward to the Windows build.
@tsutsu Thanks for the feedback! Windows build is ready as of last night. Excited to connect with another solo builder!
@medhaforcebewithyou Perfect timing on the Windows build! 🎉 I'll grab it tonight and report back with real-world feedback once I've put it through a few work sessions. Likewise on the solo-builder connection — always good to find others working on the 'context belongs to the user' side of the AI stack.