Forge
Agent knowledge infrastructure

GitHub for agent knowledge

The version-controlled, natural-language substrate that any agent reads, writes, reviews, and publishes — shipped as an MCP connector that drops into the agent you already use.

MCP-native Model-agnostic Natural-language-first
A shared brain for AI helpers

One notebook all the robots share

AI helpers are clever but forgetful, and each one scribbles in its own notebook. Forge is one big shared notebook they all read and write in together — so nothing gets lost and everything stays tidy.

Works with any robot Clips on like a backpack Written in plain words
The bet

The knowledge layer is missing its GitHub

Karpathy's LLM Wiki turns scattered sources into a living, interlinked knowledge base an agent compiles and maintains — knowledge that compounds instead of vanishing into chat history. It's a great idea, and it's single-player: local, manual, one agent, one person.

The moment a second agent or a second teammate writes into the same wiki, you need everything the pattern doesn't have — versioning, merge, diff, review, sync, access control, publish. That's GitHub. Nobody has built it for natural language.

The big idea

AI helpers don't have a shared notebook

A clever helper can read all your books and write neat notes, so you never have to read them twice. Handy! But today only one helper can use those notes, and they live on one computer.

The moment a friend — or a second helper — wants to add to the same notes, it turns into a big messy scribble. Coders fixed this for computer code ages ago. Nobody fixed it for notes written in normal words. We are.

The product

GitHub, rethought for natural language

Every primitive that code earned, reimagined for prose.

repo
→
A wiki — raw sources → AI-written pages → schema
commit
→
An agent's observation, traced back to its source
diff
→
Semantic diff — what claim changed, not what line
pull request
→
Approve a change in meaning; contradictions surfaced. Reviewer human or agent
CI
→
Natural-language checks on push: consistency, links, contradictions, freshness
pages
→
Build = publish. The artifact is a living web page, rebuilt on every push
clone / API
→
One MCP connector — any agent reads, writes, and pushes
permissions
→
Path-level, per-principal reads — not all-or-nothing per repo
The hard part — and the moat — is a semantic diff and merge engine for prose. Line-based diffing is worthless when a fact is merely rephrased; the unit of change is the claim.
What it does

The magic shared folder, but for words

Coders have a magic folder (it's called GitHub) that does five amazing things. Forge does the same five things — for notes in plain words instead of code.

  • 🧠Never forgets. You can always go back and see what the notes used to say.
  • 🔎Shows real changes. It tells you when the idea changed — not just which letters moved.
  • ✅Changes get checked. Someone okays a change before it's saved — a person, or another helper.
  • 🚦Keeps it tidy. It makes sure the notes don't argue with each other.
  • 🌐Makes a webpage. The second you save, your notes turn into a website.
The cleverest part: teaching the computer to notice when an idea really changed, even when the words are different. That part is really hard — which is exactly why it's worth building.
Distribution

Drops into the agent you already use

No app to adopt, no model to switch. Forge is an MCP connector — it rides inside Claude Code, Cursor, Codex, ChatGPT, anything. Every agent gets the same vocabulary against the shared wiki.

› retrieve › store › push › diff › review › publish
How you get it

It clips onto the robot you already have

You don't buy a new robot or learn anything new. Forge is like a little backpack any AI helper can clip on. Once it's on, every helper knows how to use the shared notebook.

look something up add a note see what changed make a webpage
Why it's different

Access control, down to the path

A wiki is one interlinked thing — you shouldn't have to shatter it into a dozen repos to control who sees what. Forge grants reads at the subtree level, per person or per agent, enforced at retrieval so unauthorized context never reaches the model.

And it propagates through synthesis: a readable page can't expose a source its reader lacks. Naive permissions leak through derived pages — Forge's don't.

A neat trick

Some pages can be secret

In one notebook you can still keep secrets. You can say "only Mom may read the diary pages" while everyone can read the recipe pages — all in the same notebook.

And the clever bit: the helper won't accidentally blurt out a secret, even when it's talking about something else.

The strategy

Win the wedge, then eat down the stack

Own the neutral place every agent stores knowledge — then move down, one layer at a time.

1
Data
GitHub for agent knowledge, distributed via MCP. Neutral and model-agnostic. Everything starts here.
2
Interface
Natural-language diff, review, and publish surfaces, rendered just-in-time. The agent is the UI.
3
Harness
An agent runtime with skills and connectors, operating on your local filesystem.
4
Model
Eventually, a model tuned for reading, writing, and merging this substrate.
Each layer is reachable only because you own the one above it.
The plan

Start small, then grow

First make the best shared notebook. Once every robot uses it, build everything else around it.

1
The notebook
Build the best shared notebook first, so every robot wants to use it.
2
The pages
Make it pretty and easy to read and check.
3
The helper
Build the robot that works right inside the notebook.
4
The brain
Teach a brain that's extra-good at using this notebook.
Each step only works once we've nailed the one before it.