LUCI local MCP screen context for coding agents

Memories.ai launched LUCI Desktop on September 22, 2026 as a free Mac and Windows app. The launch post describes it as on-device screen and meeting memory that coding agents (Claude Code, Codex, Cursor) can query. Capture and indexing stay on the machine. The agent pulls context; it does not drive the desktop.

This post stays with that launch story, the Agent Bridge docs, and the MCP docs. It is a case study for local screen history as agent context. It is not a Memories.ai review, and it does not claim LUCI ships a supported path for OpenClaw, Hermes, or Grok Bot.

Use LUCI when you want a coding agent to recall what was on screen or said in a meeting without uploading that history to a vendor cloud. Prefer skills first (Luci-skills); fall back to local MCP for Claude Code, Codex, Cursor, or any MCP client. Keep LUCI running while you expect live memory. Quitting the app cuts the live path; memory only grows while capture is on.

Do not confuse this with computer-use (click, type, screenshot-driven control), an MCP gateway that prunes tool calls, or the browser-vs-MCP action-surface debate. Those are adjacent posts with different failure modes. Start from what MCP servers are and local vs remote MCP if you need the protocol framing.

Rewind and Microsoft Recall are products a person opens and searches. LUCI is built so the agent retrieves the history itself. CEO Shawn Shen's launch framing (paraphrased): with Rewind or Recall you open the tool and hand-feed context; LUCI plugs into the agent; nothing leaves the machine. Memories.ai does not build the agent. They give the agent a local path into your own computer history. Their personal-use example: Claude Code distills the day to markdown nightly.

That split matters for operators. A human search UI and an agent-callable memory surface solve different jobs even when both look at screen history.

LUCI turns the screen into context Claude Code, Codex, and Cursor can use, entirely on-device. The launch post targets apps and surfaces without APIs: WhatsApp, browser tabs, PDFs, desktop software. If the useful fact lived only on a window, not in a typed MCP tool or REST endpoint, the agent had no clean way to recall it. Screen memory closes that gap as context, not as a substitute for a narrow tool when one exists.

Per the LUCI launch post, OpenAI's Computer History feature is paid and macOS-limited. LUCI positions itself as free, Mac and Windows, and on-device. Treat that comparison as Memories.ai's launch claim and recheck both products' current docs before you plan a rollout. The design lesson for this site stays the same either way: who indexes the history, where embeddings live, and which process can query them.

Shen frames the hard engineering problem as 100% local indexing: text and embeddings on-device, not cloud-process-then-store-local. Memories.ai also claims partnerships with Microsoft, Intel, AMD, and Qualcomm for on-device model performance, including a Microsoft Build / Nadella reference in the launch post. Keep those as their claims. For your threat model, the operator question is simpler: does indexing stay on the box you control, and which accelerator path does the app actually use on your hardware?

Memories.ai states:

• 100% local indexing and storage; nothing uploaded
• Encrypted local storage that only your own agents access
• Per-app opt-out; password managers and banking excluded by default
• Automatic redaction of sensitive info (for example passwords) as captured
• Runs on an on-device AI accelerator (not CPU) for an all-day light footprint; local meeting transcription is searchable

Those are product claims. Verify them against current LUCI docs and your own capture settings before you treat a shared workstation as safe. Also keep the Agent Bridge privacy boundary in view: memory stays local until the agent pulls it; once pulled, that content is part of the conversation and may leave the machine if the agent runs through a cloud model path.

Agent Bridge recommends skills as the default path and MCP as the fallback. Three skills ship in the Luci-skills repo:

• `luci` - search screen and meeting memory
• `distill` - daily Life folder record
• `summarize-meeting` - meeting summary path

Skills install into Claude Code, Cursor, and Codex skills folders. The same repo also covers Gemini, Copilot, and Windsurf via repo or npx install paths. Skills call a local PATH command that talks to the running LUCI app. If LUCI is not running, Agent Bridge falls back to written Life folder files.

MCP is the compatibility path for Claude Code, Codex, Cursor, and any MCP client. Memory is built and stored on the machine; queries come to the data; the data does not migrate to Memories.ai. MCP binds to loopback only, keeps the token under OS key protection, and rejects website-origin requests. Local call logs on Insights show volume, not search terms.

From the MCP integrations page and MCP docs:

1. 1Enable Screen Memory in LUCI.
2. 2Leave the app running while you expect capture and live queries.
3. 3Copy the URL, token, and client snippets from the Screen Memory panel.
4. 4Wire the client: Claude Code (`claude mcp add --transport http`), Codex (`~/.codex/config.toml`), or Cursor (`~/.cursor/mcp.json`) with the Bearer token.

Documented capabilities include exact string search, semantic or fuzzy search, app and time scoping, time-range digest, spoken-word recall, and full-context drill-down.

Operational constraint: if you quit LUCI, the agent cannot reach live memory. Memory only grows while capturing. Plan for that the same way you plan for a local MCP server that is down: the client config may still exist, but the data path is gone until the app is back.

Keep LUCI in its lane:

• Cursor Self-Hosted Machines and computer use: opt-in desktop control (click, type, screenshots) on a worker you manage. LUCI recalls screen history; it does not operate the UI.
• MCP gateway enforcement before tool calls: a proxy that prunes risky tools, brokers secrets, and audits tools/call before execution. LUCI is a memory source, not a policy gateway.
• Browser vs MCP as the wrong surface: choosing API or MCP tools versus driving a browser for actions. LUCI is passive screen history used as context, not an action surface for mutations.
• Google Home MCP for physical-world agents: remote OAuth device control. Different domain, same lesson: know whether the tool reads, writes, or only recalls.

Also useful nearby: what are MCP servers, local vs remote MCP, trust boundaries for self-hosted agents, and OpenClaw vs Hermes.

OpenClaw and Hermes are processes you run. You choose model routing, toolsets, sandboxes, and which MCP servers attach. Grok Bot-class personal agents raise the same split in smaller form: where planning runs, where tools run, and what context the host can see.

Memories.ai's launch and docs name Claude Code, Codex, Cursor, and other MCP clients for skills or local MCP. They do not document a first-party OpenClaw, Hermes, or Grok Bot path. Do not invent that support. The useful comparison is architectural:

• If context lives only in chat paste, the agent forgets whatever never got pasted.
• If context lives in a cloud computer-history product, indexing and retention follow that vendor's rules.
• If context lives in on-device LUCI memory, the agent queries a local store (skills or loopback MCP) while the app runs; cloud models still see whatever the agent pulls into the prompt.
• If you self-host OpenClaw or Hermes, a local screen-memory MCP is optional context beside tools you already expose. It does not replace tool policy, sandboxes, or trust boundaries on the Gateway you operate.

Write the trust question down before you enable capture on a shared machine: which apps are opted out, who can read the Bearer token, and whether the agent path is local-only or cloud-backed.

Whether you evaluate LUCI for personal use or a small team:

1. 1Decide capture scope: which apps stay opted out; confirm banking and password managers stay excluded.
2. 2Prefer skills install from Luci-skills; use MCP snippets only when the client needs them.
3. 3Keep LUCI running during work you expect the agent to recall; treat quit as "live memory offline."
4. 4Store the MCP Bearer token like any other local credential; do not paste it into tickets or shared repos.
5. 5Assume cloud agents: anything the agent retrieves can leave with the conversation.
6. 6Separate personal capture machines from shared CI or pool workers that should not index colleague screens.
7. 7Recheck current Luci MCP and Agent Bridge docs before you script installs across a fleet.

For build work, AI agent systems place memory tools beside human gates, MCP development shapes narrow tools when screen history is the wrong default, and systems integration keeps credentials and side effects on the right identity.

OrchestriAI is an independent implementation provider. Product names are used for identification only. OrchestriAI is not affiliated with, endorsed by, or sponsored by Memories.ai, LUCI, Anthropic, OpenAI, Cursor, OpenClaw, or Nous Research / Hermes. This article summarizes Memories.ai's September 22, 2026 LUCI Desktop launch, the LUCI site, Agent Bridge docs, and MCP docs as of early October 2026. Features, client snippets, privacy defaults, and partnership claims can change. Confirm current Memories.ai and LUCI docs before you size a rollout. OpenClaw, Hermes, and Grok Bot appear here only as design comparisons for where context and tools sit, not as products Memories.ai listed as supported.