AI Coding Agents Raised Billions but Still Forget Your Project Between Sessions

Cognition AI just raised $2 billion at a $48 billion valuation. The round was led by Andreessen Horowitz, Accel, Founders Fund, General Catalyst, and Avenir, nearly doubling the company's valuation from $26 billion just three months earlier. Reported run-rate revenue grew from $492 million in May to almost $900 million. Cognition makes Devin, the AI engineering agent, and the numbers say AI coding agents are the hottest category in tech right now.

Here is the paradox nobody at the funding announcement mentioned: open any of these tools on a Monday morning and it greets your project like a stranger. The most richly funded agents in history start every session from zero.

The question every developer asks

"Why does my AI coding agent forget everything between sessions?" "Do coding agents remember across sessions?"

If you have used Cursor, Claude Code, Devin, or any of the rest for real work, you already know the feeling. Friday afternoon the agent understood your architecture, your conventions, the workaround for that one fragile module. Monday morning it suggests the exact pattern you told it to avoid twice last week. The code it writes is good. Its memory is not.

Why it happens

The amnesia is architectural, not a bug anyone forgot to fix.

Models are stateless between sessions. A language model does not remember anything on its own. Every new session starts cold. Nothing carries over unless something carries it, and out of the box, nothing does.

Context windows fill up and rot. Developers call it context rot. Once a session's context window gets past roughly half full, the agent starts forgetting constraints, revisiting decisions it already made, and redoing work it already completed. The standard advice is to restart the session every so often. That works, but restarting wipes the slate, which is the original problem wearing a different hat.

Built-in continuity is lossy. Features like auto-compact and session resume compress the old session into a summary. Summaries drop exactly the details that matter most: why a decision was made, which approach already failed, what not to touch. A summary of a session is not a memory of it.

Memory is trapped inside each tool. Whatever Cursor remembers lives in Cursor. Whatever Claude Code keeps lives in its own files. Switch tools mid-project and you start over completely. Even Devin, the $48 billion agent, has users hand-rolling memory protocol files with sections for project state, preferences, decisions, and bug history just to keep continuity alive.

Git records what changed, not why. Your repository knows every line that was ever written. It does not know why the team chose one pattern over another, which workaround is load-bearing, or what the plan was for next quarter. The why lives in conversations, and conversations evaporate when the session ends.

Why the billions do not fix it

Follow the money and the picture gets clear. Funding chases capability: smarter models, longer autonomous runs, more tools, bigger demos. Memory is infrastructure. It is unglamorous, hard to demo, and every vendor builds it for its own app rather than for your workflow across apps. So the industry keeps shipping more powerful agents with the same amnesia, and developers keep paying the tax in re-explained context.

This is why the leaderboard for this problem is full of community-built workarounds instead of vendor solutions. GitHub is crowded with MCP memory servers, handoff markdown templates, and memory protocol skills that developers maintain by hand. They work, after a fashion. They are also manual, fragile, and per-tool, which means the maintenance burden grows with every agent you add.

What actually works

The setups that solve this all converge on the same pattern: external memory plus disciplined retrieval. Store state outside the prompt, in one place, then pull back only what matters for the current session. Decisions, conventions, bug history, preferences: the why behind the code, kept where every session can reach it.

MCP, the Model Context Protocol, is what makes this practical instead of theoretical. It is the standard plug that lets any compatible tool read from and write to the same memory layer. The memory stops belonging to the app and starts belonging to you.

The concrete version of that pattern

Vilix AI is a memory layer built on exactly this idea. It lives in the cloud, outside any single app, and connects to your tools over MCP. It auto-saves conversation turns, so project context, decisions, and preferences accumulate without manual note-taking. When you need something back, you ask in plain language and it retrieves the relevant context.

Because the memory is stored server-side on your account, the same memory follows you across Claude Code, Cursor, ChatGPT, and Claude, and across devices from your phone to your laptop. There is a free tier, and setup takes about 10 minutes per tool.

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

The $48 billion question

The $48 billion question was never whether AI can write code. It can, and the funding rounds prove the market believes it. The question is whether it can remember the project it is writing code for. Until memory becomes infrastructure instead of an afterthought, every session starts at zero, no matter how many billions back the agent.

The teams that fix this first will not be the ones with the smartest model. They will be the ones whose agent remembers what happened on Friday.