A second brain AI for a team is a shared, writable store of decisions and conventions that your assistant can read and add to - and no built-in memory gives you that today. Claude memory, ChatGPT memory, and Cursor rules each keep context for one person or one file, but none lets Claude, ChatGPT, and Cursor read from and write to the same team knowledge. The Knowledge Base app on B77 fills that gap: a hosted shared memory any of those assistants can update.
- Built-in memory is personal. Claude and ChatGPT memory belong to one user account; owners can only switch it on or off, not share it.
- Projects are a shelf of files, not a living log. Claude reads uploaded documents but doesn't write new decisions back into them.
- Cursor rules are static context. They live in version-controlled files - reusable, but not a memory that grows on its own.
- The Knowledge Base app is one shared, writable memory. It works in Claude, ChatGPT, Cursor, and Claude Code and is free on B77 (version 1.0.0, checked 2026-09-05).
- Best practice is to combine them. Personal memory for your preferences, Projects for stable references, Knowledge Base for team decisions.
Why a second brain AI for a team is not a notes app
Every phone ships with a built-in notes app, and teams still install a shared one - because private jottings don't help the person sitting next to you. Claude works the same way. It ships with built-in memory, but that memory belongs to one person and one workspace. The Knowledge Base app on B77 is the shared, cross-assistant version: the notes app your whole team actually opens.
A second brain AI for a team is a store of decisions, conventions, and how-tos that the assistant can read and write - knowledge that survives the end of a chat and the departure of the person who wrote it. That's the difference from personal memory. Individual recall helps you; team knowledge compounds only when everyone's thinking lands in one place, month after month.
If you're a PM or team lead, you already feel the gap. Your real decisions live in Slack threads that scroll away and dead chats no one can find again. An AI tool that remembers privately doesn't fix that. What you need is one memory the whole team writes to and reads from - so the reasoning behind a call outlives the conversation that produced it.
Claude memory: what it does well and where it stops
Claude memory is the feature that lets Claude carry context between conversations instead of starting fresh each time. Here is how it works (checked 2026-09-05 against Anthropic's help center).
Memory is on by default for Free, Pro, and Max plans on the web, Claude Desktop, and Claude Mobile. On Team and Enterprise plans it is off by default, and an owner turns it on. As you chat, Claude saves memory as a set of individual topics; you can also say "remember this" to capture something directly. Each project has its own separate memory space and project summary, so context does not bleed between unrelated pieces of work.
You stay in control of what is stored. Everything Claude remembers is listed under Topics in Settings > Memory, where you can read, edit, or delete each one. Incognito chats are not saved to memory. Anthropic states that owners cannot view or edit a user's individual memories.
The direction of travel is toward one memory everywhere. Anthropic's blog post "Bringing memory to Claude" (2025-09-11) introduced memory for Team and Enterprise first, and a 2026-08-25 post, "Claude's memory works everywhere," says the same memory is used across web, desktop, mobile, and Claude Cowork.
Here is the honest limit for teams: memory belongs to one user account. Your teammate's Claude does not know what your Claude remembers. A decision you capture in your conversation stays with you - it is personal recall, not a shared team brain.
Claude Projects: shared files and instructions, not a living memory
If personal memory is per user, Projects are Claude's next step up - but they solve a different problem. Projects are Claude's self-contained workspaces - each one has its own chat history and its own knowledge base. You upload documents, text, or code to a project's knowledge, and you set project instructions that apply only to the chats inside that project. According to Anthropic's help center ("What are Projects", checked 2026-09-05), Projects are available on all plans, and free accounts can create up to five projects.
On paid plans, when project knowledge approaches the context limit - the amount of text the model can hold in a single conversation - Claude switches to a retrieval mode that Anthropic says expands capacity by up to 10x. On Team and Enterprise plans, a project can be shared with members of your organization using "Can view" or "Can edit" permissions.
That makes Claude Projects genuinely useful for briefs, style guides, and reference files that change rarely. Here is the trade-off. Projects hold what a human uploaded. In Projects as they work today, Claude reads project knowledge but does not automatically write the decisions from a conversation back into those files. Updating shared context still means someone editing a document and re-uploading it. Anthropic is also changing this: a redesigned Projects beta, announced 2026-09-17, is so far available only in Claude Code for select Pro and Max subscribers. There, the project's Library collects the files Claude produces alongside the files you add, and every thread adds to a shared project memory - still Claude-only and scoped to one project.
Project memory is also scoped per project and per user (see the memory section), so a decision made in one project does not surface in another. Outside that beta, Projects are a shelf of files, not a log that grows on its own.
ChatGPT memory and Cursor rules hit the same wall
This isn't only a Claude limitation. ChatGPT has its own version of the same feature. Per OpenAI's Memory FAQ (checked 2026-09-05), ChatGPT memory is tied to each individual account and is not shared between members of a ChatGPT Business workspace; a workspace owner can switch memory off for everyone. Shared projects use project-only memory, so a conversation inside a shared project cannot reference chats outside it. Useful for one person, but there is no team-wide store that everyone reads from and writes to.
Cursor takes a different route. Its docs (checked 2026-09-05) state plainly that language models do not retain memory between completions, and that rules provide persistent, reusable context instead. Project rules live in .cursor/rules as version-controlled files (or an AGENTS.md), and team rules can be managed from the dashboard on Team and Enterprise plans. That is static context, not a living memory. So every client gives you either a personal memory or a fixed rules file - none gives three assistants one shared, writable store. That is the gap the Model Context Protocol (MCP), the open standard that lets an assistant call external tools, is built to fill.
The Knowledge Base app: one shared memory for Claude, ChatGPT, and Cursor
B77's Knowledge Base app describes itself in one line: "A shared memory your assistant can read and write." It is an MCP server hosted by B77 at knowledge-base.b77.ai/mcp. Because it is hosted, it joins your Claude connectors, ChatGPT plugins, or Cursor MCP servers without installing anything locally, and the same connector shows up in claude.ai, Claude Desktop, and Claude Code. It works with Claude, ChatGPT, and Cursor, and on B77 it is free - no card, no trial clock (version 1.0.0, checked 2026-09-05).
Knowledge is grouped into projects and categories. The assistant creates, appends to, and updates documents, and search works by meaning rather than exact words, so "how do we log in users" finds an auth note that never used that phrase. It can ingest files (PDF, DOCX, PPTX, XLSX, HTML, Markdown, CSV) from a URL and cite the page a passage came from, and a verify-quote tool checks a quote against the stored text before you publish it.
The everyday workflow is three lines:
- You finish a conversation in Claude and say "save what we decided."
- A colleague in ChatGPT asks "what did we decide about the auth flow" and gets the note.
- The engineer's Cursor agent reads the same note before touching the code.
The point is that the assistant writes to it. This AI internal knowledge base grows from real conversations, not from someone's Sunday cleanup - so it keeps up with the work.
Comparison table: built-in memory vs Projects vs Knowledge Base app
Here is how the three options compare on the practical questions that matter for a shared team memory (all checked 2026-09-05).
| Built-in memory | Projects | Knowledge Base app | |
|---|---|---|---|
| Who can read it | One user | Project members on Team and Enterprise | Everyone invited to the project |
| Who writes it | The assistant, automatically, per user | A human uploads files and instructions | The assistant, on request, in any connected client |
| Shared across teammates | No | Yes, on Team and Enterprise plans | Yes, by email invite |
| Works in | Claude only | Claude only | Claude, ChatGPT, Cursor, and Claude Code |
| Survives a new chat | Yes | Yes, inside the project | Yes, everywhere |
| Search | Claude recalls topics itself | Claude reads uploaded files | Search by meaning across projects, plus file ingestion and quote verification |
| Edit and audit | Topic list in Settings | Edit the file and re-upload | Every call written to a usage log, entries removable any time |
| Price | Part of the plan | Part of the plan; free accounts get up to five projects | Free, no card |
These options are related rather than mutually exclusive, so the practical answer is usually to combine them. Keep personal memory switched on for your own preferences and working style, since it follows you and needs no maintenance. Use Projects for stable reference files that rarely change, like a style guide or a spec you want Claude to read every time. Put decisions and conventions - the things the whole team needs to agree on and recall - in the Knowledge Base, where any teammate can add to them and read them back from Claude, ChatGPT, or Cursor.
A decision log for PMs: three prompts to copy
A shared memory only earns its keep if you feed it and query it consistently. These three prompts turn ad hoc chats into durable AI note taking for teams: searchable, dated, and owned. Because they all hit the same store behind the Knowledge Base app, you can run them in Claude, ChatGPT, or Cursor - including Claude Code - and get the same result.
1. Save a decision - run at the end of any chat where something was decided:
Save this to the knowledge base under project [product name], category Decisions. Title: [one line]. Body: what we decided, the two options we rejected and why, who owns the follow-up, and today's date. Do not save anything we did not explicitly agree on.Use this to capture the outcome the moment it lands, before the context evaporates. The output is a single dated note with the decision, rejected options, and an owner - nothing invented.
2. Retrieve before a meeting:
Search the knowledge base for everything we have decided about [topic] in the last quarter. List each decision with its date and owner, flag any two that contradict each other, and quote the exact wording of the latest one.Use this ten minutes before a review, or before a Claude roadmap planning session, to walk in with the full history. The output is a dated, owner-tagged list with contradictions flagged and the current decision quoted verbatim.
3. Onboard a new teammate:
A new engineer joins the [product name] project on Monday. From the knowledge base, write a one-page briefing: the five most recent decisions, the conventions we follow, and the open questions marked as unresolved. Cite the note each item came from.Use this to give new joiners context instead of a folder of stale docs. The output is a cited briefing that points back to source notes.
Make Prompt 1 the habit. If you only adopt one, the discipline of capturing every agreed decision is what makes the other two worth running.
How to structure projects and categories, and who gets access
A shared memory only stays useful if it has a shape everyone understands. A few practical rules go a long way.
- One project per product or team, never one per person. The whole point is shared context; per-person projects just recreate the silos you were trying to escape.
- Group by kind of knowledge, not by date. Use categories like Decisions, Conventions, How-tos, Customer facts, and Open questions. Topics organized this way are easier to search than a timeline of files.
- One document per decision or convention. Give it a plain-language title the search can actually match - write "How we name feature flags," not "Meeting notes."
- Append when a decision evolves. Don't create a near-duplicate; add the new context to the related document so the reasoning stays in one place.
- Mark superseded entries as superseded rather than deleting them. The history stays readable, and the assistant can tell you what changed and why.
Sharing works from the app's Manage page on B77 (checked 2026-09-05): invite teammates by email, and they add the same Knowledge Base connection to their own assistant, using it under your access with no credentials to set up. Team apps also let you invite people per project. The invitee gets an email, and access activates once they sign in to B77 with that address, so you can invite everyone before anyone has an account. You can revoke a share at any time, and every call is written to the usage log.
Data stays in the EU (Frankfurt and Helsinki regions), and the app reads only the notes and searches you ask it to store or look up - never your other apps or files. This works the same for creators keeping a content playbook and for engineers keeping architecture notes.
Limits and honest trade-offs
The Knowledge Base app is only as useful as the habit behind it. It knows what an assistant or a person deliberately saved into it - nothing more. Unlike built-in memory, it does not capture decisions on its own as you chat. The fix is a standing instruction that tells the assistant when to save: add it to your Claude project instructions, your CLAUDE.md, or your Cursor rules so saving happens without anyone remembering to ask.
It also does not see your other apps, files, or Claude connectors unless you paste the content in or give it a file URL. And it is young - version 1.0.0 as of 2026-09-05 - so its features and behavior will change; check the app page for the current state before you build a workflow around any single feature.
Built-in memory is still the better tool for personal preferences like tone, format, and your role, because it is on by default and needs no special skills or prompts. Projects remain the better home for large, stable reference files. A shared store needs a curator too: prune outdated notes each sprint, or search will return three contradictory answers. And a human still reads the output before it becomes a ticket, a contract, or a customer promise.
FAQ
Is Claude's memory shared with my team?
No. Claude's memory belongs to an individual user account, not to your team. Team and Enterprise owners can only turn the feature on or off - they cannot view or read a user's memories (checked 2026-09-05). If you want a shared second brain that Claude can draw on, you need something that lives outside the personal memory store, like the Knowledge Base app connected as a shared MCP.
Does ChatGPT memory work across a Business workspace?
No. ChatGPT memories are tied to the individual account, so one person's saved context does not follow the rest of the workspace (checked 2026-09-05). A shared project uses project-only memory, which stays inside that project rather than becoming a team-wide memory. To give everyone the same recall, you need a memory that sits outside any single account.
Is there a free second brain AI for a team?
Yes. The Knowledge Base app on B77 is free to use - no card required - and it works with Claude, ChatGPT, and Cursor. Claude's built-in memory is also available on free accounts, but it is personal to each user, so it does not give a team one shared memory the way the Knowledge Base app does.
Does a shared memory work in Claude Code and Cursor, not just chat?
Yes. Like other Claude MCP connectors, the same hosted connection shows up across claude.ai, Claude Desktop, and Claude Code, and Cursor connects to it as an MCP server. That means a coding agent can read the decision log before it edits code - not just answer questions in chat. Your context follows you from conversation to Claude Code and into your editor.
Built-in memory is like the notes app that lives on one phone: handy for you, invisible to everyone else. A shared team memory is the app the whole team opens. So take the concrete next step: install the Knowledge Base app from B77, connect it to the assistant you already use - Claude, ChatGPT, or Cursor - and at the end of today's last meeting, run Prompt 1 to capture the first decision. Tomorrow, your teammates open the same memory and pick up where you left off. Browse hosted MCP servers and connect one to your assistant in a couple of clicks: the B77 marketplace.
