Have you ever given an AI assistant a new instruction, only to watch it follow an old rule you gave it weeks ago instead?
When we built CommandLyne's memory, we made one promise to ourselves: never lose a note. Every preference you told the assistant was written into a single readable notebook, and every new note was added to the end after each chat. Nothing was ever thrown away.
That promise served us well, until power users scaled past thousands of chats and the notebook started working against them. Here is what broke, and what we changed.
1. The newest note was the one nobody read
Imagine a notebook where every new rule goes on the last page. Anyone reading from page one sees your oldest thinking first, and the quick-read window only ever covers the top of the file.
That is what happened at scale. Slightly reworded daily summaries stacked up at the bottom, while the reading window stayed fixed at the top. In one reported case, today's update sat below line 2,300 and never made it into the window at all.
OLD FLOW (oldest notes first)
Top of file Month-old note: budget is $50 a week <- read first
Middle Reworded daily summaries, appended again and again
Line 2,300 Today's update <- never reached
What we changed. Memory is now injected newest-first, and repeated topics are replaced in place instead of appended. Your latest rule sits at the top, where it is read first.
NEW FLOW (newest notes first)
Top of file Latest rule: budget is $60 to $300 a week <- read first
Next Daily summary, consolidated once
Below Older history, archived and trimmed when full
2. The notebook remembered numbers it should have forgotten
Remembering is usually the right instinct. With prices, it is the wrong one.
The background summarizer treated any number mentioned in chat as worth keeping, so past prices and changing metrics were saved as permanent facts alongside your real preferences. Later, when someone asked what the price was right now, the assistant answered from the saved note instead of checking. Zero tool calls, stale answer.
What we changed. The memory extractor now keeps only durable rules and preferences, and drops prices and metrics that expire. Cached dynamic values are replaced with live-compute placeholders so the model works the number out fresh. A live-data guard makes real-time price and status questions trigger a new tool call every time.
| What you tell the assistant | Where it belongs | What happens now |
|---|---|---|
| "Always reply in short bullet points" | Durable preference | Saved to memory, read first |
| "Our main domain is example.com" | Durable preference | Saved to memory, read first |
| "What is the price right now?" | Live query | Fresh tool call, never answered from a note |
| "Is the service up right now?" | Live query | Fresh tool call, never answered from a note |
| Counters and task totals | Structured storage | Kept in state.json or SQLite, not in prose |
3. The same note, five times
To avoid losing anything, our old merger only skipped lines that were 100% word-for-word identical. A tiny rewording counted as new information, so near-identical daily summaries piled up under the same date.
What we changed. Updates are now deduplicated by topic and session, then consolidated into one clean entry per day. If you say the same thing three ways, you get one note.
4. Numbers and prose in the same file
Quantitative counters and qualitative notes both lived in the same memory file. That mixing is what let conversational numbers leak into your permanent preferences in the first place.
What we changed. We drew a hard line. Exact state and counters live in structured storage, and the memory file stays purely narrative.
5. What this means day to day
- Your newest instruction wins. It is read first, so you never repeat yourself.
- Live questions get live answers. Prices, statuses and quotas are fetched, not recalled.
- Memory stays clean. Repeated notes are merged, and old history is archived instead of piling up.
What we deliberately kept
Not every report we looked at needed a code change. Some behaviours are deliberate architecture, and they stayed exactly as they were. Standalone scripts in /usr/local/bin are command-line tools rather than MCP servers, and sub-agents run in isolated contexts by design so each one sees only what is handed to it. Both are working as intended.
The full breakdown of all ten reported items, with an accuracy verdict and fix status for each, is in the release notes.
Try CommandLyne and see the upgraded memory engine for yourself, or book a demo with our team.
Try CommandLyne (opens in a new tab) | Book a demo (opens in a new tab)

