{"id":2228,"date":"2026-04-21T18:06:24","date_gmt":"2026-04-21T18:06:24","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/all-things-azure\/?p=2228"},"modified":"2026-04-21T19:57:11","modified_gmt":"2026-04-21T19:57:11","slug":"i-wasted-68-minutes-a-day-re-explaining-my-code-then-i-built-auto-memory","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/all-things-azure\/i-wasted-68-minutes-a-day-re-explaining-my-code-then-i-built-auto-memory\/","title":{"rendered":"I Wasted 68 Minutes a Day Re-Explaining My Code. Then I Built auto-memory."},"content":{"rendered":"

~1,900 lines of Python. Zero dependencies. Saves you an hour a day.<\/em><\/p>\n

GitHub \u2192<\/a><\/strong>\u00a0\u00b7\u00a0pip install auto-memory<\/code><\/p>\n

Now give Copilot CLI enhanced context recall. Point it at deploy\/install.md<\/code><\/a>\u00a0and let it cook. \ud83c\udf73<\/p>\n

Are you tired of using the slash \/compact command every 10 min?<\/strong><\/p>\n

\"auto-memory<\/a>
auto-memory-ai-coding-agent-unlimited-context-recall-layer<\/figcaption><\/figure><\/p>\n

The Context Window Is a Lie<\/h2>\n

Every AI coding agent ships with a big number on the box. 200K tokens. Sounds massive. You could fit an entire codebase in there, right?<\/p>\n

Here’s what actually happens when you start a session:<\/p>\n

200,000 tokens \u2014 your context window (on paper)<\/span>\n-65,000 tokens \u2014 MCP tools load at startup (~33%)<\/span>\n-10,000 tokens \u2014 instruction files (copilot-instructions.md, AGENTS.md)<\/code>(~5%)<\/span>\n=========<\/span>\n~125,000 tokens \u2014 what’s left before you’ve typed a word (63%)<\/span><\/p>\n

But here’s the part nobody talks about:\u00a0you don’t actually have 110K usable tokens.<\/strong>\u00a0That number is a ceiling, not a guarantee.<\/p>\n

Context Rot<\/h3>\n

LLMs don’t degrade gracefully. They hit a wall. Research and real-world usage both show the same pattern \u2014 once you cross roughly\u00a060% of the context window<\/strong>, the model starts losing coherence. It forgets things mentioned 30 turns ago. It contradicts its own earlier responses. It hallucinates file names it confidently stated five minutes earlier. It starts “drifting.”<\/p>\n

The industry calls this the “lost in the middle” problem. The model pays attention to the beginning (your instructions) and the end (recent turns), but everything in the middle \u2014 your actual working context \u2014 gets progressively fuzzier.<\/p>\n

So the real math looks more like this:<\/p>\n

But context rot kicks in at ~60% usage (120K tokens).<\/span>\nYou already burned 75K on overhead. That leaves:<\/span><\/p>\n

120,000 tokens \u2014 effective limit before quality degrades<\/span>\n-75,000 tokens \u2014 already consumed (MCP + instructions)<\/span>\n=========<\/span>\n~45,000 tokens \u2014 what you ACTUALLY have before the agent starts drifting<\/strong><\/span><\/p>\n

 <\/p>\n

Forthy five thousand tokens.<\/strong>\u00a0That’s maybe 30-40 turns of conversation before the model starts losing the plot. That’s why you’re hitting\u00a0\/compact<\/code>\u00a0every 45 minutes \u2014 not because you’ve filled 200K tokens, but because the model is already rotting at 120K.<\/p>\n

I was testing this with Copilot Claude Opus 4.7.\u00a0 \u00a0which consumes token faster on every turn i literally hit after 5-10 prompts going back and forth refining a plan.<\/p>\n

 <\/p>\n

Now start working. Every file read, every grep result, every agent response eats into that remaining window. After 20-30 turns of conversation, you’re staring at the dreaded compaction warning. You run\u00a0\/compact<\/code>. And then:<\/p>\n

“What were we working on?”<\/p><\/blockquote>\n

The agent has no idea. You’re back to zero.<\/p>\n

The Compaction Tax<\/h2>\n

Let’s talk about what\u00a0\/compact<\/code>\u00a0actually costs you. Not in tokens \u2014 in\u00a0momentum<\/em>.<\/p>\n

You’re deep in a debugging session. You’ve built up 30 minutes of shared context with the agent \u2014 it knows the file structure, the failing test, the three things you already tried, the hypothesis you’re currently testing. You’re in flow state. The agent is being\u00a0useful<\/em>.<\/p>\n

Then the context warning hits. You have two choices:<\/p>\n

    \n
  1. Ignore it<\/strong>\u00a0and watch the agent get progressively dumber as it loses the oldest context, starts hallucinating file names, forgets the test you fixed ten minutes ago.<\/li>\n
  2. Run\u00a0\/compact<\/code><\/strong>\u00a0and watch the agent lobotomize itself. Now it has a tidy 2-paragraph summary of a 30-minute investigation, and no memory of the details that actually matter.<\/li>\n<\/ol>\n

    Either way, you lose. Either way, you’re spending the next 5 minutes re-explaining things. Either way, the flow state is gone.<\/p>\n

    And this happens\u00a0every 20-30 turns.<\/strong>\u00a0That’s roughly every 45 minutes of active work. On a heavy coding day, you’re hitting\u00a0\/compact<\/code>\u00a0or\u00a0\/clear<\/code>\u00a0six, eight, ten times. Each one is a 5-minute interruption where you stop coding and start narrating your own project back to the agent like it’s a new hire on day one.<\/p>\n

    I timed it over a week.\u00a068 minutes per day<\/strong>\u00a0\u2014 just on re-orientation after compactions and new sessions. More than an hour. Every day. Doing nothing productive. Just\u2026 catching the agent up.<\/p>\n

    It’s not a minor annoyance. It’s a\u00a0tax on every session.<\/strong>\u00a0And it compounds \u2014 because after each compaction, the agent is slightly less effective, so you burn more tokens explaining things, which fills the context faster, which triggers compaction sooner. A death spiral of diminishing context.<\/p>\n

    The New Flow:<\/h2>\n

    Once you get near 50%-70% you hit \/clear<\/strong>. then prompt:\u00a0 review last sessions we discussed topic X<\/strong><\/p>\n

    The Amnesia Loop<\/h2>\n

    I tracked the specifics for a week. Every time I started a new session or hit\u00a0\/compact<\/code>, the same ritual played out:<\/p>\n

      \n
    1. Re-explain context<\/strong>\u00a0\u2014 “We’re working on the auth module, specifically the token refresh flow in\u00a0src\/auth\/refresh.py<\/code>\u2026” (5 minutes, ~2K tokens)<\/li>\n
    2. Agent does blind searches<\/strong>\u00a0\u2014\u00a0grep -r \"refresh\" src\/<\/code>\u00a0returns 500 results.\u00a0find . -name \"*.py\"<\/code>\u00a0returns 200 more. The agent reads half of them trying to figure out which ones matter. (~10K tokens burned)<\/li>\n
    3. Re-discover state<\/strong>\u00a0\u2014 “Oh, we had a failing test in\u00a0test_refresh_edge_cases.py<\/code>, what was the error again?” (another 5 minutes of archaeology)<\/li>\n<\/ol>\n

      Total cost:\u00a05-10 minutes and 12K+ tokens per re-orientation.<\/strong>\u00a0Multiply by 10 sessions a day. That’s\u00a050-100 minutes<\/strong>\u00a0wasted just telling the agent things it already knew five minutes ago.<\/p>\n

      The cruelest part?\u00a0The memory already exists.<\/strong>\u00a0Copilot CLI writes every session to a local SQLite database \u2014\u00a0~\/.copilot\/session-store.db<\/code>. Every file you touched, every conversation turn, every checkpoint. It’s all sitting right there on disk.<\/p>\n

      The agent just can’t read it.<\/p>\n

      The 200x ROI<\/h2>\n

      Here’s the cost comparison that made me build this:<\/p>\n\n\n\n\n\n\n\n\n
      Operation<\/th>\nTokens<\/th>\nWhat you get<\/th>\n<\/tr>\n<\/thead>\n
      grep -r \"auth\" src\/<\/code><\/td>\n~5,000\u201310,000<\/td>\n500 results, most irrelevant<\/td>\n<\/tr>\n
      find . -name \"*.py\"<\/code><\/td>\n~2,000<\/td>\nEvery Python file, no context<\/td>\n<\/tr>\n
      Agent re-orientation<\/td>\n~2,000<\/td>\nYou explaining what it should already know<\/td>\n<\/tr>\n
      auto-memory files --json --limit 10<\/code><\/strong><\/td>\n~50<\/strong><\/td>\nExactly the 10 files you touched yesterday<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      That’s not a typo.\u00a050 tokens vs 10,000.<\/strong>\u00a0A 200x improvement.<\/p>\n

      \u2b50\u00a0auto-memory on GitHub<\/a><\/strong>\u00a0\u2014 zero deps, read-only, installs in 30 seconds.<\/p><\/blockquote>\n

      One auto-memory call replaces an entire cycle of grep \u2192 read \u2192 grep again \u2192 oh wait wrong file \u2192 read another file. The agent gets surgical precision on the first try.<\/p>\n

      It’s Not a Memory System. It’s a Recall System.<\/h2>\n

      This is the key insight that made auto-memory simple.<\/p>\n

      I didn’t need to build a memory system. Copilot CLI already has one \u2014 it writes structured session data to SQLite after every conversation. Sessions, turns, files touched, checkpoints, summaries. The database is already there, already populated, already growing with every session you run.<\/p>\n

      What was missing was\u00a0recall<\/strong>\u00a0\u2014 a way for the agent to query that database cheaply and get exactly the context it needs.<\/p>\n

      auto-memory is a read-only query layer. It never writes to the session database. It can’t corrupt anything. It just reads what’s already there and returns it in a format the agent can consume in 50 tokens.<\/p>\n

      Unlimited Context From a Finite Window<\/h2>\n

      Here’s the mental model that makes this click:<\/p>\n