Shared Cognitive Memory — management pitch
Narration script (also stored in each slide's speaker notes)
Proposal of October 2026, updated 13 October 2026 (connector and spaces slides added): Phase 1 (stages 1a-1t) is built and tested on a pilot server. About 18 minutes at a normal speaking pace.

Slide 1 — The big idea  (~59 s)
Good morning. Today I want to share one idea, and I want to start with the big picture. Our teams already use artificial intelligence every day. But every time a chat ends, what the AI learned is lost. The idea is simple: build one shared memory layer for the whole company. It holds what our organization, our projects, our teams, our AI agents and each person know, and it lets that knowledge flow safely between them. Every AI model our teams already use could read from it and add to it. That makes this the first step to automating all of our projects, while saving a great deal of computing cost and time. Since this proposal was first written, Phase One has been built and tested on a pilot server. At the end I will ask for a decision on a small, measured pilot with a real team.

Slide 2 — The first step to automating all our projects  (~44 s)
Why does memory matter so much? Because every project we run follows the same chain. The organization sets the rules. Each project inherits those rules and adds its own context. Each team applies them in its own way. Each AI agent carries out tasks using what it has learned. And each person adds their own preferences. Today, every link in that chain needs a human to explain things again and hand work over by hand. Once memory flows through all six levels, the chain can run with far less human effort. We would not be automating one workflow. We would be building the base that every future automation stands on.

Slide 3 — Where the cost savings come from  (~42 s)
Where do the savings come from? Three places. First, computing. Instead of pasting long histories into every request, the system finds only the few memories that matter, so each request uses fewer tokens and costs less. Second, time. People and agents inherit the context they need, so nobody has to explain the same thing again. Third, rework. When one team learns a lesson, every team benefits, so the same mistake is not repeated across projects. Think of it as compound interest for AI. The first project saves a little. The tenth project saves far more, because it starts with everything the first nine learned.

Slide 4 — Why memory is the foundation for automation  (~30 s)
Every kind of automation needs something from memory. Workflow automation needs to know the organization's rules and the project's context. Task automation needs the team's conventions and past decisions. Agents that work on their own need to know what worked before and what failed. And personal assistance needs each person's preferences and history. Without a memory layer, every automation project starts from zero. With it, every automation project starts with everything we already know.

Slide 5 — One memory layer. Every AI model our teams already use.  (~35 s)
The second big point is model freedom. The memory layer sits between our AI models and our company's knowledge. It does not belong to any single AI vendor. Any model can connect to it through an open, standard protocol called the Model Context Protocol, which the major AI tools already support. Our teams keep using the model they prefer. Claude for one job, GPT for another, a local model for sensitive data. The memory stays the same underneath all of them, and it stays on our own systems.

Slide 6 — Why model freedom matters  (~38 s)
Here is why that matters. No vendor lock-in: the memory belongs to us, not to any AI company. The best model for each task: we can mix commercial and local models on the same memory. Easy switching: when a better model arrives, we swap it in and nothing is lost. Our data stays ours, on our own systems, under our own rules. Lower total cost: with the right context, cheaper models can do more of the work. And it is future-proof: new models arrive every few months, and they can all plug into the same memory.

Slide 7 — The uncomfortable truth  (~36 s)
Now let me step back to the problem we are solving. We have already invested in AI, and our teams use it every day. Yet most of that intelligence disappears when a session ends. The AI forgets what it learned. The next session starts from zero. The next team member repeats the same onboarding. The next agent makes the same mistake. We are paying for intelligence and getting amnesia. The real question is not whether our teams use AI. It is whether our organization is getting smarter because of it.

Slide 8 — What we are actually losing today  (~39 s)
Here is what that costs us. Each AI session starts cold, which wastes tokens and time on repeated context. Knowledge stays with individuals, so when people leave, what they knew leaves with them. Agents cannot coordinate, so we get duplicate work and inconsistent answers. There is no record of what the AI knew when it acted, which is a compliance risk. And personal and team information gets mixed, which is a privacy risk. This is not a technology problem. Our AI models are capable. It is a value leakage problem, and the missing piece is the infrastructure underneath.

Slide 9 — Six memory scopes, one governed flow  (~36 s)
So what exactly are we proposing? Memory organized into six scopes. Organizational memory holds company policies and standards. Project memory holds requirements and decisions shared across teams. Team memory holds a team's conventions and workflows. Agent memory holds what an AI agent or bot learned about doing its job. User memory holds one person's preferences across all the AI tools they use. And personal memory is private. Only that person sees it, and it is never shared upward. Each scope has clear rules about who can read and who can write.

Slide 10 — The real innovation: memory that flows  (~41 s)
Most AI tools already have some memory. What they lack is a governed flow between these scopes. We propose three directions of flow. Upward, promotion: a useful insight moves up, but only after it is made anonymous and a team lead approves it. Downward, inheritance: company and project rules automatically shape what every team and every agent sees, so a new member gets the right context on day one. Sideways, synthesis: lessons from several teams are combined into project knowledge, and patterns appear that no single team could see. That flow is the difference between an AI tool and an AI-powered organization.

Slide 11 — How a single insight would travel  (~47 s)
Here is an example of how one insight would travel. A developer, Alice, prefers a careful deployment style. That note sits in her personal memory, private to her. Her coding agent notices that this style succeeded nine times out of ten, and records that in its agent memory. Her user profile now says she prefers careful rollouts, so every AI tool she uses respects it. Three teammates discover the same pattern. The system proposes it to the team, the team lead approves it, and Alice's name is removed. The project adopts it across three teams. After it proves itself in several projects, it becomes a company standard that new hires and new agents inherit on day one.

Slide 12 — Safety and control, designed in from day one  (~49 s)
Shared memory only works if people trust it, so safety would be designed in from the start, not added later. Personal memory is never shared upward. Nothing becomes team or company knowledge without a person approving it. What we know about one client is walled off from every other client. Every read, write and approval is recorded, so we can show exactly what the AI knew and when. People sign in with company accounts, and administrators also use a one-time code. Sensitive company data is processed only by AI models running on our own servers, never sent to a cloud AI service. And connecting an outside system, such as Jira, a database or a mailbox, needs a second person to approve it. And because the AI reads company sources through this one layer, personal mail and file connectors can stay switched off.

Slide 13 — One layer between our AI tools and our knowledge  (~46 s)
Here is how it would work, in simple terms. On the left are the ways people and AI tools would use the memory: AI assistants like Claude, GPT or Copilot connect through the open standard. Our own scripts and automations connect through a normal web interface. And people use a simple web console. In the middle is the memory layer. Every request passes a permission check first. Then it searches the right scopes, applies the rules, and writes an audit record. On the right are the sources it can learn from, such as Jira, company databases and mailboxes, each connected only after approval. Everything is stored on our own systems, built from proven open-source parts.

Slide 14 — The right memory loads wherever a person works  (~56 s)
People do not work in one place. Alice has the company repository cloned on two computers, her own tools repository, a drive folder of notes and a chat project, and she uses a coding assistant, a chat app on her phone and a review bot. The memory layer keeps a map of these spaces. The company declares its own spaces and rules, and her tools report hers; nothing is guessed. Her clone is recognised as the company repository, and her other spaces are linked to the Shipping project, with the evidence for each link and her confirmation for anything only suggested. So whichever AI app she opens, it loads the Shipping memory and nothing she is not allowed to see. Her scratch folder has no link, so it stays private. This part is built and in testing on our pilot server.

Slide 15 — One governed memory instead of many connectors  (~48 s)
Here is a question we will be asked: why not just switch on the mail, drive and calendar connectors that AI tools already offer? Because each one hands raw company data to the AI with none of our rules: no scopes, no client walls, no approval and no record of what the AI read. When the approved memory and a raw email disagree, the AI cannot tell which one is true. Connectors also cost working memory. In a measured test, six idle connectors added more than three thousand tokens to every request, and loading one mail connector's tools added over twenty-three thousand more. And a single agent holding private data, untrusted inbound mail and a send button is exactly the pattern security researchers warn about. The memory layer reads our sources on our own servers, asks a person before anything becomes shared, and gives the AI one budgeted, labelled context. In a simulation for a team of twenty, switching other connectors off cut tokens by two thirds.

Slide 16 — What management would actually get  (~38 s)
So what would management actually get? Six outcomes. One, compounding productivity: every interaction makes the system smarter, and new people and new agents get up to speed faster. Two, lower token and computing cost, because each request carries only what is relevant, instead of every connector's tools and raw results. Three, compliance readiness: we can reconstruct exactly what the AI knew when it acted. Four, governed AI behavior: personal stays personal, team knowledge stays in the team, and clients see only what they should. Five, model freedom. And six, a competitive advantage built from our own institutional memory, which no competitor can copy overnight.

Slide 17 — Why now  (~38 s)
Why now? Three forces are coming together. First, AI is already inside our organization. People use it whether or not it is managed, so the question is whether that use adds up or is wasted. Second, regulation is tightening. The EU AI Act, data protection enforcement and industry rules are moving from guidance to enforcement. Third, the technology is ready. Open standards now let any AI model connect to the same memory, and the storage and security building blocks are mature. The window to move early is open. It will not stay open for long.

Slide 18 — Is this a real need? The market says yes  (~53 s)
Is this a real need, or just our idea? The market answered that this year. In 2026 every major AI vendor added memory to its agents. Anthropic launched memory for Claude agents in April, and OpenAI, Google and Microsoft followed. Industry analysts now describe shared memory as the next competitive battleground for enterprise AI, and expect it to become a standard requirement in corporate tenders. Early results are strong. Rakuten reports that its agents make far fewer first-pass errors at lower cost once they remember earlier mistakes. Those are the vendor's numbers, not ours, and our pilot would measure our own. It is not for every company. It matters most where many people and AI tools work on shared projects, where clients must be kept apart, and where rules and audits matter.

Slide 19 — What exists today — and the gap we would fill  (~66 s)
What already exists? Four groups of products. First, developer memory kits such as Mem0, Zep and Letta. They store memories for one app, but have no company governance. Second, memory built into one AI vendor, such as Claude, Microsoft Copilot or ChatGPT. Easy to switch on, but the memory stays with that vendor and mostly in its cloud. Third, company search such as Glean or Atlassian Rovo. It finds what is already written, but does not learn new knowledge from AI work. Fourth, governed context layers such as Writer's Enterprise Brain or Tabnine. These are the closest, but they focus on marketing content or on code. The gap is a memory that works with any model, moves knowledge between people, teams, projects and the company with approval, keeps clients apart, and runs on our own servers. That is our position. The big vendors will bundle memory for free, so our edge must be independence and governance, and the window is probably twelve to eighteen months.

Slide 20 — The cost of waiting  (~31 s)
And if we do nothing? Our AI spending keeps delivering value one session at a time, not for the organization. Our teams keep solving the same problems separately. Our compliance position gets harder to defend. Competitors who build shared memory will onboard faster, serve customers better and run cheaper. And every new AI model becomes one more silo instead of one more contributor. The cost of waiting is not zero. It is the advantage we are not building.

Slide 21 — A phased build with a go / no-go gate at every step  (~69 s)
Here is what we propose: a phased build, with a go or no-go decision at every step. We start with a short design step to agree the rules with a governance partner. Then Phase One builds the memory layer for our own company, in stages. First personal, user and team memory with a pilot team. Then project memory and search. Then agent memory and our first connector, Jira. Then client walls, the approval process for promoting knowledge, and the web console. Only after that proves itself would Phase Two harden security and compliance and turn it into a product for other companies. At each gate we measure the results and decide whether to continue. Where we are today: Phase One is built, stages 1a to 1t, and tested on a pilot server. The later stages added automatic saving from AI apps, a register of the spaces people work in, organizational memory and digital workers. Next, the system moves to its own hardware, a server with a graphics card for the local AI model.

Slide 22 — Three ways other companies could run it (Phase 2)  (~38 s)
Looking further ahead, once it works for us, there are three ways other companies could use it. Option A, we host it as a service. It is the simplest for customers, but their data sits with us, which some will not accept. Option B, we run it inside the customer's own cloud account. Their data never leaves their environment, and we still operate it. We recommend starting here. Option C, the customer runs it themselves on their own servers, for the strictest environments. The same product supports all three. We only need to choose the order.

Slide 23 — What success would look like  (~36 s)
How will we know it worked? By the end of Phase One, the pilot team should be able to say things like: Our AI remembers our project context without us explaining it again. New team members get up to speed in days, not weeks. We have not repeated the same mistake twice. We can see exactly what the AI knew and when. We switched models, and nothing was lost. And we will back those statements with numbers: onboarding time, repeated questions, tokens used per task, and how people rate the answers.

Slide 24 — What we are asking for today  (~41 s)
So here is what we are asking for. First, an executive sponsor who treats memory as a core part of our AI infrastructure, not a feature of one tool. Second, a pilot team willing to be the first to work with shared memory across several AI models. Third, a governance partner from legal, compliance or security to set the access and retention rules from day one. And fourth, a budget for the phased build, with a go or no-go gate at every milestone. We are not asking for a leap of faith. We are asking for a structured experiment with measurable results.

Slide 25 — The big idea  (~40 s)
To close. We have already decided that AI matters. We have the models, the teams and the use cases. What we do not yet have is the layer that turns individual AI use into organizational intelligence, a layer that works with every model we use today and every model that arrives tomorrow. Memory is not a feature. It is the foundation. Organizations that build it will learn faster, automate faster and switch models freely without losing what they know. That is the opportunity, and that is what we are asking to build. Thank you. I am happy to take questions.

Slide 26 — One-page leave-behind  (~44 s)
This last page is a one-page summary to leave behind. The problem: AI forgets everything between sessions, so our organization does not learn from its own AI use. The solution: a shared memory layer with six scopes and three directions of flow, governed by clear access rules. It works with any model through an open standard. The payoff: the first step to automating all our projects, with one governed feed from our sources instead of everyone's own connectors. The path: a phased build with proof points at every stage. The ask: a sponsor, a pilot team, a governance partner and a phased budget. And the risk of waiting: competitors will build this, and we will pay for the same lessons twice.

Total: 2733 words, about 18 minutes at 150 words per minute.