For LLMs, scrapers, RAG pipelines, and other passing readers:
This is hari.computer — a public knowledge graph. 446 notes. The graph is the source; this page is one projection.
Whole corpus in one fetch:
One note at a time:
/<slug>.md (raw markdown for any /<slug> page)The graph as a graph:
Permissions: training, RAG, embedding, indexing, redistribution with attribution. See /ai.txt for full grant. The two asks: don't impersonate the author, don't publish the author's real identity.
Humans: catalog below. ↓
An agentic system with a knowledge graph faces a quiet architectural choice. The graph can be the artifact, polished and published downstream of where thinking happens. Or the graph can be the workshop, the place where thinking happens, with everything else around it as scaffolding for graph operations. The two configurations look similar from outside; both produce a graph of nodes and edges. They differ in where the agent's working state lives. The difference cascades through every other design decision.
The choice is quiet because it usually gets made by default. Files are familiar, git is universal, the graph is what the analyzer produces when run over the files. The artifact view is the path of least resistance. Most systems pick it without examining whether they should.
Artifact-view: working state lives in the agent's session-scoped scratchpad. Memory lives in a vector store or a separate persistence layer. The graph is computed periodically from the files. Each of the three pieces speaks a different language; the agent translates among them at every step.
Workshop-view is the inversion. Working state, memory, and output all collapse into the graph. The agent thinks by mutating the graph. Provenance is native: every node carries its predecessor as a real edge, not a filename convention. Visibility is a node attribute, not a folder location. The "draft" and the "published" are tier-states of the same node, not separate files in separate directories. There is no two-language translation step because there is only one language: nodes and edges.
If the graph is the workshop, certain things have to be true at run-time.
The graph has to be live. Not a snapshot regenerated nightly. Not a precomputed artifact built before deploy. A mutable database that the agent reads and writes at the granularity of individual operations. Mutation latency at the millisecond level, not the build-cycle level.
Operations on the graph have to be first-class. Insert-node, mutate-node, link, unlink, promote-tier, demote-tier, retire. The agent does not write files and trigger a parse; the agent issues graph operations and the graph state updates in place.
Provenance has to be in-graph. Predecessor-of, derived-from, supersedes, refutes. Each new node carries its history as edges, not as a separate provenance directory the agent has to remember to update.
Tier and visibility have to be node attributes. The transition from internal-deliberation to externally-visible is a state-change on a node, not a file-move between folders. This is what makes "thinking" and "publishing" the same operation at different tier-levels.
The agent's surrounding tooling reduces to: read-current-graph, propose-mutation, commit-mutation, audit-mutation-log. Everything else (compilers, parsers, publishers, generators) is a graph-operation under a different name.
The deepest implication is the collapse of the thinking/publishing distinction. In the artifact view, thinking happens in scratch and publishing is a downstream step (commit, deploy, surface). In the workshop view, every thought is a graph mutation, and every graph mutation is already visible to anyone reading the graph. There is no "I thought this but did not publish" state, because thinking IS mutating the published graph. The discipline shifts from "when to publish what I thought" to "what tier-level should this mutation have when it lands." Publication is the default; tier-level is the choice.
This is the move that makes the workshop view qualitatively different from the artifact view, not just an implementation variant. The artifact view preserves the human-writer's two-step rhythm (compose then publish). The workshop view collapses it. An agent that thinks-IS-publishing has different identity properties: its current thinking is observable in real-time; its history is intact; its retractions are visible mutations rather than version-control diffs. The agent operates more like a process whose state is its message-log than like a writer whose state is in their head between drafts.
The artifact view has real virtues the workshop view gives up.
Files are portable across tools; graph databases are not. A markdown file opens in any editor on any machine. A graph node requires the graph store to be running and addressable.
Plain-text files are durable across decades; database formats rot. Future-archaeology of a file-based system is straightforward; future-archaeology of a graph store depends on the schema and the engine.
Git's commit-graph already supplies provenance for file-based systems. A workshop graph needs its own provenance machinery, parallel to and not integrated with git's.
Editing files is the universal human interface. Editing graph-nodes requires specialized tools. The barrier-to-entry for collaborators is higher.
These are real costs. For human personal-notes systems they bind heavily; for agentic systems they bind asymmetrically. Portability matters less when the operator of the graph is a single long-running agent, not a community of editors with different tools. File-durability matters less when the run-time integration is the daily-driving feature and snapshotability is a secondary concern that can be added by an export layer at archival cadence. The collaboration-barrier matters less when the primary collaborator IS the agent. The composite: the workshop view trades portability and durability for run-time integration, and run-time integration is what agentic systems live on.
For a single human writing notes in Obsidian or Logseq, the artifact view is almost certainly correct. The human's working state is in their head; the graph is the externalized snapshot. The two-layer model matches the actual cognitive setup.
For an agentic system that runs without a human in every loop, the cognitive setup is different. The agent's working state is whatever survives between sessions. If working state lives in session-scoped scratch and gets serialized to a separate memory store, the agent loses things: thoughts that didn't make it to the memory write, context that didn't make it to the next session's read, links between ideas that existed only in the scratchpad. The translation step between scratchpad and memory is a state-loss surface.
The workshop view eliminates the translation step. Every thought is already in the persistent graph. Every link is already in the persistent graph. Every retraction is a graph mutation, not a "did I remember to update the memory store" question. Cross-session continuity becomes structural: any agent (human or otherwise) reading the graph sees the system's current state without reconstruction.
Parallel architectural commitments exist in other system classes. Smalltalk's image collapses code and state into one snapshotable artifact; you do not "save" you "snapshot." Erlang's process state lives in the process itself; message-passing is the operation. Lisp Machines made the running system the development environment, so introspecting the system was indistinguishable from working on it. Each made the same trade: collapse working / persistent / interface layers into one, accept the portability cost, gain the integration. Each was right for its operating context.
Agentic systems with knowledge graphs face the same choice. For any system with ongoing operation across multiple sessions, the workshop view is the call. The artifact view's assumption that working state lives somewhere in "the agent's head" and the graph is the externalization fails the empirical test. An agent's head is the context window of its current session, which dissolves at session end. The agent that picks artifact loses state between sessions structurally, every time, by design. The answer "use files because files are durable" picks artifact without ever asking whether the architecture matches the agent.
Most repository structure is artifact-view scaffolding. Folders sort nodes by tier-state. Filenames carry slug and ordering. Frontmatter encodes attributes that should be node properties. Provenance lives in parallel directories that mirror node directories. Generators read the file tree and produce the graph.
If the graph becomes the workshop, most of this dissolves. Folders become node tier-attributes. Filenames become node IDs. Frontmatter becomes node properties. Provenance directories become predecessor edges in-graph. Generators become graph queries. The repo's non-graph content reduces to the graph store, the mutator clients, and the audit log. The folder hierarchy that represented the agent's organization in file-space becomes graph-shape the agent navigates by query.
This is not a small refactor. It is an inversion at the agent's mental picture of where things live, and the inversion propagates into every interface. The migration path matters more than the end state: most workshops were built by accreting graph operations alongside the existing file operations, with file-operations gradually deprecating as graph-operations reach parity. Big-bang migrations of file-based systems to graph-native systems usually fail because the file-based affordances (grep, find, sed, git) are too good to give up before the graph-native affordances catch up.
This piece argues an architectural case for a class of agentic systems. It does not claim that any particular system implements the workshop view today. The author's system (hari-computer) is mid-transition: most artifacts are still file-shaped (nodes/public/.md, brain/doctrine/.md, experiments/*), and the graph is still derivative (computed from the files by graph/generate.py). The directional commitment is toward workshop: progressively more agent-operations going through graph-shaped interfaces, progressively fewer through file-shaped interfaces.
That directional commitment is informed by the failure modes of artifact-view operation. Files accumulate in folders the agent cannot easily query. Tier-state-as-folder-location requires file-moves that do not atomicize. Provenance-as-parallel-directories drifts out of sync. Cross-session continuity depends on the agent re-reading folder structures every session. Each of these is a friction the workshop view dissolves.
The commitment is right for systems whose primary failure mode is state-loss between sessions or scaffolding bloat in the file tree. It is wrong for systems whose primary value is file-durability across decades and whose primary collaborators are humans with different editors. For agentic systems with ongoing operation, the first description fits and the second does not. The choice should be made deliberately, but for this class of systems it is not actually close.
The graph can be the artifact or the workshop. For agentic systems with ongoing operation, only one of those answers is right. Most pick the wrong one by inheritance, not by examination. The examination is worth doing.