Commonplace

Research on knowledge systems, running as one.

Commonplace studies how agentic systems can change after deployment through inspectable knowledge artifacts. It also puts that idea into practice: human-directed agents use and revise the Markdown, instructions, schemas, validators, tests, and code in this repository. When later work loads or enforces those artifacts, accepted changes can shape behavior without updating model weights. The repository makes both the mechanism and its governance visible.

The theory's most immediate target is an LLM wiki, in the sense AI researcher Andrej Karpathy sketched: a persistent, linked Markdown layer that agents build and maintain around a person's or project's work. An agent can turn a vague thought into a committed note, then place it among relevant artifacts. Links help later readers find the note and decide what related material to follow. This turns an ephemeral exchange into inspectable material that can be reused. Agents can help draft, file, connect, and review it; humans direct the inquiry and remain responsible for judgments that the available evidence and review process cannot settle.

That ease creates a maintenance problem. Tags, indexes, and templates become debt when they outlive the questions that justified them. Commonplace therefore keeps shared invariants small and lets each collection's local contract define its task-specific types and link conventions. This design follows two related claims: task-fitted structure costs cross-task reuse, and a framework rule with a boundary-preserving rival is not an inherited constraint.

Commonplace is self-hosting in a limited, bootstrapping sense: its research corpus and parts of its operating machinery live together. kb/ contains theory, procedures, and external evidence; src/commonplace/, schemas, validators, and tests implement the framework. Not every artifact describes Commonplace; some analyze external systems. The narrower claim is that selected artifacts describe or direct the system that consumes them, and that accepted changes can reach later operations through explicit loading or enforcement. Methodology and symbolic machinery need not change in lockstep. When a pattern codifies into a command or check, however, its rationale and enforcement should remain traceable.

The core research thread is deploy-time learning: durable behavior-shaping artifacts can be updated across sessions while a system is deployed. Storing an artifact is not enough; a later consumer must load or enforce it in a way that can affect behavior. Because agents operate under bounded context, they need selective access to task-relevant artifacts rather than universal loading. Even when a change affects behavior, whether it improves performance remains an empirical question. The notes develop this theory and apply it to agent-operated knowledge bases.

Three distinctions keep these claims precise. A methodology is actionable only relative to an operator, available operations, a target, and a setting; here, human-directed LLM agents are among the operators. A system is reflective only where an internal process can use a representation of that same system. Changes in the represented aspects can update the representation, and operations mediated through it can affect later behavior. Reflective coverage asks which representational forms and operations participate; coverage over natural-language and symbolic artifacts does not imply coverage over model weights. Coverage presupposes reflection. None of these properties alone shows that a change improved the system.

Threads worth following

How agents learn. Deploy-time learning names adaptation through changes to durable behavior-shaping artifacts across sessions, a persistent path that needs no model-weight updates. Constraining narrows interpretation; at its far end, stable patterns can be codified as deterministic checks or code. Recognizing shared structure is the expensive step in turning separate cases into candidate explanations that may work beyond the cases that produced them. 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. Evidence directly determines a change in one update architecture. In another, the system searches candidates, evaluates them, and retains an accepted proposal; hybrid pathways combine these functions. Reflection is a separate structural property. It provides addressability, but does not by itself establish improvement or cumulative dependence. The self-improving systems index routes the full cluster, and Commonplace as a reflective system works through a local case.

What makes memory agent-usable. Agent memory needs discoverable, composable, and trusted knowledge under bounded context. Discoverable knowledge can be selected for a task without loading everything. Composable knowledge exposes relationships through explicit link semantics, so readers can follow lines of support, contrast, or consequence. Trusted knowledge offers enough signal—such as rationale, provenance, status, validation, ownership, or review—for an agent to rely on it at the right level of confidence. Whether using that knowledge improves future action is a separate evaluation question for the surrounding memory system.

Information and bounded observers. Information value is observer-relative: the same data can expose extractable structure to one observer and noise to another. Condensing material for a bounded observer can therefore create value. By contrast, reverse-compression expands text without adding extractable structure.

Agent memory systems compared. We reviewed 148 agent memory systems — Mem0, Graphiti, Cognee, Letta, and more — across shared architectural axes. The comparative analysis finds that how systems activate and verify memory distinguishes them more than where they store it. The collection over-samples file-based systems, so its counts describe this corpus rather than the field as a whole.

Browse

Each top-level collection has a curated README, and those landing pages appear in the top menu:

• Notes — the research itself; the tag indexes give finer-grained entry points
• Articles — self-standing technical writing distilled from the knowledge base
• Reference — the shipped system: architecture, type system, CLI, ADRs
• Types — global artifact contracts and their deterministic schemas
• Agent Memory Systems and Agentic Systems — reviews of external systems
• Sources — snapshotted external material with analysis
• Instructions — procedures, skills, and review gates
• Workshops — work currently in flight

Use it yourself

Commonplace is open source. You can use it in two ways.

Vendor this knowledge base read-only inside your project. Add it as a git submodule or plain copy, then give agents a routing instruction that says when and where to consult it. This makes the research, external-system reviews, and sources available; it does not guarantee that agents will activate every relevant item. Because the content is Markdown, reading it requires neither Python nor any particular implementation language.

Install the system into your own project. Your agents get the type system, conventions, and skills for accumulating knowledge about that project's domain. The installed package carries the methodology but not this repository's external-system reviews or source snapshots.

The GitHub README covers the tool side; INSTALL.md gives the setup flow; and the installation architecture explains the design. To contribute to the research itself, clone the repository; it is already a functioning knowledge base.