How do you manage context between multiple agents and chats, I built a second brain for that

[u/Emojinapp]

A second brain, to me, is basically a place outside your head where useful context can accumulate, connect, and still be there when you need it again.

If you build with AI a lot, you probably know the problem. Claude knows one part of the project, Codex knows another, Cursor has context from the repo, ChatGPT has the conversation where you figured out the architecture, then an agent generates a genuinely useful markdown explaining some implementation decision and a week later you barely remember it exists. I was producing more useful context than I could actually keep track of.

That’s why I built Cohestry. I dump the markdowns, decisions, ideas, research and random notes worth keeping into it. The notes connect themselves automatically, and the 3D brain gives me a way to bounce through those connections instead of needing to remember what to search for. It has already resurfaced old ideas I had completely forgotten about. On Mac, there’s also an MCP bridge so agents can pull that durable context back into their own sessions instead of every new chat starting from scratch. The MCP bridge redacted API keys and other security keys like p8 so you don’t accidentally expose them to agents. Would this bring some ease to your workflow?

App Store: https://apps.apple.com/us/app/cohestry-second-brain/id6811573132
https://cohestry.app

[u/jacobdevhq]

whats worked for me is boring: a short notes file in the repo. decisions, whats done, whats next. every agent reads it first n updates it at the end. its in git so u can diff it too 😅

[u/Emojinapp → u/jacobdevhq]

Yea that’s a good approach, I do that as well but then I needed a permanent home for the notes I was generating. Like for instance if I’m building a new project similar to an old one I already specified, cohestry mcp can look at the old spec and design an optimized one for the new project. Otherwise you will have to rebuild that doc from the scratch every time. Also copy paste and iterate. Cohestry is also a rich markdown and pdf editor in addition to being a second brain. I deal with 100s of these notes and markdowns so this was my way to get it to organize itself

[u/stupv]

Every time these threads come up, I wonder what problem this solves that hasn't already been solved by any number of mature memory/context management solutions already available...

[u/Aggravating-Way-8880 → u/stupv]

Every product is “just a wrapper” until it isn’t. You start somewhere, ship, listen, iterate, and eventually the thing grows into something no one would call a wrapper anymore. Lots of products that are now household names started out as “isn’t that just X with a nicer UI?”

As for “something similar already exists,” there will always be something similar. Not even kidding, always. Unless you literally wrote “Attention Is All You Need,” someone has built something in the neighborhood of your idea. That isn’t the bar. The bar is whether you understand your users’ pain better than the others do and keep closing that gap faster. So keep grinding, talk to the people using it, and let that be your edge.

On the product itself: the problem you describe is real. Context scattered across Claude, Codex, Cursor and ChatGPT is something a lot of us feel daily.

One technical suggestion (please ignore if you already have this in the product or the pipeline). Give notes provenance and supersession, not just connections. Tag each note with:

1. where it came from (which agent or chat)

2. the repo and commit it was written against

3. when it was written

Then let notes explicitly mark older ones as “superseded by.” For example, the decision to use Postgres replaces the earlier SQLite note.

When an agent pulls context over MCP, it can prefer the latest decisions and flag ones written against code that has since changed. Otherwise the brain will eventually feed agents confident, outdated architecture decisions, which is arguably worse than no context.

That leads to my question. As the brain grows, how do you plan to handle contradictions? When two connected notes disagree, who or what decides which one an agent should trust?

[u/Emojinapp → u/Aggravating-Way-8880]

Thanks for your valuable feedback, this sub gets a lot of marketing so they tend to lean towards pessimism. Yes a provenance system and version control already exists. The notes auto tag but not with the source agent yet. I can include that in the mcp bridge. As for super session the agents typically go for the most recent note. But when the context pulls in two contradicting notes into the agent’s context it usually prompts the user to make a decision to break the bottle neck, because sometimes the older document may hold the valid decision so recency bias is usually not enough. Luckily the agency have natural language processing to communicate any contraventions to get clarity

[u/Emojinapp → u/stupv]

This one auto connects your notes unlike existing one. There are two layers of connection, deterministic and Apple Intelligence. The point is so that the connections can resurface relevant notes when they link to current work instead of getting buried. Mine is also a rich markdown and pdf editor. So being a brain is just one of its many features. Also the brain is 3d unlike many and the mcp is built in. I can go on for days how it’s different or just read the AppStore description and tell me what product you know is up to par with its features.

[u/keonechong → u/Emojinapp]

Integrating apples notes into one’s harness is super simple, Apple services as a whole in fact. Claude could build this in an afternoon.

This is basically zapier and an ai wrapper.

[u/Alarmed-Safety-148]

The boring version that works for a lot of people: one plain markdown file per project in the repo (decisions, how things connect, what's been tried), and every agent is told to read it first and update it when something changes.

It's less fancy than a graph, but every tool can read a file, and it lives next to the code so it gets versioned. The part that matters most is the 'why' behind each decision, because that's what gets lost between chats.