In ordinary chat use, a correction usually changes the agent’s context rather than the model’s weights. It sticks when the correction is written down somewhere the agent reads again: its instructions, its memory, a project file or a rules file. As of November 2026, ChatGPT, Claude and Microsoft 365 Copilot may retain information from corrections, depending on memory settings and what they choose to save, in the memory of the person who gave them. Claude Code can save corrections as feedback notes when auto memory is enabled, but only on the machine where they happened. To make a whole team’s agents learn, a correction has to become a shared rule with a scope, an owner, a source and a date, stored in one place every tool reads.
By Bombos. Published November 17, 2026. Sources checked November 17, 2026.
Why doesn’t an AI agent learn from corrections on its own?
A language model is fixed after training. For each request it receives a block of text, the context window: the question, the instructions, and whatever files or memories the application adds. It combines knowledge learned during training with the context supplied for the request. Say “no, this client always gets formal address” in one chat, and the next chat starts without it, unless the tool saved it and sends it again.
Research calls this learning without weight updates. Reflexion (Shinn et al., 2023) reinforces agents “not by updating weights, but instead through linguistic feedback”. The agent writes down what went wrong and reads that note on the next attempt. On the HumanEval coding benchmark this reached “91% pass@1 accuracy” after the system’s internal testing and revision process (arXiv 2303.11366). That was a coding benchmark, not a team-memory evaluation.
LangChain’s LangMem names the same idea procedural memory: “Procedural memory encodes how an agent should behave and respond.” It “starts with system prompts that define core behavior, then evolves through feedback and experience”, and its prompt optimizers “Update prompt rules and core behavior based on conversation information (with optional feedback)” (LangMem conceptual guide). A correction is a lesson about how to do the work. For the wider picture, see What is AI agent memory?.
Where do corrections end up in the tools your team uses?
| Tool | Where a correction is kept | Who benefits |
|---|---|---|
| ChatGPT | Personal memory and custom instructions; in a shared project, only what is in that project | One person, or the members of one project |
| Claude | Account memory per user, plus a separate memory per project | One person |
| Microsoft 365 Copilot | Saved memories in a hidden folder of the user’s mailbox | One person |
| Claude Code, auto memory | feedback notes in ~/.claude/projects/<project>/memory/ |
One developer on one machine |
| Claude Code, CLAUDE.md | A file in the repository | Everyone using the repository |
| Cursor | Project rules in .cursor/rules, or Team Rules from the dashboard |
The project, or the whole organization |
Sources: OpenAI Help Center, Projects in ChatGPT, Claude Help Center, chat search and memory, Microsoft Learn, Manage Copilot personalization and memory, Claude Code docs, Cursor docs, Rules, read November 17, 2026.
ChatGPT. Shared projects use project-only memory and “do not have access to an individual member’s context, custom instructions, or memories outside the project” (OpenAI Help Center). A correction someone makes in their own chats stays out of the team project.
Claude. On Team and Enterprise, owners decide whether memory is available, but “Owners can’t view or edit a user’s individual memories” (Claude Help Center). Personal memory is not automatically turned into shared team rules; users can review and share relevant information.
Microsoft 365 Copilot. Memories are “stored in the user’s Exchange mailbox in a hidden folder”, and “admins can’t restrict what type of information is added to Copilot memory” (Microsoft Learn).
Claude Code. Here, learning from corrections is designed in. When auto memory is enabled, it saves “corrections you give Claude and approaches you confirm”, and “lets Claude learn from your corrections without manual effort”, though it saves selectively, not every correction. And it is “machine-local” and “Files are not shared across machines or cloud environments”. Anthropic advises moving a lesson into CLAUDE.md when “Claude makes the same mistake a second time” or “You type the same correction or clarification into chat that you typed last session”; a project CLAUDE.md is “shared with your team through version control” (Claude Code docs). More in Claude Code memory for teams.
Cursor. Project rules are “Stored in .cursor/rules, version-controlled and scoped to your codebase”, and “Team and Enterprise plans can create and enforce rules across their entire organization from the Cursor dashboard” (Cursor docs).
The pattern is the same everywhere: what happens automatically is personal. Shared rules need an explicit publishing and review process, and usually apply to one tool; an agent can help write the rules file.
How does a team make corrections stick?
- Write the correction as a rule. Not “this is wrong” but “Use formal language when addressing healthcare clients. Reason: that is how they address us. Applies to all email and quotes.”
- Give it a scope. One client, one team, one repository, or everyone? A rule without a scope will collide with another rule.
- Store it once. Pick the place most of your team’s tools read: shared instructions, a committed rules file, or a memory layer every tool can query. Copies can diverge unless updates are coordinated.
- Keep the source and the date. Who gave the correction, when, and in response to which answer? Without provenance, outdated rules are harder to identify and remove.
- Review on a schedule. Once a month, remove what is outdated and resolve rules that contradict each other. When two people disagree, a person decides, and the decision becomes the rule.
- Test across tools. Test several relevant and out-of-scope examples from a different person and a different tool. A failure can come from retrieval, conflicting instructions or the model ignoring the rule.
Keep rules short. Anthropic notes that “The more specific and concise your instructions, the more consistently Claude follows them” (Claude Code docs), and the same holds for any agent with a long instruction file.
How does Bombos do this?
Bombos is the memory layer under the AI a team already uses: Claude, Claude Code, ChatGPT, Copilot, Codex, Cursor or your own agents. It is a plugin, not a new chat or model.
- One shared memory that learns how the team works, including from the corrections people make, available to the connected tools within the permissions you set.
- The source behind every answer: who taught it, when, and from which conversation or document.
- Your AI acts, Bombos remembers. Bombos does not take actions itself.
- Cloud on servers in Europe, or standalone on your own server. One person can try the plugin for their own agents before the team joins.
Where Bombos is not the answer: if your team works in a single repository with a single coding agent, a well-kept CLAUDE.md or AGENTS.md may be all you need.
Frequently asked questions
Can I fine-tune a model on our corrections instead? You can, but fine-tuning requires a separate training and evaluation process, while an external rule can be edited without retraining. Written rules can be changed, reviewed and traced the same day. Every tool in the table above handles corrections through instructions and memory, not retraining.
Why does the AI remember my correction in one chat but not the next? Within a chat, the correction is in the context window. In a new chat it is only there if the tool saved it to memory or instructions, and the tool decides what to save. Put corrections that must last into the instructions yourself.
Do Claude Code auto memories reach my teammates?
No. Auto memory is stored on your machine. To share a lesson, move it into the project’s CLAUDE.md and commit it.
What if the agent keeps ignoring a rule? Make it shorter and more specific, check it does not contradict another rule, and for hard limits use enforcement rather than instructions. Claude Code, for example, points to hooks for actions that must be blocked regardless of what the model decides.
Book your half hour: together we map which corrections your team keeps repeating. Free, and the plan is yours, with or without Bombos.
Which sources did we use?
All sources opened and read on November 17, 2026.
- Shinn et al., Reflexion: Language Agents with Verbal Reinforcement Learning (2023): https://arxiv.org/abs/2303.11366
- LangMem, Conceptual guide: https://langchain-ai.github.io/langmem/concepts/conceptual_guide/
- Claude Code docs, How Claude remembers your project: https://code.claude.com/docs/en/memory
- OpenAI Help Center, Projects in ChatGPT: https://help.openai.com/en/articles/10169521-projects-in-chatgpt
- Claude Help Center, Use Claude’s chat search and memory to build on previous context: https://support.claude.com/en/articles/11817273-use-claude-s-chat-search-and-memory-to-build-on-previous-context
- Microsoft Learn, Manage Copilot personalization and memory: https://learn.microsoft.com/en-us/microsoft-365/copilot/copilot-personalization-memory
- Cursor docs, Rules: https://cursor.com/docs/context/rules
