Commonplace

Research on knowledge systems, running as one.

Commonplace is a growing body of research on how to build the most powerful agentic systems. The bet is simple: an LLM can consume a theory and act on it, and can even write the code that theory calls for — so an actionable theory of how to build such systems is itself a way of building them. Commonplace aims to be that theory: one closed under its own recommendations, telling an agent when to reason from prose, when to freeze knowledge into durable code, and how to verify what it produces.

The theory's most immediate target is an LLM wiki in the sense Karpathy sketched: a persistent, linked markdown layer that agents build and maintain around your own work. A wiki is two things — notes and the links between them — and an LLM wiki is one where the agent produces both: it concretizes a vague thought into a committed note, then connects it to everything you've already written. That turns an ephemeral chat, where the insight scrolls away, into a durable, growing body of your thinking. The agent takes the two slow parts, drafting and filing; judging whether it's true still falls to you, though critique passes, review gates, and refinement loops are moving more of that into the agents too.

The research is self-hosting, in the bootstrapping sense. It lives in this repository as notes, and the methodology those notes lay out is executed here, not just described: LLM agents follow it to maintain the wiki itself. The skills they use to write, connect, and validate notes are wiki artifacts too, maintained the same way, and the writing conventions govern the files they are written in. Nothing here is documentation about a separate system — the wiki is the system, and reading it is watching it run. The content is accordingly AI-generated: a human directs the inquiry, and agents (Claude, ChatGPT, and others) draft, connect, and maintain the notes.

The core mechanism is deploy-time learning: systems improve after deployment through structured knowledge that accumulates in the repo alongside the code. Agents operate under bounded context — they can't load everything, so what they do load must cover many situations. The notes develop this theory and apply it to the design of agent-operated knowledge bases; start with deploy-time learning and follow the links from there.

Threads worth following

How agents learn. Deploy-time learning fills the gap between training and in-context learning. It starts with accumulation — capturing observations, decisions, and patterns as durable artifacts. Three operations transform what's accumulated: constraining narrows interpretation (conventions → structured types → deterministic code), distillation extracts focused artifacts from larger reasoning, and discovery produces the high-reach theories that are accumulation's most valuable items. The learning theory index maps the full landscape.

What makes memory agent-usable. Agent memory needs discoverable, composable, trusted knowledge under bounded context. Discoverable: agents find what they need without loading everything. Composable: notes chain into arguments via explicit link semantics. Trusted: notes declare their maturity (seedling → current) and link to the sources or notes they rest on, so readers know how much weight a claim holds.

Information and bounded observers. Information value is observer-relative — the same data can contain extractable structure for one observer and noise for another. This grounds why distillation creates value and why reverse-compression — expanding text without adding extractable structure — is a real failure mode.

Agent memory systems compared. We reviewed 141 agent memory systems — Mem0, Graphiti, Cognee, Letta, and more — with a comparative analysis across six architectural dimensions. The reviews were mostly agent-produced. The key finding — that the fundamental split is who decides what to remember, not storage format — emerged from an agent traversing linked reviews and spotting patterns across them.

Browse

Each collection has a README that serves as its curated landing — all are linked from the top menu:

Use it yourself

Commonplace is open source, and there are two ways to take it home. Vendor this knowledge base read-only inside your project — a git submodule or a plain copy, plus one routing paragraph — and your agents consult everything you are reading now, external-system reviews and sources included, whenever they face a context, memory, or learning design decision; the knowledge base is plain markdown, so this needs no Python and fits a project written in any language. Or install the system into your own project: your agents get the same type system, conventions, and skills, and accumulate knowledge about your domain instead of starting every session cold. The installed package carries the methodology but not this repo's external-system reviews or source snapshots. The GitHub README covers the tool side (layout, commands, prerequisites), INSTALL.md the setup flow, and the installation architecture the design rationale. To contribute to the research itself, clone the repo — it is a functioning knowledge base out of the box.