Team AI memory: no more “what did we decide again?”

Illustration scenario. The team described is fictional, with no testimonial and no figures. Pryzm's team plan is in preparation: this article describes what it aims to do, not a product that is already available.

Take a five-person team building an app: two developers, a designer, a product person, a salesperson. Each uses the AI they prefer: Claude for one, ChatGPT for another, Cursor or Claude Code for code, Le Chat for writing.

Before: the decision exists, but nobody knows where

One decision is made on a video call, another in a chat thread, a third in a conversation between a developer and her AI assistant. Nobody lied, nobody was careless: the information is simply scattered.

Three weeks later someone asks: “what did we decide about pagination?”. You have to find the right thread or interrupt whoever remembers. Meanwhile, each person's AI suggests solutions that ignore what was settled, because it only knows its own user's conversations.

The cost isn't dramatic. It's diffuse: interruptions, debates reopened, a new hire who takes a long time to understand why things are the way they are.

After: a common memory every AI checks

Pryzm works the same way as for individuals: a semantic memory connected over MCP to any compatible AI. For a team, the difference is that a project's memory is shared between its members.

• Decisions are saved where they're made. In the conversation with the AI, at the moment the call is made, with the reason.
• Every AI finds them. Whether the question is asked in Claude, ChatGPT or Cursor, the answer starts from what the team decided.
• Conventions apply without reminders. Code style, naming, tone of copy, security rules: everyone's assistant knows them.
• Onboarding gets easier. A new member can ask their AI for a project's decision history instead of pulling in a colleague.

Search combines keywords and meaning, so a decision can be found even if it was phrased differently. The dashboard, organised by project, shows what was saved and lets you correct it.

Example requests

• “What did we decide for API pagination, and why?”
• “What are our naming conventions for components?”
• “Summarise the decisions made on the project this week.”
• “Save that we're dropping PDF export for v1, product team decision.”

What it doesn't replace

A team AI memory is not a project management tool, nor official documentation. Tickets, code and approved specs stay where they are. The memory does something else: it keeps the why behind choices, the unwritten conventions and the context that usually lives nowhere, and makes it available to every AI on the team at the moment it is needed.

It doesn't replace discussion either. If two people disagree, the AI won't settle it for them; it will simply recall what has been decided so far, and by whom. That alone often shortens the conversation, because everyone starts from the same facts instead of from their own recollection of a meeting held weeks ago.

Finally, it only knows what has been said to an AI connected to it. A decision made on a whiteboard and never mentioned again won't appear by magic. The habit to build is simple: when something is settled, say it to your assistant in one sentence.

What stays private

A team memory shouldn't absorb everything. A message that starts with ## is never saved: everyone can still think out loud with their AI without it turning into a “decision”.

Servers are in Germany and data is encrypted with AES-256-GCM. As for individual use, one limit to know: during a session, the server decrypts memories in memory so it can search them. It is not end-to-end encryption.

How it works, without jargon

MCP (Model Context Protocol) is an open protocol that lets an AI call external tools. Pryzm provides a few of them: search the memory, save a memory, get a project overview. You add a single URL to each assistant, sign in once with OAuth, and each tool gets its own token, which you can revoke at any time.

The “main memory” instructions do the rest: the AI checks Pryzm at the start of the conversation and before answering anything that depends on your context, then saves on its own what is worth keeping. You don't have to think about “saving”: you work, and the memory fills up.

Good team habits

• One decision, one sentence, one reason. “We're dropping X because Y” is more useful than long meeting notes.
• One project per product or client. Answers stay focused and searches more precise.
• Correct rather than pile up. When a decision changes, update the old one in the dashboard instead of adding a contradicting one.
• Keep secrets out. Passwords and API keys don't belong in a shared memory: use the team's password manager.

Where the team plan stands

It is in preparation. Today Pryzm offers individual accounts: free up to 100 memories, then Solo at €9.99/month. Details of the team plan (per-project sharing, member management, pricing) will be published on the business page. If your team is interested, that's the place to watch.

Getting started

In the meantime, anyone can already try shared memory across their own AIs and see what it changes:

1. Create a free account.
2. Add the connector URL to your tools: Claude, ChatGPT, Cursor, Le Chat, Perplexity, Claude Code or Gemini CLI.
3. Paste the “main memory” instructions so your AI checks Pryzm on its own and saves what matters.

The guide is on the connection page.