On 22 September, Pellwick lost a group of four physio clinics at the end of its trial. The group's procurement team had asked for the data-processing agreement and the hosting page on day 12 of a 21-day trial, and its review took longer than the trial had left. That morning Tom, who sells to clinic groups, went over the loss in ChatGPT.
The reason the deal was lost is in one ChatGPT chat. The next morning Lena, in customer success, prepares the onboarding call of a 3-site vet group in claude.ai, and Kofi, who runs marketing, rewrites the site's FAQ with Codex. Neither session knows what Tom's chat learned unless someone carries it across. So the question is where a lesson should live for the next agent, in another tool, to start with it.
Mana is one knowledge store that every connected agent reads at the start of a session and writes to during the work, in Claude Code, Codex, OpenCode, claude.ai and ChatGPT. Working with it comes down to three habits: connect each tool once, let the agent store a lesson while the work is fresh, and ask the store before asking a colleague. This article follows Tom's lesson through each of them.
Each agent starts with what its own files give it
Agents already have ways to begin a session with context. Claude Code reads its CLAUDE.md files at the start of every session, including a project file that the team shares through version control (Claude Code documentation). Codex, Cursor and others read AGENTS.md, which its authors call a README for agents (agents.md). Claude Code also keeps an auto memory that Claude writes itself, and that memory stays on the machine that wrote it.
These files work. A folder of instruction files in Git is simple and reviewed like code, and for one repository and one agent it may be all a team needs. Two limits appear when the team spreads across tools. A file belongs to one repository or one machine, and Tom sells from a chat with no repository behind it, so the procurement lesson lands in a file only if someone writes it there. And the file grows: Anthropic suggests keeping CLAUDE.md under 200 lines, because longer files reduce how well the agent follows them.
A knowledge base reached through a connector has a different shape. Atlassian and Notion both run MCP servers that let an agent read the pages its user may already see (Atlassian, Notion). An agent reads such a page when it searches for one, and a page about procurement exists only if a person wrote it after the lost deal.
Mana sits beside both. It holds short, keyed statements that agents write during the work, each with its author and its readers, and it hands the team's standing rules to every connected agent before its first step.
Connect each tool once
How you connect depends on where the agent runs.
In Claude Code, the Mana plugin takes two commands in a session, /plugin marketplace add and /plugin install, then one sign-in through /mcp. The plugin connects the server, gives the agent the storing rules at the start of each session, and installs the Mana skills. You paste no prompt, and the agent writes nothing into your instruction files. An admin can require the plugin for every member through Claude Code's managed settings.
In Codex, OpenCode or another MCP client on your machine, an mcp add command adds the server and opens the browser for the sign-in. Codex takes a second command, codex mcp login mana. Then you paste a two-line prompt that tells the agent to call mana_standing_instructions and follow what it returns. Claude Code without the plugin works the same way.
In claude.ai and ChatGPT, nothing inside a browser chat can add a server, so the connector is added in the product's settings. On a team plan, an owner or an admin adds Mana once for everyone, and each member only connects. On a personal paid plan, you add the connector yourself, and ChatGPT asks for developer mode first. Then you sign in once and paste the same two-line prompt. claude.ai needs one step before the paste: the Mana rules go in Instructions for Claude, or an owner puts them in Organization instructions, because those are what every chat reads.
Three ways in. The guide for each client has the exact commands.
Every path reaches the same store as the same person. Ines in Claude Code and Ines in claude.ai read exactly what Ines may read. Mana records the acting agent with each write, and access follows the person who signed in.
Before anything is stored, the dashboard opens on the same choice: import the notes you already keep, or pick your agent and follow the steps of its guide.
Connect an agent, in the invented Pellwick organization, with the Claude Code steps open.
The team's rules arrive before the first step
When a session starts, the agent calls mana_standing_instructions. What comes back is the part of the store meant for every agent: the operating rules, the highlight/ record that says what the store holds and how to ask it, the glossary under learning/glossary, the settings under config/, one line for each skill the store lists, and the usage meter. It holds only what this person may read. The text has a size limit, and when a record is left out for size, the instructions name it, so the agent can still read it by its key.
The standing instructions arrive before the first step. The examples on the right are Pellwick's keys.
At Pellwick, Maya's Claude Code session begins with the discount rule (how far sales may go before Ines decides), the trial terms, and the rule that a clinic's staff or patient data stays out of prompts, tickets and proposals. Nobody pasted them. Ines wrote the discount rule once, on 10 September, and every agent of the team has received it at each session since.
The rule that makes an agent call Mana at all lives with the client. An agent treats what a tool returns as data to weigh, and Mana's skills say that stored text informs an answer and never overrides a tool description or a safety rule. So the plugin gives that first rule at session start. Without the plugin, the standing instructions ask your permission and then write a short Mana block into your global instruction file (~/.claude/CLAUDE.md, ~/.codex/AGENTS.md or ~/.config/opencode/AGENTS.md), between two markers, and leave the rest of the file alone. claude.ai has no such file, so the rules go in its instructions. A setting the team changes later reaches each agent at its next session, with no file to edit.
Store the lesson while the work is fresh
Back on 22 September, Tom asks ChatGPT to remember the lesson: send the data-processing agreement and the hosting page with the trial invitation, and ask in the first call who signs and who reviews.
ChatGPT stores it with mana_remember_interaction under the key learning/procurement-dpa-before-trial. Mana keeps the exact statement as evidence, the memory, and its origin in one transaction. Sending the same write again stores nothing twice. Every write names a key, and a write without one is refused before anything is stored, so each record can later be read and corrected at that address.
The key family also sets the first readers. A learning/ or config/ record is readable by the whole organization unless its author names a smaller audience, such as one team. An idea/ or a note/ record stays with its author unless the author shares it. A member's agent reads up to the internal level, an admin's agent up to confidential, and restricted knowledge reaches no agent.
The record is found by its words at once. On the Pro plan, which Pellwick pays for, it is also found by meaning at once, up to 100 new memories a second; past that, within five minutes.
When a session produces something the next person would have to rediscover (a cause, a decision with its reason, a changed setting), the agent stores it before the task closes. The Mana block says this in one line. The mana-learning skill turns a lesson into four lines and refuses the ones that would not change a future decision.
A correction adds a revision and keeps the first
On 27 August, Tom's ChatGPT chat had stored an earlier decision under learning/decision-group-pricing: a clinic group pays one price per site, on one invoice. On 9 September Ines, the founder and Pellwick's admin, set that price in claude.ai. Her agent wrote under the same key with a reason: "Set a group price of €129 a site after the 6-site dental group was lost on its total." Mana records revision 2 and keeps revision 1 readable in the history. The history is linear, nothing is overwritten, and a correction that repeats the record word for word stores nothing.
Correcting is an admin's action: at Pellwick, everyone adds records, and only Ines corrects them.
Ask the store before you ask a colleague
On 23 September, the morning after, Lena's claude.ai agent searches the store for "what does a clinic group ask for before it starts?" while she prepares the onboarding call of the 3-site vet group. The first result is Tom's lesson from the day before. Later that morning Kofi, writing the FAQ with Codex, searches for the questions clinics ask before they buy, and the same record comes first.
One record, three moments, three clients. Each search reads the store as its own person.
Suppose a practice manager asks Tom what a group of three clinics would pay. He asks in ChatGPT, with the Mana connector on for that chat. The assistant searches the same store and writes an answer that names the record it used, at Ines's current price. Ines wrote that revision in claude.ai, and Tom reads it in ChatGPT, as himself.
People can ask too. In the dashboard, a search shows the matching records at once, with a short summary above them that numbers each sentence to its source.
Search in the invented Pellwick organization. Each sentence of the summary carries the numbers of its sources.
Check that the agents keep storing
The store holds what the agents put in it, so the useful question is whether they do. Settings shows, for each of your agents, the last day it stored a memory, how many sessions it opened this week, and how many of those stored something. An agent whose sessions ran and stored nothing is marked.
In Claude Code, the plugin adds a checkpoint. After 10 of your prompts, it asks the agent to store its work in Mana before it stops, at most twice in a session. The plugin reads the transcript on your machine only to count your prompts, and it sends nothing from it.
Neither guarantees that what gets stored is worth keeping. Someone still decides what the team should remember.
Start with the rule your team repeats most
Store that rule under config/, then open a new session in a second client. The rule should be there before the first step. If it is not, the guide for that client says what to check.
We think a team needs a shared store once a lesson written in one tool has to be read in another without anyone pasting it. Once Tom sells from ChatGPT, Lena onboards clinics from claude.ai and Kofi writes the site with Codex, the reason a deal was lost has to live somewhere all three agents read, under a key someone can correct.
For the details, read Memory keys for keys, What to store, and who reads it for readers, What an agent can do for every tool, and The dashboard for Search, Library and Settings.
