Introduction

One brain for every AI coding agent. A large language model is stateless: one context window, wiped every call. It has no memory of what your team learned, no foresight about what an edit will break, and no enforced guardrails. Forge (@codewithjuber/forgekit) is the cognitive substrate — the layer that runs before the model edits code, supplying evidence-referenced, content-addressed memory (we call it “proof-carrying memory”), heuristic impact foresight, and enforced guardrails — and a cross-tool config compiler that delivers that brain as native config into every tool at once. Claude Code is the deepest-tested integration; the others receive native config and MCP tools with less real-world exercise.

​

The problem

A large language model is stateless — one context window, wiped every call.

• It has no memory of what your team already learned.
• It has no foresight about what an edit will break.
• It has no enforced guardrails — prose rules get forgotten after a compaction.

And every tool wants its own config file (CLAUDE.md, AGENTS.md, .cursor/rules, GEMINI.md, MCP…). Forge is the cognitive substrate that supplies the three missing things, and the compiler that delivers it into every tool from one source.

​

The thesis

A model can’t learn from your codebase between calls: its weights are frozen and its working memory is wiped after every response. Memory, foresight, and self-checking can’t be prompted into it — they have to be supplied from outside. That outside layer is the cognitive substrate. Formally, inference is a fixed function y = f(x) with no state between calls; Forge is the state.

​

What you get

• Memory that persists across sessions and teammates. Every lesson, fact, and verified reuse is proof-carrying memory (PCM) — our name for evidence-referenced, content-addressed memory: a claim that carries references to its evidence and is trusted only once independent oracles raise its confidence above a floor. The “proof” is that evidence trail, not a formal proof.
• Foresight before you break things. Ask “what does changing verifyToken break?” and get the blast radius from the code graph, including coupled files you never named.
• Guardrails that can’t be forgotten. Deterministic hooks enforce protected paths, cost budgets, and doom-loop detection — they survive a context compaction.
• Work that finishes end to end. A completion gate blocks “done” once per session when code moved but no doc or state artifact followed, with the repair checklist as the answer.
• One config for 9 tools. Author your rules once; Forge emits each tool’s native config, plus MCP for Roo and VS Code. Zero runtime dependencies — one Node CLI, plain files in git, no server.

​

Which tools does Forge feed?

Forge emits config for nine tools, plus an MCP server for Roo Code and VS Code: Claude Code, Codex, Cursor, Gemini, Aider, Copilot, Windsurf/Devin, Zed, and Continue. Each reads the same rules from its own native file.

​

Honest limits

Forge states its own ceiling everywhere.

• Guards enforce only what is expressible as a hook (paths, format, diff-size, budget). Semantic rules (“prefer functional”) stay prose and will sometimes be ignored.
• Verification reduces, does not certify. Crew verifiers and the hallucinated-symbol flag cut review burden; they do not prove the code correct.
• No weight-level learning. recall / cortex are file-and-prompt memory only — no RL, no fine-tuning.
• The impact graph is regex-approximate — conservative, not a sound call graph.
• Tests and human corrections always win.

​

Next steps