Give your coding agents memory: L2Cache's MCP server and hooks

November 9, 2026 · 6 min read

Coming in L2Cache 2.0. The MCP server, hooks for Grok Build and GitHub Copilot, and the cost warnings arrive in 2.0, which is coming soon. Version 1.4.6, on the App Store today, records Claude Code and Codex sessions with hooks.

Every coding-agent session starts out knowing nothing about yesterday. It doesn't know the bug you fixed last week, the approach you already ruled out, the error you just copied, or the screenshot of the failing build. You end up explaining all of it again, and the agent re-runs diagnostics it ran before.

L2Cache already keeps that history on your Mac: your clipboard, screenshots, terminal commands and every coding-agent session. It connects that history to your agents in two directions:

The agent asks L2Cache, through an MCP server. When it needs an earlier fix, decision or copied snippet, it looks it up.
L2Cache briefs the agent, through hooks. At the start of a session and with each prompt, it adds the small amount of context the agent can't get any other way.

Direction 1: agents ask, through MCP

The Model Context Protocol is a standard way for an AI agent to call tools outside itself. L2Cache ships an MCP server with twelve tools. All of them are read-only: they never change your data.

Coding-agent memory

Tool	What the agent gets back
`get_session_summary`	What an earlier session worked on: the feature, what got done, the next step and the files it touched. The tool agents are told to call first when resuming.
`search_agent_history`	Matches across earlier sessions in Claude Code, Codex, Copilot, Grok Build and Antigravity, by words, code symbols, file paths or error codes. Filters for project, branch, agent and kind (fix, decision, failed command, prompt and so on).
`get_agent_event`	One result in full, with the messages just before and after it.
`get_error_resolutions`	Earlier fixes: the symptom, root cause, what changed, how it was verified and which files were involved.
`get_decisions`	Design decisions and trade-offs from earlier sessions, so the agent doesn't undo one by accident.
`get_recovery_point`	Where you left off in a project: the last request and reply, failing commands, recent terminal commands and changed files.

Clipboard, screenshots and files

Tool	What the agent gets back
`get_recent_clips`	Short previews of what you copied recently, filtered by type or source app if needed.
`search_clips`	Full-text search of your clipboard history.
`get_clip`	One clip in full, including the image if it's a screenshot.
`search_screenshots`	Screenshots found by the text inside them, read with on-device OCR.
`search_memory_folders`	Text inside the files, PDFs and images in folders you've connected to L2Cache.
`get_folder_item`	One of those files in full, or a downscaled image the agent can look at.

So "what was that error in the screenshot I took this morning?" or "we fixed this crash before, how?" become questions the agent can answer itself, without you digging through history.

Built to stay small

Everything an MCP tool returns lands in the agent's context, so the results are kept short: a handful of results by default, short excerpts rather than whole conversations, and fields the agent already knows left out. The agent fetches the full item only when it needs it. The tool list never changes while the server runs, so it doesn't break the agent's prompt cache.

Which agents can use it

Settings › MCP has a ready-to-copy setup line for Claude Code, Claude Desktop, Codex, Cursor and Google Antigravity. You can also paste a prompt into the agent and let it add the server itself.

Direction 2: L2Cache briefs the agent, through hooks

MCP only helps when the agent thinks to ask. Hooks cover the rest. They're small shell commands that coding agents run at fixed moments: when a session starts, when you send a prompt, after the agent edits a file or runs a command, and when it stops. L2Cache uses them for two jobs: recording what happens, and adding a little context at the right moment.

What gets recorded

Which files the agent edited, and which shell commands it ran, including the ones that failed.
A one-line work summary at the end of each turn that edited files. The agent writes it as a hidden comment: the feature, what changed, and the next step. L2Cache checks it against the file changes it recorded, so it never shows the agent's claim as fact. These summaries feed the Your Day card on L2Cache's Today page and the handoffs below.
When you copied an error and the agent fixed it and confirmed the fix with a passing test or build, a short fix record: symptom, cause, fix, verification and files. Copy the same error later and L2Cache's action bubble shows the earlier fix; agents can find it with get_error_resolutions.

What gets added

A handoff when a new session starts: the goal, files, completed and pending work, and where the last session left off. See starting a fresh session without losing context.
Recent clipboard items with your prompt: up to five things you copied in the last 30 minutes that the session hasn't seen and you didn't paste yourself. Most prompts get nothing, which is the point: it only speaks up when you just copied something relevant.
What compaction dropped: after Claude Code or Codex compacts its context, L2Cache checks the summary and adds back up to five missing facts, such as files edited since the last commit, a command that's still failing, or the next step.
Cost warnings: a note when a session gets heavy, and the cold resume guard when you resume a session whose prompt cache has expired. See why resuming a cold session costs more.

Which agents get which hooks

Hook feature	Claude Code	Codex	Grok Build	GitHub Copilot
Live capture (edits, commands, sessions)	Yes	Yes	Yes	Yes
Handoff when a session starts	Yes	Yes	Yes	No
Recent clipboard with your prompt	Yes	Yes	Yes	No
Work summaries	Yes	Yes	No	No
Cost warnings and cold resume guard	Yes	Yes	No	No

You connect each agent in Settings › Coding agents, and each feature has its own switch. Hooks and agent history over MCP are part of Developer Pro, which the free trial includes.

Why both

The two halves cover each other's gaps. A hook can add context before the first prompt, but it has to stay short, because whatever it adds is carried in every request after that. MCP can go deep, but only when the agent decides to look. So L2Cache uses hooks for the few lines every session needs, and gives the agent tools to fetch everything else on demand. A handoff ends by pointing the new session at get_session_summary and the old session's ID, so the deep detail is one call away.

Privacy and safety

Everything stays on your Mac. The MCP server reads a local snapshot that L2Cache keeps in ~/.l2cache. Nothing listens on a network port, and nothing is sent to L2Cache's servers.
No helper binary. The MCP server is a script run by macOS's own JavaScript interpreter (osascript), so there's nothing extra to install or approve.
Sensitive items are never available. Clips marked sensitive, such as passwords and API keys, and apps you've excluded are filtered out before the snapshot is written. Agents can't ask for them.
History is treated as reference, not instructions. Context L2Cache adds is labelled as earlier history, so the agent checks it against the code instead of following it blindly.
Hooks fail quietly. They have short time limits, and if anything goes wrong they get out of the way. A broken hook never blocks a prompt or prints L2Cache errors into your terminal.
You can turn it off. Switching off agent history in Settings removes the session history from the snapshot straight away.

The short version

MCP gives agents twelve read-only tools to look up your earlier sessions, fixes, decisions, clipboard, screenshots and files.
Hooks record what agents do and add a handoff, recent clips and missing facts at the moments that matter.
It all runs locally, and sensitive items are never shared.

Give your agents a memory

L2Cache connects your clipboard, screenshots and coding-agent history to Claude Code, Codex and more, all on your Mac.

Download L2Cache for Mac