A developer at her laptop early in the morning, with a coffee cup and a blank open notebook beside it

Your AI agents start cold every session: what each morning costs

Problem7 min read

What it costs when an AI agent starts each session with no past: minutes, tokens and reopened decisions, with an illustrative sum and the market options.

by Equipo MemoryFirst

Table of contents
  1. The cold start, as a scene
  2. The daily cost, in an illustrative sum
  3. The costs that don't show up in the sum
  4. Why the usual patches fall short
  5. What it takes for the start to stop being cold
  6. How each option on the market solves it
  7. Sources

You open a fresh session with your coding agent and type: "Carry on with the Acme work." The agent answers politely, with a question: what is Acme, and what had we decided so far? You know the answer, but you explained it three days ago in another session, and that session no longer exists for the agent.

That isn't a model failure. It is the default: every session starts with an empty context window. We covered the technical reason in why your AI agents need a memory layer. Here we go after what that piece didn't: what the cold start costs a real team, every single day.

The cold start, as a scene

A typical working session has three phases. First you rebuild the context: which project this is, what was decided, what broke yesterday. Then you work. At the end, if you remember, you summarise what was done for next time.

The first and third phases produce nothing new. They are the toll for an agent that doesn't remember. And it is paid in every session, with every agent, by every person on the team.

A wall clock and a stack of identical blank sheets on a desk, a picture of time spent again and again

The daily cost, in an illustrative sum

Illustrative: these figures are round assumptions so the sum can be done, not a measurement. Swap each one for your own.

Suppose one person opens 5 sessions a day with an agent. In each one they spend 4 minutes re-explaining the context, and the agent re-reads or is handed about 12,000 tokens of material to catch up (files, pasted notes, summaries).

ItemPer sessionPer day (5 sessions)Per month (21 days)
Minutes re-explaining420420 (7 hours)
Tokens of rebuilt context12,00060,0001,260,000

For a team of five with the same pattern, that is about 35 hours a month and roughly 6.3 million tokens. Seven hours per person won't sink anyone, but it is seven hours of repeating what was already said, and the tokens cost the same even though the agent had already seen all of it before.

If your real pattern is half that, the cost is still there. If it is double, it starts to show in the bill and in the calendar.

The costs that don't show up in the sum

Minutes and tokens are the easy part to measure. The expensive part is usually something else.

  • Reopened decisions: the agent proposes again what was already ruled out, and someone has to remember why.
  • Different versions of the same story: if a colleague works with another agent or another tool, each one believes something different. Nobody knows which is current.
  • Knowledge trapped on one machine: an agent's local notes live on one laptop and in one tool. Change machines or AI client and you start from zero.
  • Distrust: when the agent doesn't remember, you learn to verify everything. That constant checking is work nobody sees.
Two colleagues at separate laptops looking puzzled, each holding a different version of the same story

Why the usual patches fall short

Most teams end up improvising one of three patches.

  1. Pasting a summary by hand at the start: it works for as long as someone maintains it, and goes stale as soon as anything changes.
  2. An instructions file or local notes: a good idea, and free. But it is per project and per machine, and someone has to write it and prune it.
  3. Huge context windows: stuffing everything in fits more and more, but costs more, takes longer and dilutes what matters. We expand on that in the article linked above.

The three share one thing: the memory depends on a person writing it and looking after it. When that person is busy, the memory goes stale exactly when it is needed most.

What it takes for the start to stop being cold

A start with memory needs five things:

  • It is persistent, and doesn't depend on a single session.
  • It is selective: a short, relevant briefing, not a dump.
  • It writes itself, from what already happens in the session, without asking for extra work.
  • It cites its origin, so you can check a fact before acting on it.
  • It is portable across tools, so you aren't tied to one agent.

This is how MemoryFirst does it for Claude Code, described as it actually works. When a session opens, a hook asks the API for a briefing on the project with a token budget (2,500 by default), mixing what is recent with what is important, and injects it as context. When the session closes, the transcript is sent to be indexed. If there is nothing to inject, it injects nothing. We don't promise the agent "knows everything": we promise a short, citable starting point that doesn't depend on you. The hook details are in plug memory into any agent and in memory for Claude Code and coding agents.

A developer working calmly in a bright office with a handwritten to-do list beside them

How each option on the market solves it

We summarise what their own public pages say. Where we couldn't check something, we say so.

  • Local agent notes and files: free and dependency-free, but per machine and per project, with manual curation. A good base, a poor team memory.
  • claude-mem (a code memory plugin): records what the agent does, compresses it with AI and injects it into later sessions. Data is stored locally and the licence is Apache 2.0. We could not verify what content its observer sends to a model provider.
  • Mem0: describes itself as "the memory layer for AI agents and applications", to be integrated over an SDK or API. It has a Free plan and a Custom one; graph memory is listed under Custom. More in MemoryFirst vs Mem0 and the comparison page.
  • Zep: describes itself as an enterprise context layer for agents. Plans are Free, Flex ($125/month), Flex Plus ($375/month) and Enterprise; the EU DPA is listed only under Enterprise. More in MemoryFirst vs Zep and the comparison page.
  • Letta: its pricing page talks about stateful agents and memory repositories, with Free and Pro ($20/month) plans. We could not verify how it describes itself. More in MemoryFirst vs Letta.
  • Supermemory: offers plugins for Claude Code and Cursor, with Free, Pro ($19/month), Max ($100/month) and Scale ($399/month) plans, plus a custom Enterprise tier. See the comparison page.
  • MemoryFirst: business memory with verifiable citations, reachable over MCP from Claude Code, Cursor or ChatGPT, with session hooks and data stored in the EU. Limitations: by default the answer is written by a US provider unless you bring your own key, and there is no self-hosted edition.

If you want a guide to deciding, start with how to choose a memory layer. And to see the problem from the team's side, read your company's knowledge is scattered.

Sources

Third-party data, accessed 2026-11-14:

  • Mem0, pricing: https://mem0.ai/pricing (accessed 2026-11-14)
  • Mem0, home page: https://mem0.ai/ (accessed 2026-11-14)
  • Zep, pricing: https://www.getzep.com/pricing (accessed 2026-11-14)
  • Zep, home page: https://www.getzep.com/ (accessed 2026-11-14)
  • Letta, pricing: https://docs.letta.com/letta-code/pricing (accessed 2026-11-14)
  • Supermemory, pricing: https://supermemory.ai/pricing (accessed 2026-11-14)
  • claude-mem: https://github.com/thedotmack/claude-mem (accessed 2026-11-14)

The figures in the daily sum are illustrative and do not come from any measurement.

Let your agent start where you left off

Try MCP memory with the Claude Code hooks for free: one project, 30-day retention.

Start free

Keep reading