One memory for every AI you use

Confluo is a unified memory layer for every AI tool you use. It sits outside ChatGPT, Claude, Gemini, and the rest, quietly keeping a permanent, searchable record of every decision, bug, feature, and fact you've ever discussed — so you stop re-explaining your project from scratch every time you open a new chat.

Most people don't use one AI. They bounce between ChatGPT for brainstorming, Claude for writing code, Gemini for research, and maybe Cursor or Windsurf for the actual build. Every one of those tools has its own memory, if it has any at all, and none of them talk to each other. The moment you switch tools, or start a new session, your context resets to zero.

Confluo fixes that by treating your project — not any single AI — as the thing that should remember. You create a project once, and every conversation you have about it, on any tool, becomes a permanent, structured memory that any other AI can be handed later.

Why Confluo

A few concrete problems Confluo is built to solve, and what you get once your project has a real memory behind it.

• No more re-explaining your stack. Tell an AI once that you're using Firebase, Stripe, and vanilla JS — every future conversation, on any tool, can start from that baseline instead of you retyping it.
• Decisions stop getting lost. "Why did we raise the price to $5?" or "why server-side webhooks and not client-side?" are answerable months later, with the original reasoning intact.
• Every AI conversation becomes an asset, not a throwaway. Instead of a chat log you'll never reopen, each conversation is parsed into decisions, bugs, features, and TODOs you can actually search.
• You're not locked into one AI vendor. Your project history lives in Confluo, not inside ChatGPT's or Claude's memory — so switching models, or using several at once, costs you nothing.
• Your team sees the same picture you do. Collaborators share the same timeline, graph, and files, instead of everyone holding a different half-remembered version of the plan.

Quickstart

The fastest path from "never used Confluo" to "Claude and ChatGPT both understand my project." Takes about five minutes.

Projects

A project is the unit everything else in Confluo attaches to — one persistent workspace per app, product, or client you're building for.

Every memory, file, and conversation belongs to exactly one project. That keeps a freelance client's work separate from your side project, and means a Switch Context document (or an MCP tool call) only ever pulls in the history that's actually relevant.

You can hold multiple projects at once — the free plan includes 3, Pro is unlimited — and archive or delete ones you're no longer actively building.

Memory timeline

Every saved conversation becomes a permanent checkpoint in your project's history — browsable, searchable, and filterable, like git log, but for your thinking instead of your code.

Each entry is automatically tagged with the AI it came from, a timestamp, and the categories Confluo's extraction pipeline pulled out of it — decisions, bugs, features, architecture notes, and open TODOs. You can drop into any entry to read the full original conversation, or delete entries you don't want kept.

Knowledge graph

A visual map of your project where every memory is a node connected to the facts it produced.

Scroll to zoom, drag to explore, and click any node to jump straight back into the session it came from. It's the fastest way to see the shape of a project you've been building for months — what's done, what's pending, and where the actual blockers are — without reading the timeline top to bottom.

Files & folders

Every project carries a real file tree, not just a memory log.

Create folders, drop in files directly, or sync code straight out of a saved conversation. This turns a Confluo project from a passive history into an actual working directory for the project — useful for keeping specs, configs, and reference docs next to the decisions that produced them.

Team collaboration

Invite collaborators into any project and everyone works from the same source of truth.

Teammates see the same timeline, graph, and files you do, and a built-in team chat keeps day-to-day back-and-forth in the same place as the work itself — instead of scattered across Slack threads that don't connect back to any of it.

Manual paste

The zero-setup way to save any conversation, from any AI, on any device.

Chrome extension

One click, on any AI website, saves the full conversation automatically — no copying, no pasting.

Switch Context

A one-click, AI-optimized summary of everything Confluo knows about your project — built to be pasted directly into a new conversation on any AI.

Open your project and click Switch Context. Confluo compresses the tech stack, key decisions, and next steps into a compact document, ready to copy. Paste it as the first message in a new ChatGPT, Gemini, or Claude conversation, and that AI instantly understands months of history it was never part of.

This is the manual equivalent of what the Claude MCP connector now does automatically — Switch Context still works everywhere, MCP just removes the copy-paste step inside Claude.

What is MCP

The Model Context Protocol is an open standard that lets AI apps like Claude connect to external tools and data. Confluo runs a hosted MCP server, so you can plug it into Claude as a custom connector — just a URL, nothing to install.

Once connected, Claude can list your projects, pull the full context for one of them, save the conversation you're currently having, and search past memories by keyword — all without you leaving the chat to copy a Switch Context document by hand.

Connect to Claude

The recommended way to connect Confluo to Claude on the web, desktop, and mobile. About a minute, no config files.

Connect to Claude Code

Claude Code has first-class MCP support. Confluo connects with a single CLI command — no config file, no OAuth flow. Every one of Confluo's tools becomes available inside your coding sessions.

$ claude mcp add --transport http confluo https://app.confluo.in/api/mcp/YOUR_TOKEN/mcp

$ claude mcp add --transport http --scope user confluo https://app.confluo.in/api/mcp/YOUR_TOKEN/mcp

$ claude mcp list

Sharing with your team

To commit Confluo into a project so teammates get it on clone, use --scope project. This writes a .mcp.json file at your project root.

Important: your token is personal — don't commit the raw URL. Reference it as an environment variable instead:

# In your shell or .env:
$ export CONFLUO_TOKEN=your_token_here

# Add it to the project — teammates set their own CONFLUO_TOKEN
$ claude mcp add --transport http --scope project confluo "https://app.confluo.in/api/mcp/${CONFLUO_TOKEN}/mcp"

Add CONFLUO_TOKEN to your .env.example so teammates know what to set.

Rotating your token

If you regenerate your Confluo token, remove and re-add:

$ claude mcp remove confluo
$ claude mcp add --transport http --scope user confluo https://app.confluo.in/api/mcp/NEW_TOKEN/mcp

Connect to ChatGPT

ChatGPT supports custom MCP connectors through Developer Mode. It's free to enable but off by default, and available on ChatGPT Plus, Pro, Business, Enterprise, and Edu on the web.

Connect to Codex

Codex uses the same MCP configuration format across Codex CLI, the VS Code extension, and the Codex desktop app — one setup covers all three.

Codex CLI

The fastest path — one command, no file editing.

$ codex mcp add confluo --url https://app.confluo.in/api/mcp/YOUR_TOKEN/mcp

Codex persists this to ~/.codex/config.toml automatically. Verify it worked:

$ codex mcp list

Edit config.toml directly

If you prefer editing the config yourself, or want to scope Confluo to a specific project, add this block:

[mcp_servers.confluo]
url = "https://app.confluo.in/api/mcp/YOUR_TOKEN/mcp"

For project-scoped servers (trusted projects only), use .codex/config.toml at the project root with the same syntax.

Codex VS Code extension & desktop app

Both surfaces share the same config.toml as the CLI — if you added Confluo with codex mcp add, it's already there. To add it through the UI instead:

Local install

Prefer to run the server on your own machine? The confluo-mcp npm package runs locally via npx. This path is Claude Desktop only and needs Node.js — most people should use the custom connector instead.

{
  "mcpServers": {
    "Confluo": {
      "command": "npx",
      "args": ["-y", "confluo-mcp"],
      "env": {
        "CONFLUO_TOKEN": "your_token_from_confluo_settings",
        "CONFLUO_API_URL": "https://app.confluo.in"
      }
    }
  }
}

Available tools

Four tools ship in the current version of the Confluo connector.

Example prompts

Once connected, you don't need to name the tools — just describe what you want in plain English.

Troubleshooting

Pricing & plans

Start free, no credit card, no expiry.

Security & tokens

Your token is the single credential behind the Chrome extension and the Claude connector alike.

• Scoped to you. Every request made with your token acts as you, against your projects only.
• Revocable any time. Regenerating or revoking a token from Settings immediately breaks every device and connector using the old one.
• It lives in your connector URL. Claude stores custom-connector settings encrypted and doesn't show the URL again after you add it — but still treat the URL like a password, and regenerate the token if it ever leaks.
• Local installs store it in plain text. If you use the npx method, keep claude_desktop_config.json readable only by your own account, and never commit it to a shared repo.
• Every action is explicit. Claude asks for approval before calling a Confluo tool, just as it does for any other connector.

FAQ

Roadmap

What's shipped, what's actively being built, and what's still an open direction. Nothing here is a promise of a date — it's where Confluo is headed.

Compatibility with other AIs

Product