CleverPopup: a cross-tool second brain for developers who use more than one AI assistant.

The problem CleverPopup solves

If you build software with AI assistants in 2026, you already know the shape of the problem. It is almost never "the AI isn't smart enough." It is almost always one of these:

• Per-tool amnesia. Your editor's agent remembers this session. Your terminal agent remembers a different one. Your browser chat remembers nothing. Tomorrow, all of them forget everything. You spend the first ten minutes of every session re-pasting architecture notes.
• Context that lives nowhere. The decision you made about the auth flow is in a Slack thread. The schema is in a Figma comment. The deploy runbook is in a Notion doc that nobody updated after the last migration. The AI doesn't know any of it.
• Copy-paste as a workflow. You read a PDF, manually summarize it into ChatGPT, copy the answer into a ticket, paste the ticket into your editor's agent. Three tools, three pastes, three chances to lose fidelity.
• Citations you can't trust. You ask an assistant about your own system. It answers confidently. You cannot tell which line of which document it pulled from — or whether it invented the whole thing.
• Notes that rot. You wrote down the API contract six months ago. It changed three times since. The old note is still there, wrong, and now actively misleading the AI you paste it into.
• Memory that doesn't follow you across tools. Even the best note app is a dead end — your editor can't query it, your terminal can't query it, your CI can't query it. It's a document, not a memory.

CleverPopup is the answer to all six. It is one hosted brain that ingests your heterogeneous sources, builds a graph of facts and relationships, resolves contradictions on its own, and — critically — exposes itself to every AI tool you use through a standard protocol. Your editor, your terminal, your browser chat: all reading and writing the same memory.

What CleverPopup does

CleverPopup is a hosted web application at cleverpopup.com. Once you have an account, you feed it the things you want to remember, and it does the rest: extracts the text, chunks it, embeds it, has a language model pull out the structured facts and relationships, and stores it all in a graph you can query. Then you ask it questions — in the dashboard chat, or from any of your AI tools — and it answers with citations back to the exact sources it used.

Five ingest formats, one pipeline

• Text notes. Paste a note and it is processed synchronously — chunked, embedded, and graph-extracted before the response returns. This is the fast path for "remember this real quick."
• Web URLs. Drop a link and CleverPopup fetches the page, strips it to clean article text with a Readability pass, and runs it through the same pipeline. Good for docs, blog posts, and Stack Overflow answers you keep losing.
• PDFs and text files. Upload a PDF or text file and it is decoded and ingested asynchronously — specs, RFCs, vendor whitepapers, your own design docs.
• Images. Upload a screenshot, a diagram, or a photo of a whiteboard. A vision model performs OCR and captioning, and the resulting text flows into the graph. Good for architecture diagrams and slide decks.
• Audio. Upload a voice memo or meeting recording. It is transcribed with a speech-to-text model and ingested like any other text source.

Every source ends up in the same place: chunked into meaning-preserving segments, embedded as vectors, and represented as nodes (facts, entities, preferences) and edges (relationships) in a knowledge graph. That graph is what makes the difference — more on that below.

The part nobody else does: cross-tool memory

A second brain that only lives in a browser tab is just a fancier note app. The reason CleverPopup exists is the protocol layer. It exposes two standard interfaces so that the AI assistants you already use can read your memory and write to it — without you copy-pasting anything.

• An MCP endpoint. CleverPopup speaks the Model Context Protocol at /api/mcp. Any tool that supports MCP — and in 2026 that is most of the serious ones — can be pointed at it with a single API key. The tools exposed are deliberately simple and high-signal: search_memory, save_memory, save_session_summary, list_projects, batch_save, get_memory, and delete_memory.
• A v1 REST API. For tools that prefer plain HTTP, there is a versioned REST surface — /api/v1/memories, search, batch, projects, and a /me endpoint — authenticated with the same per-tool API keys.

You generate a separate API key for each tool you wire up — one for your editor, one for your terminal agent, one for Claude Code, one for Codex, one for a throwaway script. Each key is scoped to your account. Each tool now sees the same brain: when your editor's agent saves a session summary at the end of a refactor, your terminal agent can search it five minutes later. No sync, no copy-paste, no "let me paste that in here too."

That is the whole pitch in one sentence: your AI tools stop forgetting, and they stop forgetting from each other.

The source for the cross-tool layer and the whole product is open and public on GitHub at github.com/dubeychandan996/cursormemory. This writeup stays at the business level on purpose — the repo is there if you want to read the implementation.

How it works under the hood (public-safe)

This is a product writeup, not a source dump, so I am keeping the architecture at the level you need to evaluate it — not the level you would need to clone it. The shape is what matters.

• Frontend and API: Next.js 16 App Router, React 19, TypeScript, Tailwind CSS 4. Server components and route handlers do the real work; the browser holds an anon-scoped SDK client only.
• Backend and data: a self-hosted InsForge backend — Postgres with pgvector for embeddings, plus Auth, Storage, Edge Functions, and Realtime. The graph, the chunks, the sources, and the search RPCs all live here.
• AI gateway: OpenRouter, called server-side only via the OpenAI-compatible SDK. Chat, embeddings, vision (OCR/caption), and speech-to-text all route through one gateway with one key that never reaches the browser.
• Retrieval: hybrid — pgvector approximate-nearest-neighbour plus Postgres full-text search, fused with Reciprocal Rank Fusion, then one-hop graph expansion for structured context.
• Async jobs: an edge function handles file extraction in production, with a local after() worker as a dev fallback so large PDFs don't time out.
• Continual learning: a scheduled cron — what I call "dynamic dreaming" — runs reconciliation in the background to merge, supersede, or decay facts.

Security posture in one paragraph

Every user-owned table has row-level security scoped to the owning user; the search RPCs are SECURITY DEFINER but re-filter by the authenticated user id, so they cannot leak across accounts. Storage objects are path-scoped to the user. The OpenRouter and admin keys are server-only. The MCP and REST APIs authenticate with per-tool API keys tied to your account. Per-tool saves are capped per session and per day so a runaway agent cannot flood your memory or your bill.

SuperRAG: answers with citations you can verify

The chat is the part you will use every day, so it is worth explaining why it is different from pasting your notes into a generic chatbot.

When you ask a question, CleverPopup does not hand the model your raw notes and hope. It runs hybrid retrieval: a vector similarity pass over your chunk embeddings and a full-text search pass, fused with Reciprocal Rank Fusion so neither lexical nor semantic matches dominate. Then it expands the top matching graph nodes by one hop — pulling in related facts the LLM extracted earlier — to give the model structured context, not just prose.

The answer that comes back is grounded and cited. Every claim is tagged with a fact reference like [F3] pointing at a specific extracted fact, and a source reference like [S2] pointing at the exact source it came from. You can click through to the original. If the memory does not contain anything relevant, it says so instead of inventing an answer. That last part — the willingness to say "I don't have information about that" — is the whole point of retrieval over generation.

The knowledge graph and "dynamic dreaming"

A flat pile of notes gets worse the more you add to it — duplicates, outdated facts, and quiet contradictions pile up. CleverPopup's graph model is the answer to that. Every ingested fact is a node with a lifecycle: a status, a valid_from, a valid_to, and a superseded_by pointer. Nothing is ever silently deleted; things are marked.

On a schedule, the "dynamic dreaming" reconciliation job wakes up and does the boring, important work a human never will:

• Merge duplicates. Two nodes that say the same thing get merged into one, with their source references combined.
• Supersede contradictions. An old fact and a newer, conflicting fact get judged — the old one is marked superseded with a pointer to the new one, so the graph remembers the history without confusing the model.
• Decay the stale. Facts that have not been touched and are no longer relevant get marked forgotten and drop out of active retrieval.

Every action is written to an audit log. The result is a memory that gets sharper the more you use it, not noisier — which is the opposite of every note app you have ever owned.

Layered on top of the graph is a profile: a hybrid, editable summary of who you are and how you work, auto-derived from your active preference nodes. It is injected into every chat as uncited personalization — so the model knows your stack, your conventions, and your taste without you restating them every time.

Connectors and weekly intelligence

The fastest way to keep a second brain fresh is to stop being the one who feeds it by hand. CleverPopup has connectors that sync external services into the same ingestion pipeline on a schedule.

• GitHub. A GitHub App syncs the things that actually describe a codebase — framework schemas, migrations, models and entities, Markdown docs, READMEs, and issues — and derives schema maps from them. Syncs are incremental and idempotent, so re-running a sync never duplicates a chunk or a node.
• Email (Gmail and IMAP). Email is where a huge amount of institutional knowledge actually lives — decisions, threads, vendor correspondence. The email connectors are gated and disclosure-based, so they only run for users who have explicitly accepted the processing terms.

On top of synced and manually-ingested memory, CleverPopup generates weekly insights and optional digest emails — a model looks at what you added and asked about that week and writes you a short, useful summary. It is the difference between a memory you forget exists and one that actively surfaces what you learned.

The dashboard: one screen, your whole memory

You should not have to write a query to answer "what does my second brain actually know." The dashboard gives you, on a single page:

• Source and memory counts — how much you have ingested and how big the graph has grown.
• Memory growth — an area chart so you can see your knowledge base compound over time.
• Recent ingest activity — the last sources you added and their processing status.
• Chat history — every grounded question you have asked, with citations intact.
• Analytics — retrieval latency, ingest throughput, and per-tool API usage so you can see which assistant is actually leaning on your memory.
• A quick-add composer pinned to the top — paste a note, a URL, or drop a file without leaving the dashboard.

CleverPopup vs. the default AI workflow

I am not going to pretend a second brain is the right tool for every single person. But for the kind of developer CleverPopup is built for — someone using two or more AI assistants on a real codebase — the math comes out clearly in favor of a shared, cited, self-maintaining memory. Here is the honest comparison:

The short version: if "re-paste context into a new chat" is a real line item in your day, CleverPopup pays for itself in the first week.

A real workflow: from zero to "your tools remember each other" in 5 minutes

Here is what onboarding actually looks like. Five steps, no infrastructure to stand up, no agent to install on your laptop.

1. Create your account. Sign up at cleverpopup.com. You land on the dashboard with an empty memory and a quick-add composer at the top.
2. Drop in your stuff. Paste the notes you keep re-using. Drop the URLs of the docs you keep losing. Upload the design PDF and the architecture diagram. Connect your GitHub repo so the schema and READMEs sync in. Each source is processed and added to the graph — watch the memory count climb.
3. Ask a grounded question. Open the chat and ask something only your memory can answer — "what did we decide about the auth flow?" You get a cited answer with [F#] fact and [S#] source references you can click through. If it is not in your memory, it says so.
4. Wire your AI tools to the same brain. In Settings, generate a per-tool API key — one for your editor, one for your terminal agent, one for Claude Code or Codex. Copy the one-line MCP config and paste it into each tool. That tool now speaks to your CleverPopup memory.
5. Stop re-explaining yourself. End a refactor session and your editor's agent saves a session summary to memory. Five minutes later your terminal agent searches that same summary. Tomorrow, both of them still know. That is the whole point.

Who CleverPopup is for

• Developers using two or more AI assistants — an editor agent, a terminal agent, a browser chat — who are tired of each one forgetting what the others learned.
• Founders and tech leads who keep decisions scattered across Slack, Notion, GitHub, and email and want one queryable memory.
• Small teams that want a shared institutional memory instead of each member re-discovering the same context.
• Anyone who has been burned by a confident, un-cited AI answer about their own system and wants claims they can trace back to a source.
• Anyone whose notes have rotted — the old API contract is still there, wrong, and actively misleading the AI you paste it into.

It is not for you if you only ever use one AI tool in one session, if you do not mind re-pasting context, or if your notes are few enough that search already solves the problem. CleverPopup earns its keep when memory compounds and crosses tool boundaries.

What is intentionally not in here

A few things I deliberately left out of this writeup, because this is a product blog, not a source dump — the public repo is linked above for anyone who wants the implementation:

• The exact environment variable names, production host details, and bucket identifiers.
• The internal route file layout and migration SQL beyond the public API surface.
• Any actual API key values, of course, and the per-account configuration details.
• The specific model cost figures and the pricing tiers — those live on the product page, not here.

If you are evaluating CleverPopup for yourself or your team and want a deeper technical walkthrough — architecture diagram, schema, security review, a guided onboarding of your repos and tools — I am happy to do that on a call. The point of this post is to give you enough to decide whether it is worth the call.

Start using a memory your tools share

If your current AI workflow is "paste the same context into a new chat, again", we should talk. The fastest path is to just start:

• Sign up at cleverpopup.com and ingest your first sources in a couple of minutes.
• Generate a per-tool API key and point your editor, terminal, and CLI agents at the MCP endpoint.
• Connect your GitHub repo so your schema and docs sync into memory automatically.
• Ask a grounded question and watch it answer with citations back to your own sources.

Self-serve when you want to try it now. A guided call when you want your whole team onboarded properly — repos connected, tools wired, conventions captured in the profile. Either way, the goal is the same: your AI tools stop forgetting, and they stop forgetting from each other.

Prefer email? Reach me at dubeychandan996@gmail.com.