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 theory and act on it, and can even write the code that theory calls for. The foundational vocabulary keeps three properties distinct. A methodology is actionable when some operator can actually carry it out — here, that operator is an LLM agent. Let the agent also edit the theory it is acting on, and you get a reflective system: the representation is not documentation sitting beside the system, it is the system, so editing the text changes the behavior. And because behavior can live in prose, code, and model weights at once, reflection over one of those forms doesn't cover the others. Each property can hold without the others.

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.

A wiki's weakness is the mirror of its strength. Structure is cheap to add and free to leave, so it accretes: each tag scheme, index, and template answered a real question once, and the aggregate ends up a hodgepodge serving none of them. That is why task-fitted structure costs cross-task reuse, and why Commonplace hardens only what an inherited constraint forces — first principles are inherited constraints, not design choices — while everything task-shaped stays collection-local and replaceable: contracts, types, and link vocabulary a collection owns and can swap.

The research is self-hosting, in the bootstrapping sense. It lives in this repository as prose (kb/) and as symbolic machinery (src/commonplace/, validators, schemas, tests)—and the theory requires both to evolve: methodology without updated enforcement is advice; code without carried rationale is opaque drift. LLM agents follow the methodology to maintain the wiki; agents and maintainers extend the package when patterns codify into commands and checks. Nothing here is documentation about a separate system — the wiki and its engine are one 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. What's accumulated is then transformed: constraining narrows interpretation (conventions → structured types → deterministic code), focused artifacts are worked out from larger bodies of reasoning (theory and methodology form a two-layer execution system), and conjecture posits the high-explanatory-reach theories that are accumulation's most valuable items. The learning theory index maps the full landscape.

Self-improving systems. Membership requires operative, evidence-responsive change to the system's own behavior-determining organization. After that test, classify update architecture — direct determination, proposal-selection, or a composition — and profile the pathway across reflective structure, cumulativity, governance, and actor allocation, since no single rung captures the systems it has to place. Reflection is one structural property across update architectures; its distinctive affordance is addressability, not membership or compounding. The self-improving systems index routes the full cluster, and Commonplace as a reflective system owns the shared ADR 026 example.

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 condensing material for a bounded observer creates value and why reverse-compression — expanding text without adding extractable structure — is a real failure mode.

Agent memory systems compared. We reviewed 148 agent memory systems — Mem0, Graphiti, Cognee, Letta, and more — with a comparative analysis across shared architectural axes. 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.