v0.2.1 MIT · MCP + REST · zero runtime dependencies

One project.
One brain.
Every AI.

You plan in ChatGPT, argue architecture with Claude, ask Grok and Perplexity, and let Codex, Claude Code, Cursor, Copilot and Gemini write the code. Each one remembers alone. hamyad gives all of them one shared brain: every chat, decision and code change, attributed to the tool that made it, and visible to all the others the next time they start.

Watch five AIs share one brain Connect your AI

$curl -fsSL https://mrzroot.github.io/hamyad/install.sh | sh

PS>irm https://mrzroot.github.io/hamyad/install.ps1 | iex

Paste it into a terminal inside your project. It installs Node if needed, asks before touching anything, wires every AI tool and can give ChatGPT & Claude.ai a public URL.

ChatGPT
Claude.ai
Claude Code
Codex
Cursor
Gemini CLI
Gemini app
Grok
Copilot
Windsurf
Perplexity
Claude Desktop
Zed
Cline · Roo
JetBrains
aider

.brain/

◆ decision · ChatGPT± change set · Codex💬 session · Cursor

A dozen AIs, a dozen islands

Decide something in ChatGPT and Codex never hears about it. Change your mind in Claude and Cursor keeps building the old plan. Every tool has its own memory, and none of them talk.

Chat apps

ChatGPT memory, Claude Projects, Gemini Gems, Grok and Perplexity threads: each a private memory in someone's cloud, with no way to write back to your repo.

Coding agents

Claude Code, Codex, Cursor, Copilot, Gemini CLI, Windsurf, aider: each keeps its own transcripts on this machine only, and none knows what the others did yesterday.

Your repo

The code changes, but the why lives in a chat nobody else can see. When a decision changes, agents keep working on the stale one.

Sources and the full survey of every tool's hooks, logs and connectors: RESEARCH.md

Five AIs, one brain

This is hamyad's real brain and MCP server, compiled to run in your browser. Pick any chat app on the left and any coding agent on the right: they all write to the same drawer, and each agent is told what changed since its last session. Nothing is faked except the network.

Show JSON-RPC wire

ChatGPTchat · hamyad connector

.brain/0 entries

~/shop $ claudehooks + MCP

hamyad timelineevery tool's chats, decisions and code changes, newest first

JSON-RPC wireexactly what each AI and hamyad say to each other

Step by step

From zero to “every AI shares one brain” in a few minutes. Pick where you want to start; the animation shows each screen. Menus are drawn from the apps as of October 2026 and may move a little.

Connect any AI

hamyad init --all wires every coding tool in your repo. hamyad connect <tool> prints the exact steps for the rest. Anything else can use MCP, the REST/OpenAPI endpoint, or the always-fresh MEMORY.md.

Chat apps need a public URL

They call connectors from their own cloud. Use the free Cloudflare Worker over your GitHub repo, or with no GitHub at all run hamyad serve --token … next to your shared folder and expose it with cloudflared tunnel.

No GitHub? One file is enough

hamyad init --all --store ~/Dropbox/shop/MEMORY.md keeps the whole brain in one Markdown file in Dropbox, Google Drive or a cowork folder. Upload that same file to any chat that only takes files.

How it works

1
Every AI writes

Chat apps call brain_remember through a connector or GPT Action. Coding agents are captured by hooks: each session's prompts, outcome and git diff become entries, attributed to the tool.
2
One folder stores

Plain Markdown in .brain/: in your repo (GitHub is the source of truth), in any synced folder, or in a single MEMORY.md. Secrets are redacted before anything is written.
3
Decisions supersede

When a new decision replaces an old one, the old one is marked superseded everywhere. hamyad flags likely conflicts instead of guessing.
4
Every AI catches up

At session start each agent reads the brief plus “⚠ DECISIONS CHANGED since your last session” and what the other tools did. Chat apps get the same through brain_context.

 ChatGPT · Claude.ai · Grok · Perplexity · Gemini app ──remote MCP / GPT Action / REST──┐
                                                                                         ▼
 Claude Code · Codex · Cursor · Copilot · Gemini CLI · Windsurf ──hooks + MCP──▶  .brain/  ◀── git · Dropbox · Drive · one MEMORY.md
 Zed · Cline/Roo · JetBrains · Claude Desktop ──────────────────────MCP──────▶   decisions · tasks · notes · sessions · changes
 aider ───────────────────────────────────AGENTS.md + chat import on commit──▶   → CLAUDE.md / AGENTS.md / MEMORY.md regenerated

When	What hamyad does
Session start	pull, refresh CLAUDE.md / AGENTS.md / MEMORY.md, inject brief + “decisions changed”
Every prompt	record it (redacted); warn if another tool changed a decision meanwhile
Turn / session end	session summary + git diff, commit, push in the background
MCP / REST write	entry saved, MEMORY.md and instruction files regenerated
git commit · timer	import aider chats; `hamyad watch` imports local chat logs and syncs on a schedule

Set it up in ten minutes

Inside your repo. init --all creates .brain/ and merges MCP servers, hooks and rules for Claude Code, Codex, Gemini CLI, Cursor, Copilot, Windsurf, Zed, Roo, Junie and aider, without touching anything already there.

cd my-project
curl -fsSL https://mrzroot.github.io/hamyad/install.sh | sh      # Windows: irm https://mrzroot.github.io/hamyad/install.ps1 | iex
#  = install Node if missing + hamyad + `hamyad setup` (init --all, pre-approve tools)
# already have Node 20+?  npm i -g https://github.com/mrzroot/hamyad/releases/latest/download/hamyad.tgz && hamyad init --all
git add -A && git commit -m "Add hamyad brain" && git push
hamyad import      # past chats from Claude Code, Codex, Gemini, Copilot, Cursor, Windsurf, aider
hamyad status      # which tools are wired, last session of each

hamyad setup gives chat apps a public URL: a free Cloudflare quick tunnel (no account, lives while the window is open) or a permanent free Worker (it runs wrangler login and deploys for you). It then prints every connector URL below and can open the Claude.ai and ChatGPT pages for you.

hamyad setup            # wizard: 1) quick tunnel  2) Cloudflare Worker  3) own URL  4) skip
hamyad tunnel           # just share this brain now (quick tunnel)
hamyad setup --worker   # permanent URL on your free Cloudflare account

ChatGPT     Developer mode → Add custom MCP server   URL/mcp/<TOKEN>?source=chatgpt
            or GPT → Actions → Import from URL       URL/openapi.json  (API key: Bearer <TOKEN>)
Claude.ai   Connectors → Add custom connector        URL/mcp/<TOKEN>?source=claude-chat
Grok        grok.com/connectors → Custom             URL/mcp/<TOKEN>?source=grok
Perplexity  Connectors → Custom → Remote             URL/mcp/<TOKEN>?source=perplexity
Gemini app  Connected Apps → Add a custom app        URL/mcp/<TOKEN>?source=gemini-app  (or upload MEMORY.md)

hamyad connect instructions   # paste into the Project / GPT / Gem / Space instructions

The brain can live in any folder your machines and tools share, or in one file. Serve it to chat apps through a tunnel.

hamyad init --all --store ~/Dropbox/brains/shop/MEMORY.md
hamyad serve --host 0.0.0.0 --token "$HAMYAD_TOKEN"
cloudflared tunnel --url http://localhost:8787
hamyad watch --interval 300    # timer: import local chats, refresh MEMORY.md

Things hamyad will never do

Store your API keys. Secrets are redacted from chats, prompts and diffs before anything is written.
Push your work in progress. It pushes only when every unpushed commit is a brain: commit.
Capture full transcripts unless you opt in. The default is a short summary.
Run a public server without a token. Workers and hamyad serve refuse to.
Lock you in. It is a folder of Markdown. Delete hamyad and the notes stay.

Next to what already exists

	Built-in memories	basic-memory	mcp-memory-service	Mem0 MCP	hamyad
Works across vendors	✗ one app each	✓ MCP clients	✓ MCP clients	✓ MCP clients	✓ MCP, GPT Action, REST, MEMORY.md
Captures agent sessions + code diffs	✗	✗	~ own hooks	✗	✓ hooks for 6 agents + importers
Superseded decisions flagged to every tool	✗	✗	✗	~	✓
Lives in your repo or folder	✗	~ notes dir	✗ DB	✗	✓
Semantic search	–	✓	✓	✓	✗ keyword, Persian-aware
License	–	AGPL-3.0	Apache-2.0	Apache-2.0	MIT

hamyad cannot read the built-in memories of ChatGPT or Claude (there is no API). Chat apps write to hamyad because the connector and your instructions ask them to.

Questions

Does it need an OpenAI or Anthropic API key?

No. The thinking happens in whichever AI you already use; hamyad only stores, summarises (without any model call) and serves.

Which tools are really tested?

Claude Code, Codex, Gemini CLI, Copilot CLI and aider run for real against a mock model server in our e2e suite: hooks fire, sessions and diffs are captured, and “decisions changed” reaches each model. Cursor, Windsurf, Zed, Roo and JetBrains configs are verified by parsing; chat-app connectors need your account.

I am in Iran. Will the connectors work?

Yes. ChatGPT, Claude.ai and Grok connect to your Worker from their servers, not from your device, so domestic filtering of workers.dev does not affect them. You may need open internet once to deploy.

What about teams?

Everyone with repo (or folder) access shares the brain. The remote endpoint uses one token per deployment; OAuth per person is on the roadmap.

Can I edit entries by hand?

Yes, in your editor, on github.com, or right inside MEMORY.md.

One project.One brain.Every AI.