Guide

How to share context between ChatGPT, Claude and Cursor

You spend an hour settling a decision in one AI, switch to another, and it has no idea. Here are four ways to fix that, from a free copy-and-paste habit to a setup that runs by itself.

By Northforged Labs · October 21, 2026 · 7 min read

The short answer

Keep one up-to-date brief of what is true about your project (what you decided, what you ruled out and why, your constraints, and what's next) and put that same brief in front of every AI you use. You can maintain it by hand, or use a tool that keeps it current and delivers it to each AI for you.

Why AI tools don't share context

ChatGPT, Claude, Cursor, Copilot and Gemini each keep their own conversations, and most now have some kind of memory. But every one of those memories lives inside its own app. Nothing carries over when you switch, so the only thing that moves between them is whatever you remember to paste.

That causes two problems. You re-explain the same background over and over. Worse, the AI can't tell the idea you rejected last week from the decision you settled on yesterday, so it confidently suggests things you already ruled out.

Four ways to share context

Method	Works across apps	Stays current	Effort
1. Paste a summary	Yes	No, it goes stale	Every time you switch
2. Instruction files	Per tool, mostly coding tools	Only if you edit them	Medium
3. Built-in memory	No, one app only	Automatically	None
4. A shared memory tool	Yes	Yes, continuously	Install once

1. Paste a summary

Ask the first AI to summarize where you are, then paste that into the next one. It costs nothing and works in every app. The catch: the summary is out of date the moment you keep working, and summaries tend to drop what you rejected, which is exactly what the next AI most needs to know.

2. Instruction files

Coding tools read project files automatically: CLAUDE.md for Claude Code, AGENTS.md for Codex and several others, .cursor/rules for Cursor, .github/copilot-instructions.md for Copilot and GEMINI.md for Gemini CLI. Put your brief in them and each tool starts informed. It's reliable for code that lives in a repository, but you have to keep every file in sync yourself, and it doesn't help chat apps like ChatGPT or Claude on the web.

3. Built-in memory

ChatGPT, Claude and Gemini all remember things about you now. It's automatic and needs no effort, but each memory only works inside the app that made it, so it solves the problem only if you never switch tools.

4. A shared memory tool

A tool that sits underneath your AI apps notices decisions as you work and hands each app the same current brief. Most AI apps can connect to outside tools through the open MCP standard, which is what makes one memory able to serve many apps. This is the only option that is both cross-app and automatic. The trade-off is installing something.

What a good shared brief contains

Whichever method you pick, the brief matters more than the plumbing. Keep it to about a page and include:

Decisions, with the date, so the AI knows what's current.
Rejected ideas and why. This is the part summaries drop first, and the part that stops an AI re-suggesting what you already killed.
Constraints: budget, deadlines, tools you must or must not use.
Next steps, so a new chat can pick up the work.

Here is a template you can copy:

PROJECT BRIEF  (update after every important decision)

Project:      Tidepool — booking and payments for yoga studios
Decided:      Paddle for payments (switched from Stripe, Oct 14)
Rejected:     Stripe — can't pay out to our Canadian account
              Firebase — class schedules are relational data
Constraints:  $29/month per studio · no per-booking fees
Next:         Ship the pricing page by Friday

History (superseded, keep for reference only)
  Feb 3  Payments: Stripe

How to do it by hand

Keep one file. Create a single PROJECT-BRIEF.md using the template above. This is the only copy you edit.
Add a line after each decision. Note the date and the reason. Do it while the conversation is fresh.
Give it to every tool. For chat apps, paste it at the start of a new conversation, or put it in a project's instructions. For coding tools, make each tool's instruction file point at the same source. A symlink does this on Mac and Linux: ln -s PROJECT-BRIEF.md CLAUDE.md.
Prune weekly. Move superseded decisions into the history section so the top of the file only says what's true now.

This works well and costs nothing. Its weakness is you: it only stays accurate as long as you remember to update it, and decisions made quickly in the middle of a chat are the ones that get lost.

How to automate it

ContextOS is a free desktop app that does the steps above for you. It runs on your computer, reads the work you already do in your AI tools, and turns it into the same kind of brief: decisions, rejected ideas with reasons, constraints and next steps. Then it hands each connected tool a short, current version.

Install it. Download the app for Mac, Windows or Linux. No account is needed.
Let it connect your tools. It detects supported apps (Cursor, VS Code with Copilot, Claude, Codex, Gemini CLI, Windsurf, Zed and others) and plugs into each through its MCP, plugin or skill slot. The setup screen shows which are connected.
Work as usual. It records decisions and rejections as you go, and keeps them in a private database on your computer.
Check it. Open a different AI tool and ask what you decided about something. It should already know.

Two things to know. Chat in the browser (chatgpt.com, claude.ai and similar) needs the optional browser extension, which stays off until you turn a site on. And reaching Claude on the web or phone needs the optional cloud connector. Your memory stays on your computer unless you turn those on. See the privacy policy for the details.

Try it on your next project

Free for Mac, Windows and Linux. Set up in about a minute.

Download free

Questions

Can ChatGPT and Claude share memory?

Not on their own. Each app keeps its own memory and conversations, and neither reads the other's. To share context you either maintain one brief by hand and give it to both, or use a tool that connects to both and keeps one shared memory.

What is MCP and why does it matter here?

The Model Context Protocol is an open standard most AI apps use to connect to outside tools and data. A shared memory tool that speaks MCP can be plugged into many apps at once, which is how one memory can serve several of them.

How long should a shared project brief be?

Short enough to read in a minute: roughly a page. Include what is decided, what was rejected and why, the constraints, and the next steps. Move superseded decisions into a history section so they don't confuse the next AI.

Is it safe to put project details in a shared brief?

Treat the brief like anything you paste into an AI: leave out passwords, API keys and anything you wouldn't paste into a chat. Whatever tool you use, check where the brief is stored and who can read it.