Memory app bridging Claude Code/Codex/Cursor over MCP

Tiger — Wed, 20 May 2026 07:19:38 +0000

I'm Tiger, an indie developer who just shipped Contextberg — a Windows-native memory app for AI agents — and I wanted to share the design notes behind it.

What is Contextberg?

A local memory app for AI agents on Windows, distributed on the Microsoft Store.

It runs quietly in the background and records 5 signals from your PC — screenshots, browser history, keystrokes, app/window usage, and agent conversation history — then serves the distilled memory back to any MCP-compatible agent (Claude Code, Codex, Cursor, GitHub Copilot, OpenClaw, LM Studio).

MCP server built in — one-click connect to Claude Desktop / Cursor / etc.
3 kinds of memory auto-generated: 15-min Activity, hourly Report, daily LTM
Raw data stays local; cloud AI processing is zero-retention
~250MB active / <1% idle CPU — light enough for a corporate laptop
Free tier from day one

Close your laptop Friday mid-debug. Open Contextberg Monday. Your agent already knows where you left off.

Why I built this

These days, my development style revolves around using multiple AI agents in parallel — Claude Code for design discussions, Codex for review and diff verification, Cursor for assisted editing, GitHub Copilot in the terminal.

The problem: none of these agents see each other's conversations. And on top of that, most of my decision-making happens before I even open an agent — reading Stack Overflow, browsing GitHub Issues, scribbling notes in another app. By the time I land in a chat, only the last mile of thinking is captured.

So every session starts with me re-explaining myself.

Concrete examples that piled up:

Monday night, I spent 30 minutes reading Stack Overflow and a GitHub issue, decided on an approach. → No agent ever saw this (I didn't open one)
Tuesday morning, I open Claude Code to continue. → It has no idea what I read Monday, or what I decided in another agent. Starts from zero.

To make "pick up from Friday" actually work, I need a place that records the whole working context — what was on my screen, what I read in the browser, what app I was in, what each agent and I talked about.

Why existing tools didn't quite get there

I tried a bunch of similar tools. None of them fully clicked:

Open-source ones require local builds. Setting up a .NET/Node toolchain just to try a memory tool is a non-starter for anyone outside hardcore developers.
"No setup" usually means paid SaaS. Useful, but you hit a paywall before you've experienced the value.
They run heavy in the background. Many residents idle at 500MB–1GB. On a corporate laptop, that's a deal-breaker.
Not designed AI-native. They look like chat history viewers, not something built to feed agents as context.
No MCP / no export path. Even if memory accumulates, the only way to use it is the app's own chat. Nothing flows outward.
macOS-only. The kicker. Windows developers get left out.

To reach non-developers too with a "give your agent memory" tool, I needed something install-free, sign-up-only, lightweight enough to coexist with other tools, and built around MCP from day one.

Four pillars
Try it in 5 minutes
What gets recorded — 5 signals
The Record tab and the Memory tab
Three kinds of memory — used for different purposes
Privacy design — nothing is retained on the cloud side
Performance — why Windows-native
Wiring it to agents via MCP
Plans — Free vs Lite
Who this is for
Roadmap
Closing

Four pillars

01 · Context — Stop re-typing what you already did

Sends per-window screenshots to your agent directly via MCP
Auto-imports browsing history (Chrome / Edge History SQLite → URL & title)
Pulls in conversation history from Claude Code / Codex / Cursor / Terminal
Built-in MCP server — connect a compatible agent with one click

02 · Memory — Your work becomes memory

Short-term memory (Hourly Report): auto-summarized by hour and activity
Long-term memory (LTM): habits, tools, ongoing projects, working patterns
All auto-generated. Your agent can reason over it any time.

03 · Private — Your work data doesn't leave your PC

Activity, screenshots, and browsing history are stored locally
AI processing uses cloud models by default (Google Gemini via a BFF that holds the API key)
Switch to LM Studio for fully offline operation

04 · Remember — Resume where you left off

The moment you come back, Contextberg surfaces a summary of what you were doing
Activity, browsing, and agent history reconstructed across sources
Dive deeper on anything via the in-app chat

Try it in 5 minutes

1. Search "Contextberg" in the Microsoft Store, or open
   https://apps.microsoft.com/detail/9nhpvl6s5dw9
2. Launch → sign in with Google (free plan is fine)
3. Use your PC normally for a few minutes (activity accrues in the background)
4. Open the Memory tab → an Hourly Report should appear within the hour
5. Settings → MCP → click "Connect Claude Desktop"
   (Auto-appends a block to your Claude Desktop config)
6. Restart Claude Desktop and ask:
   "What did I work on yesterday?"

What gets recorded — 5 signals

The starting point of Contextberg's design was a simple judgment: agent conversation history alone is not enough memory.

Tools that import agent conversation logs already exist. But most decision-making happens before you reach the chat box. Reading Stack Overflow, skimming GitHub Issues, staring at a file in VS Code for 30 minutes and not touching it — none of that lands in a conversation log. Only the final move, after the decision is already made, gets saved.

So Contextberg records 5 signals to capture everything happening on your PC:

Signal	What's recorded	Why
App / window usage	Foreground process name, window title, dwell time	Reconstruct "1 hour in VS Code on auth code"
Browser history	URL / title / last-visited from Chrome & Edge `History` SQLite	Reconstruct "I read that Stack Overflow thread"
Screenshots	Active-window capture (PNG)	Let humans and AI re-read what was on screen
Keystrokes	Per-app keystroke log	"What were you typing?" "Where did you get stuck?"
Agent conversation history	Conversation turns from Claude Code / Codex / Cursor / Terminal	Reconstruct cross-agent dialogue

The key is combining all 5 into a single timeline. Conversation history alone tells you what was decided. Add browser, screen, keystrokes, and app usage, and the agent can infer why that decision was made.

"You're recording all that? What about privacy?" — fair question. Everything stays on your PC, only summarized prompts go to the cloud (and if you switch to LM Studio, even those stay local). See the privacy section below.

The Record tab and the Memory tab

Recording silently in the background and pushing through MCP isn't enough. Users need to see what's being captured to trust it. Contextberg has two tabs for this.

Record tab — live activity log

Foreground app switches stream in real-time
Recent screenshots appear as thumbnails
Browser history shows up as it's imported
Daily usage pie chart and stack bar

This turns "I'm being watched" anxiety into "I can see exactly what was recorded" trust. It also works as a personal review tool — what happened while I was away, where the morning went, etc.

Memory tab — short-term + long-term memory view

The tab where you read your own accumulated memory.

LTM is editable by hand — delete things the AI got wrong, add things like "I prefer X" manually
Each Hourly Report links into the in-app Chat for deep-dives ("walk me through this decision")

Three kinds of memory — used for different purposes

Contextberg keeps three kinds of memory with different update cadences and use cases. It's not a linear "compress lower layers into upper" pipeline — they're parallel memory types optimized for different access patterns.

Memory	Update frequency	Primary use
Activity	Every 15 min	"What was I just doing in the last session?"
Hourly Report	Every hour	Daily review, "what did I do this morning?"
Long-Term Memory (LTM)	Every day	Persistent facts (role, preferences, ongoing projects) injected into agents

How memory is generated

Each memory layer is generated by feeding per-app-use screenshots + keystrokes + agent conversations + browsing history as a single bundle to an LLM. Raw signals go in, the model writes the summary out.

[14:00-14:18] VS Code (Contextberg.sln)
  - Editing Views/MemoryView.xaml.cs
  - 4 screenshots (referenced by path)
  - Keystroke excerpt: "Migrate" "Async" "await ctx.Database..."
[14:18-14:35] Edge
  - GitHub: contextberg/contextberg#42
  - Stack Overflow: "EF Core MigrateAsync vs EnsureCreated"
[14:35-15:00] Claude Code (session abc123)
  - Decided "replace with MigrateAsync" → edited AppDbContext.cs
[14:58] git commit "fix(db): use MigrateAsync"

With browser, screen, and keystroke context around the conversation, the agent can infer why the implementation ended up this way.

Activity / Hourly Report / LTM in a sentence each

Activity (15 min): recent signals, near-raw. For "what was I just doing?"
Hourly Report (1 hour): 1-hour Activity rolled up into natural-language summary. The main surface for daily/weekly review.
LTM (1 day): distilled from a day's Hourly Reports — only the things that should persist (role, preferences, active projects). Functions as agent pre-injection context.

One implementation gotcha — LTM section name matching

LTM is structured as Markdown sections like # Active Projects. Ask an LLM to "append to Active Projects" and it'll happily invent ## Current Projects instead. Without intervention, the same concept ends up split across 3–4 sections. The fix: a normalization dictionary in MemoryUpdatePipelineService that runs before the merge.

Privacy design — nothing is retained on the cloud side

Contextberg captures screen, browser, keystrokes, app usage, and conversations broadly. Narrowing the input would degrade the "memory" feature directly, so I chose not to.

Honestly: at the scale of an individual developer, local-side privacy has limits. No matter how clever the OS hooks and SQLite handling, perfectly auto-filtering "only the dangerous stuff" is beyond what I can guarantee.

So the line I draw is different: record broadly on the device, but retain nothing on the cloud side.

Microsoft Store certification

The Microsoft Store reviews apps that capture screen content and keyboard input more strictly than other categories. Data handling, encryption, and third-party transmission must all be declared and reviewed. Contextberg has passed this review. The Privacy Statement and support contact on the Store page act as your first line of accountability.

What's stored locally

Screenshot image files (%LOCALAPPDATA%\Contextberg\screenshots\)
Keystroke logs (per-app, in SQLite, with content)
Browser history cache (URL / title / last visit from Chrome & Edge History SQLite)
App usage log (process name / window title / dwell time)
Imported copies of agent conversation history
Auth tokens (DPAPI-encrypted via ProtectedData.Protect(bytes, null, DataProtectionScope.CurrentUser) — only decryptable by the signed-in Windows user)

Browser form input, cookies, and tab body content are explicitly not read.

What gets sent to the cloud

For AI generation (Hourly Report / LTM), Contextberg sends a formatted prompt built from the local records above. That prompt includes screenshot images, keystroke log contents, browsing history, app usage, and conversation history (Gemini is multimodal, so screenshots ride along as images).

But nothing on the cloud side persists. Requests are processed statelessly through a BFF Lambda to Vertex AI Gemini, with the generated text flowing right back to the client and into local storage. No long-lived storage of any of the input.

This is the core of the current privacy design. Record broadly on the device; retain nothing where the data lands. Not perfect, but the most honest line I could draw at solo-dev scale.

Excluding what you don't want recorded

For information you don't want recorded (or sent to the LLM), Settings supports exclusion at multiple granularities:

Per-app exclusion — password managers, banking apps, certain messaging apps pause Record while they're focused
Window title / URL pattern exclusion — *.bank.* window titles, specific domains
Time-of-day exclusion — off-hours, specific time windows
Per-signal toggles — screenshots off only, keystrokes off only
Record pause button — immediate stop, one click to resume

Anything excluded never enters the Activity layer, so it never leaks into Hourly Reports, LTM, or MCP responses.

Auto-exclusion is on the roadmap

Current exclusions require you to configure them upfront. If you handle a secret in an app you didn't pre-configure, it gets recorded. Future work:

Auto-detect password managers / banking apps and pause Record automatically
PII detection and masking on screenshot text
Stronger "now recording" notification banner

Fully local operation is an option

If you'd rather avoid the cloud entirely, switch to LM Studio — Hourly Report and LTM generation run on a local LLM via the OpenAI-compatible endpoint you point Settings at. Zero outbound traffic. Designed from day one for corporate laptops where cloud egress isn't acceptable.

See it, delete it

Record tab shows every recorded item one by one, visually
Right-click any record to delete it on the spot
Settings has ZIP export and delete-all any time

Performance — why Windows-native

When you hear "always-on capture of screen, browser, and keystrokes", the next question is memory and CPU. Measured numbers:

Metric	Value
Idle memory	120–180 MB
Active memory	~250 MB
Idle CPU	< 1%
MSIX size	~100 MB

The design line is keep memory, CPU, and install size small. As an always-on app, anything heavier turns Contextberg into "that thing eating RAM next to Slack and Chrome" and users quietly uninstall.

Why WPF instead of Electron / Tauri

I chose to give up cross-platform from the very first design pass. Three reasons:

Electron residents commonly hit 300–500MB just from boot. With a Chromium process in tow, the < 200MB line isn't realistic.
Heavy Win32 API direct access is needed. Keyboard hooks, foreground window process identification, screen capture, DPAPI, MSIX package identity — each is 1–3 lines in .NET; in Tauri / Electron you'd be wrapping FFI.
MS Store distribution was the plan. WPF + .NET 8 + Windows App SDK is the smoothest path to a clean MSIX.

The trade-off is that macOS / Linux versions need a separate codebase, which is on the roadmap. My bet: "a 250MB Windows-only app" beats "a 400MB cross-platform app" for the initial user base.

I want this on corporate PCs eventually

Long-term, I want Contextberg on company-issued laptops. The developers who'd benefit most from agent memory often do their main work on corporate hardware.

But corporate PCs are usually 8GB or 16GB of RAM. With Slack, Teams, Edge, VS Code, and Docker Desktop running, a 500MB resident is fatal. I see colleagues at work suffering on near-frozen laptops that can barely show a Slack notification (no joke).

"Doesn't get in the way of other tools" is an absolute requirement for any path to enterprise. The line stays at < 300MB.

Wiring it to agents via MCP

Contextberg runs a local HTTP server (http://127.0.0.1:18080) inside its WPF process, fronted by a thin MCP proxy. Drop this one block into any MCP client config (the "Connect Claude Desktop" button writes it for you):

{
  "mcpServers": {
    "contextberg": {
      "command": "npx",
      "args": ["-y", "@contextberg/mcp-server"]
    }
  }
}

Tools exposed:

Tool	Returns
`get_activity`	Recent N hours of Activity (apps, window titles, screenshots, browser history)
`get_daily_memory`	Daily report for a given date
`get_weekly_memory`	Weekly report for a given week
`get_agent_history`	Cross-agent conversation turns from Claude Code / Cursor / Codex
`read_ltm`	Full LTM as Markdown
`update_ltm`	Append diff to an LTM section

What it looks like in practice

You (in Claude Desktop):
  "The auth refactor I was doing Friday — how far did I get?"

Claude Desktop (behind the scenes):
  get_agent_history({ query: "auth refactor", since: "2026-05-08" })

Claude Desktop (to you):
  "On Friday at 5:30pm you finished moving AccessTokenStore to DPAPI.
   Two failing tests remain. Right before that you were reading a
   Stack Overflow thread about `ProtectedData.Protect` thread-safety,
   and it looks like that's the direction you took.
   You were running tests in both Codex and Claude Code in parallel.
   The failing tests are test_token_refresh_idempotent and
   test_logout_clears_pkce_state. Which one first?"

The Stack Overflow reading is nowhere in conversation history — but Contextberg saw it via browser history and the Hourly Report, and the agent now sees it too. That's the win over "conversation-history-only" tools.

Plans — Free vs Lite

Plan	Includes
Free	All core features — capture, MCP, local LLM (LM Studio), 3-tier memory
Lite	Cloud Gemini quota expansion, premium models, longer retention

Free covers MCP, 3-tier memory, and fully-local LM Studio operation. This is intentional: putting "give your agent memory" behind a paywall locks out solo developers and students — the very people who benefit most. Lite is for users who want generous cloud AI quota, premium models, and longer retention; users running MCP + local LLM customization. The boundary is drawn so people can feel the value on Free first.

Who this is for

Developers who use Claude Code / Codex / Cursor / GitHub Copilot daily — the more agents you juggle, the more painful the memory fragmentation
Anyone tired of re-explaining "where I left off" — the morning 15 minutes you lose unconditionally
People who want to resume work quickly — collapse the seams between sessions
People who want AI benefits without sending data to the cloud — LM Studio fully-local operation is designed for corporate-laptop scenarios

If recording screen, browser history, or keystrokes — even locally — bothers you in principle, this isn't for you. The signal width is intentionally broad.

Roadmap

macOS / Linux support
Hermes model integration
Auto-generation of skill commands
Skills management view

Got ideas? Drop them in the comments — your feedback shapes what we build next.

Closing

Contextberg's goal: let Claude Code × Codex (and friends) work across multiple agents without you having to re-explain yourself every session.

Agent conversation history alone wasn't enough, so I wrapped it together with screen, browser, keystroke, and app usage data — as a Windows-native local memory app. And I packaged it so non-developers can use it too: no build, sign-up only, distributed on the Microsoft Store.

You just use your PC; 3 kinds of memory accumulate in the background
The pre-conversation research, browsing, fiddling, and typing is all captured
Open any agent and your past self is loaded via MCP automatically
Active memory ~250MB, idle CPU < 1%, free tier from day one
LM Studio fully-local operation available
Verified with Claude Code / Codex / Cursor / GitHub Copilot / OpenClaw / LM Studio
Product Hunt: https://www.producthunt.com/products/contextberg
Microsoft Store: https://apps.microsoft.com/detail/9nhpvl6s5dw9
Website: https://contextberg.com

Questions, criticism, ideas — leave them in the comments or ping me on X (@screenest_ai).

DEV Community: Tiger