I built Threadbase to give AI coding tools a shared memory inside the repo

The biggest problem I kept running into with AI coding tools was not code generation.

It was memory.

I would explain the repo to one agent, switch tools, and then have to explain the same project all over again.

Claude.
Codex.
Cursor.
Copilot.
Gemini.

Each tool was useful on its own, but the project context kept getting fragmented across sessions and agents.

That felt like the real bottleneck.

So I built Threadbase.

What Threadbase does

Threadbase makes the repository itself the shared memory layer for AI-assisted development.

It stores project context in plain Markdown inside the repo, so agents are not depending only on chat history or tool-specific memory.

That means:

• different agents can work from the same memory
• teammates working on the same project can use the same context
• anyone can pick up from anywhere without starting from zero
• the memory stays in Git with the rest of the project

Instead of asking, "Which AI tool remembers this project best?"

the better model is:

the repo remembers, and the agents read from it.

Why that matters

A lot of current AI coding workflows are tool-specific.

You build up useful context in one tool, but the moment you switch agents or start a fresh session, continuity breaks.

That creates a few recurring problems:

• repeated prompting
• inconsistent decisions
• context getting lost between sessions
• teammates and agents working from slightly different understandings of the project

Threadbase is my attempt to solve that in the simplest possible way.

Not with a hosted memory layer.
Not with another dashboard.
Not with lock-in to one agent.

Just a small repo-native convention that lives alongside the code.

How it works

Threadbase creates a .ai/ folder in your repo with a few key pieces:

• .ai/memory/ for durable project memory
• .ai/generated/context.md for the current working context
• agent instruction files like AGENTS.md, CLAUDE.md, GEMINI.md, and others that point agents to the same shared memory

So the flow becomes:

1. Initialize Threadbase once.
2. The agent reads the shared project memory before starting work.
3. As work happens, the memory gets updated inside the repo.
4. Another agent or teammate can pick up from the same context later.

No manual copy-pasting between tools.
No separate sync step every time.
The workflow itself keeps the shared memory in motion.

The part I care about most

Threadbase is intentionally:

• repo-native
• git-native
• agent-agnostic
• markdown-first

I did not want this to be "memory for one AI tool."

I wanted it to work across tools.

If I want to switch from Claude to Codex to Cursor, I should not have to re-explain the project every time.

If someone else on the team opens the repo, they should be able to use the same project memory too.

That is the real value.

Quick start

bash
npm install -g threadbase
threadbase init
Run that in the project repo or agent workspace root.

Why I’m sharing it
I think AI-assisted development needs better shared context primitives.

Right now, a lot of workflows are still too session-bound and tool-bound.

My bet is that project memory should live closer to the repo, be readable by humans, and be usable by any agent.

That is what Threadbase is trying to do.

If you are experimenting with multi-agent workflows, AI coding tools, or shared context in development, I’d love to hear what breaks, what feels right, and what should exist next.

GitHub: https://github.com/ani3198/threadbase
npm: https://www.npmjs.com/package/threadbase