← Back to the blogMemory

Models Change. Memory Stays.

Coding assistants turn over every few months. What you know about your software, and why it works that way, has to stay with you, whatever the model.

September 2, 2026 · 4 min read

Why does your admin console log people out after 15 minutes of inactivity, while the customer app keeps them signed in for 30 days? Why do admin passwords expire every 90 days when customer passwords never do? Someone knew once. That person moved on, the ticket was closed, and the chat in which an agent was told “don’t touch the session timeout” ended when the window closed.

Where did the reasons go?

They went where most software knowledge goes. Into a chat history nobody rereads, a rules file for a tool you no longer use, a context window emptied at the end of a session. Sometimes nowhere at all.

Picture the next developer. The task is to make the admin console less annoying. They find a 15-minute timeout that looks arbitrary, an agent suggests raising it to eight hours, and the change sails through review, because nothing in the code says why 15 minutes was chosen. Maybe an audit required it. Maybe it was a guess. Nobody can tell anymore, and that uncertainty is the real problem.

Teams have always lost this kind of memory when people left or when the wiki got rebuilt. AI speeds the leak up. More changes, made faster, with the intent scattered across conversations.

Isn’t the model supposed to remember?

It isn’t, and it shouldn’t be the one keeping it. Models improve quickly, which is good news. The one you use today will be replaced, your vendor will change its terms or its pricing, and your engineers will want to try the next tool. Plenty of teams have already switched assistants more than once this year.

The model is a production tool. Your asset is what your software is supposed to do and why, meaning the rules, the journeys, the invariants, the decisions behind them, and where each one is implemented.

That asset will outlive several generations of tools. In an October 2025 study of 1,000 Global 2000 executives, Cognizant expects the share of IT budgets spent on legacy modernization to rise from 26% to 43% by 2030. Programs that size will see many models come and go.

ASSISTANTS COME AND GOTIMEYOUR INFRASTRUCTUREMCPThis year's assistantMCPThe next toolMCPA local LLMLYRIKS · PROJECT MEMORYRULEAdmin sessions expire after15 min of inactivitySCREENAdmin consoleSERVICEAuth serviceWHYReason recorded thenLINKED RULEPasswords, 90 dayssame rule, same links for every model · exportable in full
Assistants come and go over time. Each one receives the same session rule over MCP from the Lyriks project memory on your side, where the rule stays linked to its screen, its service, its reason and the password rule.

So where should it live?

Outside the model, on your own infrastructure, in a form you can query. That is the idea behind Lyriks.

It builds a single knowledge base on a graph database that brings together your code, Jira, Confluence, Notion, Figma and GitHub. Every element is linked to its source, and every rule points to the code that implements it. Because the engine is deterministic, the same question always gets the same answer.

For the session policy, that memory would hold the rule itself (admin sessions expire after 15 minutes of inactivity), the screens and services that enforce it, the change request that introduced it, the reason recorded at the time, and who approved it. When a developer or an agent proposes eight hours, the change is checked against that rule before it reaches review. The discussion then happens with the reason on the table, which is a very different discussion.

The same base catches disagreements. An illustrative case: the security policy on Confluence says passwords rotate every 90 days, a Jira ticket says rotation was dropped after a security review, and the code still forces it on the admin side only. No model can know which one is right. It is a decision, and Lyriks routes it to whoever owns the policy with the three sources side by side. Once settled, the rule is recorded with its reason, and every agent that works on authentication receives it from then on.

That structure is what separates this memory from a long instructions file. A rules file says “keep admin sessions short.” The memory says which sessions, how short, enforced where, decided when and for what reason, and it can tell you which other rules depend on it. The password rule and the session rule may well come from the same audit. Change one, and you probably need to look at the other.

What happens when we switch assistants?

Nothing happens to the memory. It is handed to the new model through MCP, with the rules and their sources, exactly as it was to the old one. The check on the code that model produces doesn’t change either, since it runs on a deterministic engine: same code, same spec, same verdict. Your team can try a new tool on Tuesday without losing anything on Wednesday.

And if you ever want to leave, the memory exports in full, traceability included. It belongs to you in the plainest sense.

RULES FILE"Keep admin sessionsshort."Which sessions? How short?Where? Since when? Why?PROJECT MEMORYWHICHAdmin sessionsHOW SHORT15 min of inactivityENFORCEDThe screens and servicesDECIDEDThe change requestWHYThe reason, recorded thenAPPROVEDWho approved itDEPENDSOther rules, e.g. passwordsan agent proposing 8 hours is checked against the rule
A rules file says keep admin sessions short; the project memory says which sessions, how short, where it is enforced, when and why it was decided, who approved it and what depends on it.

Who holds the keys?

You do. A memory this central can’t depend on somebody else’s service. The platform is open source under the AGPL license, installs with one command, and runs on premises or air-gapped with no outbound connections. You use your own LLM and your own tokens, local or sovereign if you prefer. The company and its intellectual property are French. The Security page has the details, and the Project memory use case shows what goes into it.

A sensible first step is a small one. Pick the policy whose reasons your team has already lost, the session timeout or any other, and record it properly while someone can still reconstruct why it exists.

Keep your software in tune

Start with one module. Lyriks recovers its spec, then verifies every change. All it needs is your repository.