COGNITIVEX · USE CASE

One shared memory across all your AI tools

Tell it once; every tool already knows. Claude, Cursor, Codex, and ChatGPT all read and write the same living memory over MCP. Stop re-explaining yourself to a new chat window every morning.

WHY YOUR AI TOOLS KEEP FORGETTING

Every tool has its own amnesia.

You explain your architecture to Claude. You re-explain it to Cursor. You paste the same context into ChatGPT, and Codex never heard any of it. Each tool keeps, at best, its own small, siloed memory: a CLAUDE.md here, a project rule there, a chat history that truncates. None of them talk to each other, so you become the integration layer, copying context between windows by hand.

Shared memory across AI tools fixes this with one move: point every tool at a single hosted memory instead of giving each its own. Now a decision you record in one place is recallable from all of them. The memory is the constant; the tools are interchangeable front-ends to it.

ONE ENDPOINT, EVERY TOOL

MCP is the wire. The LCM is the memory.

The Model Context Protocol (MCP) lets any compatible tool call external tools and data over a standard interface. CognitiveX exposes its memory as an MCP server, so every tool that speaks MCP gets two verbs: remember and recall. They all point at the same endpoint, so they all share the same brain.

1 · Connect once per tool

add one MCP entry pointing at api.cognitivx.io with your key
same key in Claude, Cursor, Codex, ChatGPT, with nothing to run locally

2 · Write from anywhere

a decision recorded in Claude is stored in the shared memory
it is consolidated and scored for salience server-side, not dumped to a file

3 · Recall everywhere

Cursor recalls it the next time you open the repo
new tools inherit the whole history, with no re-teaching

SILOED VS SHARED

Per-tool memory vs one shared memory.

Most tools ship a memory feature now. The question is whether it stays trapped inside that one tool, or whether your whole stack draws from the same well.

Capability	Per-tool memory (CLAUDE.md, project rules)	Manual copy-paste
Remembers within one tool		partial
Survives across sessions	partial
Shared across every tool at once		manual
New tools inherit existing context
Consolidates instead of accumulating
Surfaces context by salience
Zero hand-copying between tools

Want the full head-to-head against dedicated memory products? See the comparison page.

CONNECT YOUR STACK

One config block per tool.

Create a key, then drop the same MCP server into each tool. Every tool now reads and writes the same memory. Full, per-tool walkthroughs live in the integration guides.

// add to each tool's MCP config (.mcp.json / settings)
{
  "mcpServers": {
    "icog": {
      "url": "https://api.cognitivx.io/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

Paste that into Claude, Cursor, Codex, and any other MCP client. Because the url and key are identical everywhere, all of them now share one memory. The same backbone powers iCog, the consumer app built on the LCM, so your tools and your personal AI can even share context.

A SHARED MIND, NOT A SHARED FILE

The shared thing is a memory, not a document.

A synced file is still a flat blob every tool re-reads top to bottom. The CognitiveX memory is a four-tier substrate (semantic, episodic, procedural, and foundational) that consolidates over time, scores what is relevant to the moment, and surfaces it by salience. That is the difference between a shared notepad and a shared mind.

This is what the Large Cognition Model is for. An LLM does query → answer → forget. The LCM closes the loop: a memory that every tool feeds, that reasons over its own contents, and that gets sharper the more your stack uses it. The tools are interchangeable; the cognition is the moat.

FREQUENTLY ASKED

Common questions

What does "shared memory across AI tools" actually mean?

One hosted memory that every AI tool reads from and writes to. When you tell Claude a decision, Cursor and ChatGPT can recall it on their next turn, because they are all pointed at the same CognitiveX memory over MCP, not at separate per-app stores.

Which tools can connect?

Anything that speaks MCP: Claude (desktop and Claude Code), Cursor, Codex, Windsurf, Zed, and a growing list of IDEs and agents. Tools without native MCP can call the same memory over the HTTP API. They all hit one endpoint with your key.

Is this just a synced file like CLAUDE.md?

No. A file is static text you maintain by hand and copy between tools. The CognitiveX memory is a hosted, four-tier substrate that consolidates, scores salience, and surfaces the right context by relevance, not a flat document each tool re-reads.

Do I have to re-teach each new tool?

No, that is the whole point. New tools start with everything the memory already holds. Connect Cursor today and it inherits the context you built up in Claude last month.

How do I set it up?

Create a key, add one MCP server entry (or one CLI command) to each tool pointing at api.cognitivx.io, and you are done. There is nothing to run locally; the memory is hosted.

Give your whole stack one memory.

Connect every AI tool to the same living memory. Tell it once; every tool already knows.

Start building →Try iCog →