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.
Table of contents
- 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
HistorySQLite → 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
HistorySQLite) - 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).
Top comments (0)