Claude Sonnet 4.5's Memory Tools vs a Real Memory Layer: What's Actually Missing

Anthropic's Claude Sonnet 4.5 release made noise in developer circles: better reasoning, a native VS Code extension, checkpoints in Claude Code, and sessions that can run up to 30 hours without losing coherence. But the feature that got the most attention was memory. A new memory tool, now in beta, lets Claude store and retrieve information outside the context window.

That raises the obvious question, the one people keep searching for: does Claude Sonnet 4.5 remember across sessions now?

The honest answer is more interesting than a yes or no. Sonnet 4.5 gives developers real building blocks for memory, but there is a meaningful gap between what those tools do and what most people mean when they say "my AI should remember me."

What Sonnet 4.5 actually changed

The release introduced several memory and context features aimed mostly at developers building agents:

Memory tool (beta). An API tool that lets agents store and retrieve information outside the context window through a file-based system the developer controls. The documented use cases are building knowledge bases over time, maintaining project state across sessions, and preserving long-running project context through file-based storage.

Context editing. Automatic rules that clear older tool calls and results as the conversation approaches token limits. Instead of the session dying when the context fills up, the API prunes stale content and keeps going, which is what enables much longer agent sessions without manual intervention.

A new stop reason. Sonnet 4.5 adds a model_context_window_exceeded signal that explicitly tells your application when generation stopped because the context window filled up, rather than because of a token cap. Small detail, big reliability win for anyone building on the API.

Longer autonomous sessions. Sessions of up to 30 hours, a large jump from the roughly seven hours of the previous generation, mean agents can run very long tasks with less babysitting.

Claude Code checkpoints. Snapshot progress and roll back to a previous state, making long coding sessions safer to run.

That is a genuinely strong release. But now the important part: understanding what the memory tool is and is not.

What the memory tool really is

The memory tool is best understood as a structured notepad that the model can read from and write to during its work, with the files stored in a system the developer sets up and controls. It is an API feature, currently in beta, designed for people building agents on top of Claude.

Before 4.5, an agent's memory was whatever fit in the prompt plus whatever the developer hand-rolled with files or a database. Now Anthropic provides a standardized way for the model itself to save notes, update them, and read them back later, across sessions of that agent.

That solves a real problem for agent builders. It does not solve the problem most end users have in mind when they ask "does Claude remember me."

Where the memory tool stops: four honest limits

1. It is per agent, per app. The memory tool stores information inside the specific application or agent that implements it. Nothing about it crosses over to your other tools. What Claude Code's agent remembers has no path to your ChatGPT conversations, your Cursor sessions, or anything else. Each app gets its own island of memory.

2. Someone has to build the memory system. The tool gives the model read and write access to files. Turning that into an actual memory system, deciding what gets saved, how it is organized, how stale memories get cleaned up, how it stays useful over months, is still the developer's job. It is infrastructure, not a finished product. For end users who just want their AI to remember them, there is nothing to turn on.

3. It remembers the work, not the person. The memory tool is designed around project state and task context: where the agent left off, what it already tried, what the codebase looks like. That is valuable. But it is not a memory of you. Your preferences, your past decisions, the context from a conversation you had on your phone last month, none of that is captured unless a developer explicitly builds that pipeline.

4. It lives inside Anthropic's world. The memory exists within the ecosystem of the app built on Claude. It does not follow you to other providers, other devices, or other contexts. If you switch tools, the memory stays behind.

None of this is a criticism of the release. These are developer primitives, and they are good ones. But they address a different problem than the one most people feel day to day: starting over with every app, every device, every new conversation.

What a real memory layer looks like

Compare the memory tool with the idea of a memory layer: persistent memory that belongs to the user, not to any single app.

In that model, memory lives in the cloud, outside every application, and connects to your tools over MCP, the standard plug that lets AI apps talk to outside services. Important turns get saved automatically as you talk. Start a new session in any connected tool and the relevant context is pulled back in. You ask in plain language, and the memory finds what matters.

The practical differences are concrete:

• Cross-app. The same memory serves Claude Code, Cursor, ChatGPT, and Claude. A decision made in one shows up as context in another.
• Cross-device. Because the memory lives server-side under your account, context follows you from phone to laptop without any syncing on your part.
• Automatic capture. You do not maintain files, write summaries, or decide what to save. Turns are saved as they happen.
• Plain-language retrieval. You do not query a database or grep through markdown. You ask, and the relevant past context comes back.

This is a different category from a per-agent memory tool. One is a better notepad for a single agent. The other is a memory that belongs to the person and travels with them.

The bottom line

Sonnet 4.5's memory features are genuinely good news for developers building long-running agents. The memory tool, context editing, and longer sessions solve real problems around keeping agents coherent over hours of work.

But if your question is "will my AI finally remember me across everything I use," the answer is still no. The memory tool gives each agent a better memory inside its own walls. It does not give you one memory across all your tools, and it does not capture your context automatically as you live your digital life.

That gap is exactly where a dedicated memory layer fits. If you want memory that lives outside any single app, follows you across Claude Code, Cursor, ChatGPT, and Claude, works the same on your phone and your laptop, and saves your turns without you maintaining anything by hand, that is what Vilix AI is built for. It connects to your tools over MCP, auto-saves conversation turns, and retrieves relevant context when you ask in plain language. There is a free tier, and setup takes about ten minutes per tool.

https://vilix.ai?utm_source=devto&utm_medium=article&utm_campaign=sonnet-45-memory

Sonnet 4.5 moved the industry forward on agent memory. The next step is memory that belongs to you, not to your apps.