The problem nobody talks about
Anyone who uses an AI assistant daily knows this experience: after a productive session, when you open a new chat the assistant remembers nothing. Previous decisions, effective paths, mistakes to avoid, style preferences all vanish. The user becomes the only link of continuity, having to note what was decided and summarize the context at every new session.
Partial solutions exist: the memories built into consumer products let you save general information like the user's name or tone preferences, but they're limited in space and managed by the provider. They aren't enough for real software development or operational management projects.
In recent months a different approach has emerged: build an external memory that the model reads and updates as a work tool. The model stays general while the memory grows, specializes and persists as two separate layers evolving at different speeds.
What the Model Context Protocol is and why it changes the game
In November 2024 Anthropic released the Model Context Protocol (MCP), an open standard that lets an AI model communicate with structured external tools. Anyone can write an MCP server that exposes capabilities to Claude. Once connected, the assistant automatically picks up those capabilities transparently.
The difference with proprietary plugins is crucial: MCP is an open protocol, the user owns the server, data does not pass through third-party companies. The server runs wherever the user wants — on their computer, on a rented server, on a Raspberry Pi.
From an experience standpoint, hooking an MCP server up to Claude is as simple as adding an account. Once connected, Claude uses it when needed, with no explicit commands. It's like giving an assistant the keys to an archive: the assistant knows it exists and how to consult it.
What Timo is
Timo is an MCP server that works as structured persistent memory for the user. Technically it's a small software stack that runs as a dedicated instance, reserved for a single user. It exposes tools that let an MCP-compatible AI read, write, search and organize work notes.
Technically it combines a smart search engine with a traditional text index and a Git versioning system. The notes are Markdown files readable and editable outside the AI as well.
Timo lets you:
- write topic-based notes;
- ask the AI to read or update those notes;
- run smart searches across the entire archive;
- keep registers of decisions and rules;
- share the space between devices with Git sync.
The user owns the space, moves it wherever they want, backs it up however they prefer. No dependency on cloud providers.
The pattern in action: three actors, one shared memory
With a traditional AI assistant there are two actors: the user and the assistant. With Timo there are three: the user, the AI and the external memory.
In sophisticated flows, the AI splits into two roles: an architect the user talks to (high-level reasoning) and an executor that receives precise instructions and runs them (like Claude Code with access to terminal and file system).
Traditionally the two roles would communicate via a very long prompt. With a shared memory the flow changes radically: the architect writes a short prompt to the executor asking it to consult specific notes, run tasks and write reports into the memory. The executor accesses only the content needed at the right moment.
The user is no longer the carrier of context but becomes the architect of the knowledge, deciding what to memorize. The AI is an execution tool. The memory is the lasting shared substrate.
The qualitative leap: extended procedural memory
Cognitive psychology distinguishes between episodic memory (specific events tied to time and place) and procedural memory (how you do something).
Traditional AI assistants live on fragmented episodic memory. Timo builds procedural memory of the project: style rules, recurring mistakes to avoid, historical architectural decisions, known bugs and workarounds, domain glossary.
This knowledge, in traditional setups, would have to be repeated at every session or loaded via huge initial prompts. With Timo it's written once, lives in topic-based notes, gets read when needed.
Every new session starts already expert in the project, with no initial re-onboarding phase. The AI's context memory stays free for active reasoning on the current conversation.
Four concrete scenarios
The long-running software project. A solo developer on a complex application records code conventions, database schema, architectural decisions, historical mistakes and resolutions. The AI consults the appropriate memory, proposes consistent solutions, avoids past mistakes.
The writer with a distinct voice. An author saves tone guidelines, target audience, successful examples, stylistic mistakes to avoid, a glossary. The AI starts from the memory, applies the rules, keeps the voice consistent.
The professional with multiple clients. A consultant, lawyer, architect with memory structured per client allows targeted consultations without manually reloading files.
Daily operational management. A task list updatable by the AI, meeting register, incident log, follow-ups. The memory becomes the ideal procedural second brain for intellectual work.
Privacy and granular control
In a traditional AI assistant, everything in the chat passes through the provider's servers. With a dedicated MCP server like Timo, the space lives in the user's isolated instance. The AI accesses only the content in the exposed folders.
This enables granular control: public notes, work notes, private notes. Moving a file between folders is an ordinary file system action.
Since the AI model reads the content as an external tool without being trained on it, there's no risk that information ends up in someone else's training data.
Invariance with respect to the model
An underrated property is the separation between model and memory: they are technically independent entities.
The AI model evolves over time. When the user changes models — for a better one, different costs, a local model — the memory stays where it is.
The Timo space doesn't know or care which model reads its notes. It exposes the same standard MCP tools to Claude today, tomorrow, to other compatible models.
The memory is invariant with respect to the model: an investment not tied to a provider but a user-owned asset reusable with any compatible AI.
The pattern's limits: when it isn't needed
The pattern is not universal.
For one-off conversations — a recipe, summarizing an article, a translation — an AI without external persistent memory is perfectly adequate. The memory is infrastructure that only makes sense with projects that justify it.
For users who don't want to run a server, the DIY pattern isn't a fit: spinning up a dedicated instance, configuring a domain, managing backups are operations within reach of developers but not everyone. That's why Timo is also offered as a managed service.
For work requiring maximum confidentiality where no data should transit through external AI services, the cloud AI model remains an exposure even with private memory.
For casual, intermittent use, the cost-benefit doesn't add up.
The pattern shines with durable projects, users who tend to them, continuity that justifies the infrastructure.
Conclusion
The real qualitative leap in everyday use of artificial intelligence doesn't come from more powerful models, it comes from the architecture around the models.
The pattern of shared procedural memory, enabled by open standards like the Model Context Protocol and concrete implementations like Timo, is one of the most promising developments. It turns AI from an episodic assistant into an ongoing collaborator. It frees the user from the role of context carrier. It builds an asset of operational knowledge that grows and stays with the user, independent of the model's provider.
The daily experience changes sharply when you move from «every chat is an island» to «every chat is a chapter of a book written together». Once you've tried it, it's hard to go back.