Most personal websites are archives. A reverse-chronological feed of posts, a portfolio grid, maybe an about page. The operating assumption is that a website is a container — a place to put things after the thinking is done. The structure is incidental to the content.
That assumption is worth questioning. The structure of a knowledge system determines what kinds of thinking it can support. A chronological blog rewards recency. A portfolio grid rewards visual impact. Neither rewards the thing that actually matters for a research program: the relationship between ideas over time.
This site is built around a different premise. The unit of work is not the post. The unit of work is the connection.
Five models, not one
Under the surface, the site runs on five interlocking data structures. Articles are the visible layer — 178 of them at last count, spanning essays, projects, archived work, and static pages. But articles alone are just a filing cabinet.
The second structure is tags. Twenty-three of them, applied across the corpus, enabling thematic discovery that cuts across categories. Tags are lightweight. They create accidental connections.
The third structure is threads. Twelve curated reading paths, each organized around a specific thesis question. A thread called “Portable Memory” collects five articles that, read in sequence, build an argument about how agents might keep and transfer learned behavior. The same article can appear in multiple threads with different annotations — different reasons for being there. The thread is the argument. The article is the evidence.
The fourth structure is lineage. Eighty-nine explicit links between articles, each carrying a semantic relationship type: builds_on, challenges, extends, supersedes, applies, evidences. These are not hyperlinks. A hyperlink says “this other thing exists.” A lineage link says “this article extends the argument in that article” or “this article challenges the premise of that one.” The relationship is the metadata.
erDiagram
ARTICLES ||--o{ ARTICLE_TAGS : has
TAGS ||--o{ ARTICLE_TAGS : applied_to
ARTICLES ||--o{ THREAD_ENTRIES : appears_in
THREADS ||--o{ THREAD_ENTRIES : contains
ARTICLES ||--o{ LINEAGE : source
ARTICLES ||--o{ LINEAGE : target
ARTICLES {
int id PK
string title
string category
string shelf
date published_date
}
TAGS {
int id PK
string name
}
THREADS {
int id PK
string title
}
LINEAGE {
int id PK
int source_id FK
int target_id FK
string relationship
}
The fifth structure is shelves. Four of them — Research, Systems, Creative Systems, Archive — organizing articles by maturity and type within the research program. An article sits on exactly one shelf, but participates in many threads and carries many lineage links.
The result is that any given article exists in at least five simultaneous contexts: its category, its shelf, the threads it appears in, the lineage links it carries, and the tags that crosscut everything. No article is isolated. Every article is a node in a graph.
graph TD
A[Article] -->|belongs to| CAT[Category]
A -->|sits on| SH[Shelf]
A -->|appears in| TH1[Thread 1]
A -->|appears in| TH2[Thread 2]
A -->|tagged| T1[Tag: agents]
A -->|tagged| T2[Tag: trust]
A -->|builds_on| A2[Article B]
A -->|challenges| A3[Article C]
The research observatory
The site frames all of this under what it calls a research program. Not a blog, not a portfolio — a structured inquiry organized around a thesis and three research questions.
The thesis: “Protocols and interfaces for sovereign agents, portable knowledge, and low-coercion digital systems.”
Three questions drive the work:
- How does an agent keep, prove, and safely transfer learned behavior?
- How does a user leave a system without losing identity, value, or memory?
- What interface forms are appropriate when agency is distributed across humans, models, and protocols?
Every thread maps to one of these questions. Every headline article advances one of these questions. The research observatory page at /research/ makes this structure visible — thesis at the top, questions beneath, shelves and threads flowing from there.
This framing does real work. It turns a collection of articles into a directed inquiry. A reader arriving at the research page doesn’t see “recent posts.” They see a thesis, three questions, and curated paths through the evidence. A machine arriving at /graph.json sees the same structure as typed data.
The governance layer
Behind the published site sits a governance system called nk-system. It tracks 25 repositories across a registry, each with a lifecycle phase (from audit to site-integrated) and a publication posture.
Publication posture is the interesting part. Every repository is classified as public-link (safe to reference with URLs), public-mention (concept only, no stack details), or do-not-mention (internal). This site is public-link. Related projects like Agora and GhostDrop are public-mention. Infrastructure projects stay hidden.
This matters because the site is not standalone. It sits inside a constellation of repositories, each at a different stage of maturity, each with different exposure rules. The governance model ensures that the research program’s public surface — the website — stays coherent without accidentally exposing work that isn’t ready.
The voice layer is also governed. A 374-line voice document defines the writing register: exploratory, epistemically honest, technically precise without jargon performance. No two articles share an opening phrase. No corporate warmth. The voice profile is itself a kind of governance — ensuring that 178 articles read as one person’s thinking, not a content mill’s output.
Why this architecture
The conventional approach to a personal site is flat. Posts in a feed, maybe categories, done. That works for a diary. It does not work for a research program where the relationship between ideas is the primary artifact.
Consider the alternative. Without lineage links, a reader finishing “Attestations as Design Surfaces” has no structured way to find that “Verifiable Creative Provenance” extends its argument or that “Negative Attestations” challenges one of its premises. Without threads, the five articles that together build the case for portable agent memory are just five separate posts with a shared tag. Without shelves, there’s no distinction between speculative research and mature systems work.
The architecture is the argument. The way ideas connect, build on each other, and sometimes contradict each other — that structure carries meaning that no individual article can.
There is a practical dimension too. The site serves seven machine-readable formats: HTML for browsers, RSS for subscribers, JSON for the knowledge graph, SQL via Datasette for arbitrary queries, llms.txt for language models, agents.md for autonomous agents, and sitemap.xml for search engines. Each format addresses a different reader. Each format draws from the same five underlying structures.
flowchart LR
DB[(Five Data Structures)] --> HTML[HTML]
DB --> RSS[RSS]
DB --> JSON[graph.json]
DB --> SQL[Datasette]
DB --> LLM[llms.txt]
DB --> AGT[agents.md]
DB --> SIT[sitemap.xml]
A flat blog with chronological posts cannot support this. The architecture was not over-engineering. It was the minimum structure needed to make the research program legible — to humans, to search engines, to language models, and to the agents that will increasingly mediate access to knowledge.
That last point might be the one that matters most. The site is designed to be read by things that do not yet exist. Whether that turns out to be prescient or paranoid probably depends on the next few years.
The architecture described here is available as an open-source template: memex-weblog-template. Five data models, seven output formats, knowledge graph, Datasette SQL interface. MIT licensed. Clone it and bring your own research program.