AI Coding Assistants Are Collectively Losing Their Memory. Someone Built a Cross-Tool Memory Layer, but Users Say a Single Markdown File Is Enough

Every AI coding tool you've used loses its memory the moment you close the window. Cursor forgets the migration plan you agreed on that morning; Claude Code forgets the debugging path that took two hours to figure out last week. Switch tools, and everything you discussed before is wasted.

An open-source project called Beacon wants to catch this. It spans more than 20 harnesses including Claude Code, Cursor, Codex, OpenCode, and more, captures the history of each session, and extracts useful workflows, corrections you've given, and debugging patterns into knowledge that future agents can call on. A pit one agent has fallen into doesn't need another to fall into from scratch.

What It Actually Does

At Beacon's core is a loop: run an agent, capture the session, evaluate which steps were useful, extract knowledge, have a human review and confirm it, then let future agents reuse it.

It captures things in fine detail: prompts, responses, tool calls, commands, file changes, approval records, MCP interactions, and token usage, all unified into an event model based on OpenTelemetry and stored locally as JSONL.

Local-first by default, written on the local machine, not sent out. If you want to forward to Beacon Cloud, Splunk, Datadog, S3, and other destinations, you need to explicitly click through a confirmation screen, which clearly states the account, destination, and capture mode. It also supports letting agents directly retrieve these memories through MCP or Agent Skills.

Installation on macOS is just a few commands:

brew update
brew trust asymptote-labs/tap
brew tap asymptote-labs/tap
brew install beacon
beacon endpoint install

After installation, use your agent as normal; it will keep recording in the background. To view the content, run beacon traces to open a local terminal browser where you can browse the event timeline, token consumption, and retained content. The project is MIT-licensed, with code at GitHub.

Some Aren't Buying It

The narrative sounds smooth, but a few replies hit hard.

One user said most of what's worth remembering is already sitting in the repo, and a CLAUDE.md plus git log is more reliable than a memory layer that quietly goes stale. Another put it more briefly: a markdown file in the repo solves most of the problem.

That's not unreasonable. The more memories there are, the more likely they are to go stale. A debugging path written down three months ago may today point to a function that no longer exists. An agent following it would be worse off than if it had amnesia.

Another doubt is more practical. One user warned that something that remembers all your sessions across more than 20 harnesses is itself a very fat target for leaks. Beacon responds to this with local-first and explicit forwarding, but for a tool that captures by default and stores all prompts and file changes, you need to understand the permission boundaries yourself.

There were voices of agreement too. One user mentioned having done something similar in a clumsier way before: giving each coding agent a skill that reads a local memory store, plus an MCP server for reading and writing. Others think the cross-harness aspect itself has value: after all, Cursor sessions can feed Codex, and Codex's can feed OpenCode; as you switch tools, knowledge doesn't have to migrate with them.

The tweet author summed it up: 'The tools are free; the business built on top of them hasn't been done yet.'

If anything, the hard part of memory isn't storing it; it's filtering it. Storing every session is easy. Judging which one is worth keeping and when to let it expire is the watershed for whether this layer is usable. Beacon leaves the review step to humans, which is a fairly honest design.