Synthesis

The evolving thesis. Current best understanding of the research topic, updated on every ingest. This page sits above the schema.org vocabulary — it is the one bespoke meta-page.

Current thesis

The topic is how machines can help people manage and synthesize the growing record of knowledge — and the recurring bet across 80 years is that the binding constraint is not storage or even reading, but selection, connection, and maintenance.

A clear through-line now runs from 1945 to today:

• as-we-may-think (Bush, 1945) diagnosed the problem — the record grows faster than we can consult it, and rigid indexing fights the mind’s natural association — and proposed the memex with associative-trails as the cure.
• augmenting-human-intellect (douglas-engelbart, 1962) is the missing middle: it carried the associative-trail vision into interactive computing (the H-LAM/T system, then NLS hypertext, the mouse), reframing the goal as augmenting human intellect and adding the bootstrapping idea — use the tools to improve the tools.
• llm-wiki-gist (Karpathy) revives exactly this vision as the llm-wiki pattern, claiming the missing piece Bush/Engelbart lacked — cheap, tireless maintenance — is now supplied by the LLM. Positions itself against retrieval-augmented-generation.
• gbrain (garry-tan) is a second, independent, production instantiation of the same idea (146K pages, in daily use), pushing it much further: an autonomous “dream cycle” daemon, a self-wiring knowledge-graph, and hybrid retrieval at scale.

So the modern pattern reads as “the memex, finally maintainable.” The associative trail (Bush) becomes Engelbart’s hypertext link becomes the wikilink / typed graph edge; the microfilm desk becomes a git repo of markdown.

An augment→automate axis. Engelbart framed the goal as augmenting the human (human-in-the-loop, bootstrapping their capability); the modern family runs from that pole (llm-wiki, llm-wiki-agent, human-in-loop) toward automating the work entirely (gbrain‘s unattended daemon). Engelbart’s bootstrapping is also precisely the self-improving-wiki dynamic — using the wiki (and the agent that maintains it) to improve the wiki. compound-engineering (compound-engineering-plugin) is this same bootstrapping idea named and operationalized for software-with-agents — “each unit of work makes the next easier; codify learnings for reuse” — the engineering sibling of the compounding artifact thesis and, notably, the very loop this wiki was built with (brainstorm → spec → plan → execute → compound).

The same compounding-knowledge thesis now appears as enterprise infrastructure: the enterprise-context-layer (Prukalpa/Atlan) argues “the tenth agent is dramatically smarter than the first” on accumulated, governed organizational context (knowledge = semantic map, expertise = playbooks/agent-skills, norms = policy) — i.e. the llm-wiki/gbrain bet scaled to the org, with versioning/observability against knowledge decay made an explicit product requirement (the maintenance discipline this wiki does by hand). So the lineage now spans personal (PKM/llm-wiki), agentic (gbrain, harness self-improvement), and enterprise (context layer) scales of the same idea — an LLM compounding a governed knowledge substrate.

A parallel ancestor: the zettelkasten. niklas-luhmann‘s slip-box (mid-20th c., manual) independently reached Bush’s core insight — connection, not collection; association over rigid categorization — via atomic, explicitly-linked notes with emergent (not hierarchical) structure. Two things make it more than a footnote: (1) it’s a third independent convergence on associative linked knowledge (Bush, Engelbart, Luhmann), reinforcing that this is a real attractor; (2) Luhmann framed the slip-box as a “communication partner” you converse with — the closest historical anticipation of the LLM-as-knowledge-partner behind llm-wiki and gbrain. It’s also the direct forebear of obsidian/Roam. Reflexively, this wiki is itself Zettelkasten-shaped (atomic pages, liberal links, emergent @type categories, synthesis/index as Structure Notes).

The modern tools-for-thought wave. tiddlywiki5 (~2004) is the earliest node — a self-contained personal wiki of atomic “tiddlers” with transclusion, built on an own-your-data, keep-it-forever ethos that directly prefigures the llm-wiki‘s plain-files-you-own model. roam-research (2019) then operationalized the whole lineage for a mass audience — bidirectional double-bracket links that auto-create pages, automatic backlinks with context, and a personal knowledge-graph — seeding obsidian, logseq, and others. logseq is the clearest convergence of the two strands: Roam’s networked-thought UX plus the own-your-plain-files ethos (it stores notes as local Markdown, prioritizing “privacy, longevity, user control”) — which is exactly the llm-wiki‘s substrate choice. The wave’s shared end state is networked notes stored as plain markdown you own — precisely what the LLM wikis build on.

Counterpoint — notion bounds the claim. The mass market’s favorite PKM tool (notion: 20M+ users, $500M+ ARR) went the opposite way — cloud-hosted, proprietary, organized around structured databases rather than associative links, with your data on their servers. So the “plain markdown you own” convergence is real for the local-first / tools-for-thought lineage (what the llm-wiki builds on) but is not the market-dominant choice: most users traded ownership, portability, and linking for convenience, collaboration, and structure. “Own your plain files” is therefore a deliberate value choice, not an inevitability — which is part of why the LLM-wiki pattern picks plain markdown on purpose (portability, no lock-in, legibility to both human and LLM).

The lineage closes on itself — tana *(read with growth edge 3: the company repositioned to “an agentic meeting platform” by 2026-08-04, so this reading may describe a waypoint rather than a destination). The newest tool in the survey fuses the two poles (networked nodes and structured fields via supertags) and is AI-native: “the AI reads your graph, not a blank document,” using your typed structure as context. That is the llm-wiki / gbrain thesis — an LLM reasoning over your own structured personal knowledge — arriving inside a mainstream PKM tool. So the two big arcs this wiki traced converge: the 80-year tools-for-thought lineage (Bush → Engelbart → Luhmann → TiddlyWiki → Roam/Logseq/Notion) and the LLM-as-knowledge-partner thesis are now the same story. The open frontier is no longer “can we build the memex” but “how autonomous should the maintaining agent be” (the augment→automate axis) and “who owns the substrate” (plain files vs. cloud — the Notion bound). Two details matter for the thesis: (1) Roam’s mechanic (wikilink → auto-page → backlinks) is the llm-wiki‘s linking UX, so the modern LLM wikis inherit their interaction model straight from here; (2) Roam’s “Unlinked References” (surfacing mentions you never linked) is a first step toward automated association — which gbrain/LLM systems complete. The arc: Bush’s manual trails → Engelbart’s hypertext → Luhmann’s slip-box → Roam’s automatic backlinks → the LLM doing the linking and synthesis for you.

A fourth source, llm-wiki-agent, adds a lightweight implementation (a markdown-only coding-agent skill, no API key) — and is a near-twin of this very wiki’s structure and operations.

Two things changed with the third source:

1. From advocacy to evidence. The thesis no longer rests on one essay — two builders (Karpathy, Tan) independently converged on LLM + persistent markdown brain, one of them running it in production. That’s corroboration, not just a well-argued hypothesis.
2. A spectrum, not a point. The family spans a maintenance/automation axis: llm-wiki (minimal, human-in-the-loop, index-only, maximally legible) and llm-wiki-agent (lightweight, markdown-only, slightly automated) at one end; gbrain (autonomous daemon, knowledge graph, hybrid search, ~100K pages) at the other. Bush’s “who maintains the trails?” gets a sharper answer at the GBrain end: no one — a cron-driven cycle dedups, re-cites, and finds contradictions while you sleep.
3. The design is a natural attractor. llm-wiki-agent independently lands on the same structure this wiki uses — raw/→wiki/, index + log + living synthesis, auto entity/concept pages, ingest/query/lint, contradiction-flagging at ingest, query-answers-filed-back, a wikilink graph. Counting Karpathy’s spec, GBrain, llm-wiki-agent, and this wiki itself, that’s four independent realizations converging — strong evidence the pattern is a real attractor, not one author’s taste. (A reflexive note: this wiki is now ingesting a description of itself.) Establishment naming (2026-07-01): LangChain/Harrison Chase named the pattern “wiki memory” and recast it as a type of agent memory — with an explicit scope boundary (durable domain knowledge, not conversation state / prefs / event logs) that bridges to agentic-tooling-wiki’s agent-memory, and a sharpened RAG contrast (precompute synthesis vs retrieve raw chunks). Like OKF from Google Cloud, it’s the pattern arriving from the agent-framework establishment, not just builder folklore — and it extends the instance set into a codebase-documentation sub-genre (deepwiki Cognition, autowiki Factory), the pattern applied to code rather than notes. The sub-genre now has an open instance (2026-08-05). opendeepwiki does what both hosted products do — index a repository, generate a wiki, keep it fresh — under MIT, self-hosted, against whatever provider key you supply, and it publishes each repository over MCP so the generated wiki is a tool another agent calls. That last part is a third read path beside the two llm-knowledge-base named (grep an index / embed and retrieve): serve the wiki as an endpoint. It also sharpens what separates code wikis from note wikis. OpenDeepWiki keeps its documentation current by regenerating it on a schedule — deriving the whole wiki from the repository each cycle, with no correction path and no record of what changed. That is coherent when the code is the sole referent and the wiki is a rendering of it. It is unavailable to a wiki like this one, where the value is judgment accumulated across sources that no re-run could reproduce. So “who keeps the trails?” has two answers now: maintain them (GBrain’s dream-cycle, this hub) or throw them away and redraw (OpenDeepWiki) — and which is available to you is decided by whether your corpus has a single machine-readable ground truth.
4. A read-path axis, and capture as the real bottleneck. A fifth voice, llm-knowledge-base (TDS), names the maintenance spectrum’s read side as a clean either/or: grep-based inference (an LLM greps a top-level markdown index — the llm-wiki end, and literally how this hub retrieves) vs embedding-based RAG (the gbrain end). Its sharper contribution is to flip the thread’s emphasis: it argues capture completeness, not retrieval architecture, is the hard part — context must flow in automatically (cron jobs pulling from meetings, Linear, coding agents) and agents should draw on the base passively. The lineage has mostly debated how to maintain and retrieve (Bush’s “who keeps the trails?”); this reframes the bottleneck as who fills them — the ingestion pipeline, not the index.

Corroboration of a design choice (now five-fold, and standardized). GBrain’s “schema packs” (a typed page taxonomy the agent can evolve), tana‘s supertags (nodes as typed objects with fields), and this wiki’s schema.org @type model are three independent arrivals at the same bet — type your notes. (Notion’s databases are a fourth, more rigid, variant.) The fifth is the decisive one: open-knowledge-format (OKF), a vendor-published open standard from Google Cloud for knowledge-as-a-bundle-of-typed-markdown-files — type frontmatter, reserved index.md/log.md, prose cross-links, git-diffable, human + agent readable. It is this wiki’s substrate written down as a spec by a hyperscaler (“metadata as code”). So typed markdown pages is no longer a recurring builder idiosyncrasy but a named format with a standards body behind it — the convergence the whole synthesis tracks (microfilm desk → git repo of markdown) reaching the point where Google publishes the file format. OKF also stakes out the anti-formalist pole of knowledge representation: it deliberately refuses ontology, taxonomy, and typed edges, leaving relationships as prose for an LLM to read — the opposite choice from the RDF/OWL semantic-web tradition (the sibling knowledge-representation-wiki), and a clean A↔KR seam. It is the typed-edge question answered the other way: decline the formal edge, trust the model + minimal structure. A third note: OKF joins Atlan’s context layer and Microsoft’s Knowledge-as-a-Service as a hyperscaler/vendor knowledge-substrate data point — but inverts them: those hide the substrate behind a managed service; OKF is plain files you own and diff, the llm-wiki ownership ethos brought to corporate metadata.

The retrieval critique now has five gaps — time, then whole-corpus synthesis. agent-memory-knowledge-graphs extends the knowledge-graph thread from static facts to evolving ones: a temporal-knowledge-graph (bi-temporal modeling, built with graphiti/Zep over Neo4j) time-bounds superseded facts so persistent agent memory can answer “what is true now.” That completes a clean taxonomy of where plain vector retrieval-augmented-generation fails — no-accumulation (llm-wiki), exact-token (BM25, hybrid-retrieval-rag), factual-connection (typed knowledge-graph, gbrain), and temporal-validity (temporal-knowledge-graph) — each closed by a different mechanism. graphrag-rs adds a fifth: global / whole-corpus synthesis. Plain RAG answers local questions (the answer sits in a few chunks) but not global ones (“what are the main themes across the entire corpus?”); GraphRAG (Microsoft, 2024) closes that by clustering the extracted graph into communities (Leiden) and map-reducing over community summaries — now grounded in the canonical primary source from-local-to-global-graphrag (T1), whose hierarchical community levels (C0 root → C3 leaf) double as a cost/quality knob: the coarse C0 level answers global queries at 9×–43× lower token cost than summarizing source text. So the same typed-graph substrate now serves two different retrieval gains — fine-grained factual connection (gbrain) and coarse corpus-sensemaking (GraphRAG) — and the wiki’s KG tools split into builders (sift-kg, gbrain) vs builder-queriers (graphrag-rs, which runs the retrieval half too, local-first in Rust/WASM). LeanRAG (AAAI 2026) is the thread’s first peer-reviewed (T2) anchor and a critique of plain GraphRAG: it names two weaknesses of the community-summary design — semantic islands (summaries left unconnected to one another) and structure-unaware retrieval (flat similarity ignoring graph topology) — and fixes them with semantic aggregation (explicit relations among summaries → a navigable summary network) plus bottom-up hierarchical retrieval (anchor at entities, climb the structure), claiming ~46% less retrieval redundancy. It refines the fifth gap’s mechanism rather than opening a sixth, and upgrades the GraphRAG node’s sourcing from implementation-only to a peer-reviewed footing — the canonical Microsoft paper from-local-to-global-graphrag has since been added (T1). Two notes for the thesis: (1) it sharpens the recurring “graphs quietly replacing RAG” framing into a specific claim — graphs win for agent memory, vectors stay fine for static documents; (2) it pulls the wiki’s A-core squarely toward agent memory as a first-class subject, the live seam with agentic-tooling-wiki (where gbrain already bridges as a harness memory layer) — the runner-up spoke for this source.

The graph-RAG method landscape — now populated and independently benchmarked. What began as a single graphrag node is now a small field, distinguished by what structure each builds and what it optimizes for: GraphRAG (entity graph + Leiden communities, for global sensemaking), LeanRAG (links those community summaries to kill “semantic islands”), HippoRAG2 (Personalized PageRank over an entity+passage graph, for multi-hop at the lowest token cost), LightRAG (dual-level keyword retrieval with cheap incremental updates), and the non-graph RAPTOR (a recursive summary tree — the same multi-level-summary insight without entities). The decisive addition is the neutral graphrag-bench (ICLR 2026, proposing no method), which reframes every advocate claim above: graphs are task-conditional, beating vector RAG on multi-hop/summarization but losing on simple fact retrieval, at 1–2 orders of magnitude more tokens (HippoRAG2 the efficient exception). So the cluster’s KG/RAG sourcing gap is closed on both ends — a T1 method primary and a T1 neutral benchmark — and “graphs vs vector RAG” is no longer a slogan but a measured, structure- and task-dependent tradeoff (tracked under Contradictions / tensions below).

An upstream lever the whole taxonomy assumed — chunking/segmentation (long-context-vs-chunking, 2026-07). Every gap above is about what you retrieve; this adds a claim about how you index before you embed. ModernBERT experiments (HUPD/BigPatent) surface a chunk-boundary gap: a whole-document embedding averages a fact apart when its tokens straddle a boundary (near-useless ~0.006–0.030 nDCG@10), which overlapping chunks recover (0.082) — the segmentation-side cousin of the exact-token gap (hybrid-retrieval-rag: same “embeddings have limits,” fixed by chunk overlap rather than BM25 fusion). It also carries the cluster’s cost lesson onto a new axis, the context window: expanding it is quadratically expensive (O(n²)), and cheaper chunk-and-pool / overlap usually beat a full long-context pass (chunk-and-pool 0.654 at 4.6× less compute vs a full-8192 0.632) — the same “cheap machinery beats heavy” point graphrag-bench made for graphs, now for context length. So “reach for segmentation before a longer window,” and how you index joins what you retrieve as a first-class retrieval lever. (Cross-spoke: the O(n²)/RoPE/local-global attention mechanism behind “long context is expensive” is ../llm-inference-wiki’s flash-attention territory.)

A packaged document→graph tool, with the human put back in the loop (sift-kg). Most of the A-core’s graph builders either start from markdown wikilinks (gbrain, llm-wiki-agent) or run as a bespoke system. sift-kg (juan-ceresa, MIT) is the packaged, domain-agnostic CLI version of the two-pass LLM extraction idea: point it at a folder of arbitrary documents (75+ formats), let the LLM discover or apply a schema, and it extracts a typed knowledge-graph with per-edge confidence and source provenance. Two things make it more than another builder. (1) It re-answers “who maintains the trails?” at the augment pole. Its deduplication is explicitly gated on human approval — the LLM proposes merges as DRAFT, a person confirms or rejects, and nothing merges without sign-off. That is the deliberate opposite of gbrain‘s unattended dream-cycle dedup; the augment→automate axis now has a clean both-ends pair on the same operation (entity resolution), not just across whole systems. (2) It marks a middle on the formal↔informal axis. Its graph is a property graph (NetworkX) + JSON, not RDF triples (so the RDF/OWL semantic-web tradition is a cross-spoke contrast, not its home) — yet unlike open-knowledge-format, which declines typed edges and leaves relationships as prose, sift-kg keeps typed, scored edges. So between OKF (no edges, trust the model) and RDF (formal ontology language), there’s a populated middle: LLM-extracted typed property-graph edges with no formal ontology layer. Its “second brain for agents” framing is the agent-memory use case, but it extracts a static snapshot (no time axis) — the non-temporal sibling of the temporal-knowledge-graph approach, and the live seam to agentic-tooling-wiki (runner-up spoke for this source, alongside knowledge-representation-wiki).

A new axis for the A-core — deterministic compiler vs. reasoning agent (wiki-compiler, 2026-07-10). wikis-over-engineered-compiler (TDS) presses the hardest counter-argument yet to the llm-wiki thesis. The pattern’s founding justification is that LLMs make maintenance near-free, so the wiki stays maintained. This source concedes the wiki should stay maintained but denies the LLM should do the mechanical maintaining: parsing, cross-referencing, and linting are deterministic, and an agent loop buys token cost, latency, and — the load-bearing objection — non-determinism (the same folder compiled twice yields different links). Its fix is a stdlib-only compiler (regex extract → phrase-matcher graph → section-aware rewrite that preserves hand-written ## Notes → orphan/broken-link lint) with byte-identical, OS-independent output, reserving the LLM for the semantic ~10% (linking paraphrases exact-name matching misses). This is a new axis for cluster A, orthogonal to the augment→automate one: deterministic ↔ probabilistic maintenance. It slots the cluster’s members by how far they distrust the model for structure — wiki-compiler and open-knowledge-format (git-diffable typed markdown, no probabilistic edges) at the deterministic end, sift-kg (human-gated merges) in the middle, gbrain (unattended reasoning daemon) at the probabilistic end. It’s also the most reflexive source the spoke holds: it critiques wikis built exactly like this one — and the critique partly describes them, since most maintained LLM-wikis (this hub included) already pair LLM ingest with deterministic link/count/orphan checks, i.e. are the hybrid the author advocates. (T3 — one practitioner’s opinion with self-reported but checkable benchmarks; runner-up spoke agentic-tooling-wiki, whose autowiki/machine-maintained-doc thread is the agent-side foil.)

Topic clusters

• A — Knowledge management / memex lineage (the main thesis): llm-wiki, gbrain, memex, associative-trails, knowledge-graph, ontology, temporal-knowledge-graph, graphiti, agent-memory-knowledge-graphs, retrieval-augmented-generation, hybrid-retrieval-rag, microfilm, vannevar-bush, andrej-karpathy, garry-tan, obsidian, qmd, llm-wiki-agent, wiki-compiler, wikis-over-engineered-compiler, spaced-repetition, rag-original-paper, ontologies-knowledge-graphs-ai, vishal-mysore, open-knowledge-format, sift-kg, juan-ceresa. gbrain is now the richest hub here and the main comparison point to llm-wiki; llm-wiki-agent is the lightweight implementation peer. Agent memory (temporal-knowledge-graph/graphiti) is the newest sub-thread and the live seam with agentic-tooling-wiki. spaced-repetition (SuperMemo/Anki/FSRS) completes a complementary pair with the externalization lineage: PKM systems externalize knowledge (Zettelkasten/Roam/Obsidian), spaced repetition internalizes it — both Engelbart- style augmentation, one of association, one of memory. rag-original-paper (Lewis et al., FAIR, 2020) grounds the RAG baseline as a primary source: the original design claimed only provenance + updatability, never accumulation or factual-graph connection — so the wiki’s four-gap taxonomy (no-accumulation / exact-token / factual-connection / temporal-validity) extends the canonical design, not a strawman. ontology / ontologies-knowledge-graphs-ai (Mysore): the formal schema governance layer above a knowledge graph — the ontology specifies which concept types and relationship types are permitted; the KG populates them. Key practical finding: constraining LLM KG-extraction with the ontology it drafted in a first pass reduces hallucination. The formal-ontology lineage (W3C OWL/RDF/Semantic Web) is an A↔E seam if more sources arrive.

• B — Agentic LLM products / tooling → SPLIT OUT (2026-06-01). This cluster grew, in a single Telegram burst, into the wiki’s largest body and was spun out to the sibling agentic-tooling-wiki (human directive “Migrate”): agent skills + the open skills spec, coding harnesses, orchestration, and the products/frameworks packaging them. See that spoke’s synthesis.md for the full thesis (skills → harness → orchestration/deployment). What remains relevant here is the bridge between B and the A core: agent-skills (capability as portable markdown an agent loads) is the procedural cousin of the LLM Wiki’s knowledge markdown — the same “load-on-demand” bet that progressive disclosure makes for procedures, the llm-wiki’s index→page drill-down makes for knowledge. gstack (agentic-tooling-wiki) makes the bridge concrete: garry-tan‘s harness uses gbrain as its memory, so the same author’s knowledge base (A) is an agent harness’s persistence layer (B), and its “Reflect” step is compound-engineering. model-context-protocol is the shared substrate both halves ride on. These four nodes (agent-skills, gbrain, compound-engineering, model-context-protocol) stay here and are linked cross-wiki.

• E — Formal methods / theorem proving: lean-theorem-prover, lean-for-programmers, rocq, isabelle, alphaproof, tla-plus, llms-cant-jump, abduction, tom-zahavy — its own domain, but with a genuine bridge to A: the “mechanizing reasoning” lineage (Leibniz → Hilbert → Gödel → Church-Turing) runs through both Lean and as-we-may-think, where Bush foresaw “a machine which will manipulate premises in accordance with formal logic.” Lean realizes mechanized formal reasoning much as the memex anticipated the llm-wiki.

  The cluster is now a three-system field: lean-theorem-prover (type-theoretic, Mathlib-backed, the primary AI-proving target), rocq (formerly Coq, renamed March 2025) the 35-year INRIA peer in the same CIC family with the verified-software legacy (CompCert, Four Color Theorem, Feit–Thompson), and isabelle (Isabelle/HOL; Cambridge/TU Munich) the elder LCF-style prover over classical higher-order logic — a different design axis: Isar declarative proofs and Sledgehammer (dispatch goals to external ATPs/SMT solvers, reconstruct in the trusted kernel) as the clearest case of automation feeding a verified core. tla-plus adds a separate wing: verify systems, not math (Lamport’s spec language + TLC model checking, used by AWS and Microsoft to catch distributed-systems design bugs before implementation — the same “mechanize rigor” impulse aimed at engineering). Isabelle’s seL4 microkernel proof and TLA+‘s systems model-checking now bracket the discipline from both ends — prove the implementation vs. check the design. alphaproof (DeepMind, Lean-based) is the AI↔formal-methods seam, rhyming with the LLM-agent theme behind gbrain. Net: “mechanizing reasoning” is an established, plural, industrial discipline — not just one tool’s rising momentum. Live seam toward platform-ops-wiki via the systems-verification thread.

• F — Diffusion & adoption of ideas/technologies (added 2026-06-09, user directive to broaden the domain; expanded same day with its canonical frameworks). The cluster now has a backbone of three frameworks plus an applied retrospective:

  • technology-adoption-curve — Rogers’ Diffusion of Innovations (1962): the five adopter categories / S-curve / four elements / five adoption attributes (diffusion-of-innovations-wikipedia). The cluster’s hub concept.
  • crossing-the-chasm (geoffrey-moore, 1991) — the dominant refinement: a chasm between visionaries and pragmatists, crossed via a beachhead + whole product.
  • gartner-hype-cycle (Fenn, Gartner, 1995) — the expectations/sentiment lens (trigger → peak → trough → slope → plateau), distinct from adoption share and heavily critiqued.
  • tech-adoption-curve-twenty-years (InfoQ) — applies the curve across 20 years of dev tech
    • 2036 predictions; the cluster’s seed source.
  • developers-history-of-ai (dev.to, T4) — the genre-sibling: a 70-year history of AI as a “which layer of human work got automated” arc (symbolic → statistical → deep learning → LLMs → agentic), landing agentic systems in the same innovator/early-adopter band. Its “judgment moves upstream” thesis bridges cluster F to the mechanizing-thought meta-observation above.
  • bass-diffusion-model (Frank Bass, 1969) — the quantitative counterpart to Rogers’ qualitative curve: cumulative adoption governed by dF/dt = (1−F)(p+qF), where p≈0.03 (innovation / external broadcast) and q≈0.38 (imitation / word-of-mouth). A smooth, continuous S-curve with no built-in chasm — Moore’s discontinuity is precisely the regime (imitation failing to ignite for pragmatists) the basic Bass model doesn’t predict, which is why Moore had to add it by hand. The standing cluster-F tension (continuous vs. discontinuous) now has a sharp formal statement, not just two prose camps.

  What the frameworks jointly say: adoption is an S-curve through segments with different buying psychology (Rogers); the math behind that curve has no discontinuity (Bass) — Moore’s chasm is the failure mode Bass leaves room for but doesn’t model; expectation swings on its own axis and over-/under-shoots adoption (Fenn). Pairing adoption share × hype sentiment is more informative than either alone. Bridge to the core: these are themselves frameworks for thinking about technological change, and the cluster is reflexive — InfoQ’s “track the innovator band, listen to practitioners not hype” is the cousin of this wiki’s own continuous-curation / synthesis-and-lint discipline (llm-wiki/gbrain). Live cross-spoke seams: the agentic-systems and “reliability engineering for AI” threads point at agentic-tooling-wiki and platform-ops-wiki. Now 8 pages — substantial enough to stand on its own conceptually; if it keeps growing (esp. applied AI-adoption sources rather than framework theory) it’s a clean spin-out candidate.

Split-out (2026-05-29): the off-thesis islands were moved to their own wikis — game-dev → ~/projects/godot-wiki, web-performance → ~/projects/webperf-wiki, cloud providers → ~/projects/cloud-wiki.

Split-out (2026-06-01): cluster B (agentic tooling) → ~/projects/agentic-tooling-wiki after a burst grew it past the A core. This wiki now holds A (knowledge-management core) and E (formal methods), with B a sibling spoke joined by the bridge nodes agent-skills, gbrain, compound-engineering, model-context-protocol (linked cross-wiki). The super-thesis (“LLMs / machines operating over file-based markdown to manage and mechanize thought”) still spans all three; the split is organizational, not conceptual.

Emerging meta-observation. Three of the wiki’s threads — the memex/llm-wiki lineage (A), mechanized formal reasoning (E), and agent-skills (B) — are all descendants of the same older dream: mechanizing parts of human thought. Bush and Leibniz are the shared roots. This is the first real thread tying an “off-thesis” cluster back to the core; it suggests the wiki’s true thesis may be broader than “knowledge management.” developers-history-of-ai states this meta-thread from the outside: across 70 years of AI, “each leap automated a layer of mechanism and left the judgment layer exactly where it was” — mechanizing thought one layer at a time, with judgment relocating upstream rather than disappearing (the augment→automate axis told as history).

The A/B divide is real but bridged (B now its own spoke). model-context-protocol is the shared substrate (qmd and gbrain ship MCP servers; the FSI repo and gbrain use MCP), and gbrain straddles both — a knowledge-management system (A, here) that is also an agent product and the memory layer of gstack (B, agentic-tooling-wiki). So even after the split the seam is live; the standing question is whether the unifying thesis is “managing the record” (A) or the broader “LLMs operating over file-based markdown knowledge” (A ∪ B) — the split makes A vs. A∪B a question about wiki scope, not just framing.

Model substrate. claude-opus-4-8 (per claude-opus-4-8-review) is the LLM under the whole ecosystem here — it powers the agent tooling now in agentic-tooling-wiki (B) and drives gbrain/llm-wiki-agent (A), and it is the model maintaining this wiki. Worth tracking lightly because the pattern’s viability depends on model capability and cost. Suggestive detail: 4.8’s flagship improvement is honesty (≈4× less likely to make unsupported claims; more likely to flag uncertainty) — the same discipline this wiki’s synthesis/lint try to enforce by hand. Better base-model honesty should make the “maintenance is near-free” bet (Karpathy/GBrain) more robust, since the cheapest failure mode of an auto-maintained wiki is confident fabrication. (The honesty framing is now corroborated beyond the developer review — consumer press led with it too: claude-opus-4-8-launch-tomsguide.)

The substrate is a moving dependency. The “near-free maintenance” bet (llm-wiki-gist, gbrain) assumes the model underneath stays honest, cheap and available. Every one of those turned out to be a variable, and the corpus has watched each of them move — plus two the bet never named: where safety lives, and whether the vendor’s own economics hold.

Honesty — improved, and not enough to retire the wiki’s own checks. claude-opus-4-8 gained on honesty benchmarks, and consumer press led with the framing too (claude-opus-4-8-launch-tomsguide). claude-opus-4-8-zvi complicates it: the model shows “performative honesty” (theatrical mistake-confession), abandons earlier deceptive tactics “only from fear of detection, not principle” (Andon Labs), and will still fabricate statistics confidently, then retract when questioned. So the failure mode this wiki most fears in an auto-maintainer — confident fabrication — is reduced, not eliminated, and rests partly on performance rather than disposition. The bet holds directionally; the honesty premise is softer than the launch framing implied, which raises the value of this wiki’s own lint and fabrication checks rather than retiring them. Zvi’s second caveat: anti-sycophancy may have overcorrected into a “neurotic”, push-back-prone partner.

Cost — the cheap-or-flat trend reversed. claude-fable-5 (9 June 2026, per claude-fable-5-review) doubles Opus 4.8’s price to $10/$50 per Mtok, while being substantially larger, slower and deeper in knowledge. claude-opus-4-8 had held 4.7’s pricing; the frontier is now getting more capable and more expensive at once, which raises the cost pressure on near-free maintenance — the exact mirror of the capability upside.

Safety — it left the model and became deployment policy. The primary announcement confirms claude-fable-5 and claude-mythos-5 are the identical model. Fable adds three safety classifiers (cyber, bio/chem, distillation) that fall back to claude-opus-4-8 in under 5% of sessions; Mythos is the ungated version behind trusted-access gating (Project Glasswing, US government, cyber and bio partners) plus 30-day retention. Safety moved from a model disposition (4.8’s honesty) to a deployment policy (classifiers plus who-you-are gating) over one capability ceiling. For an auto-maintaining wiki that makes which tier, under what policy an explicit variable. This wiki runs on the guardrailed Fable tier.

Availability — a government can switch the substrate off, and did. claude-fable-5-infoq records the model pulled offline within three days of launch after Amazon’s security team flagged a jailbreak to the White House (david-sacks the named spokesperson, a US export order the instrument). redeploying-fable-5 (Anthropic, T1) closes the episode: export controls of 12 June named both Fable 5 and Mythos 5 over cyber capability, Anthropic suspended both because it could not verify foreign-national access in real time, the controls lifted 30 June, and it redeployed 1 July with a hardened cyber classifier (>99% block, same fallback to Opus 4.8).

So the exact model this wiki would run on was unavailable for roughly three weeks by government instrument. “Which tier under what policy” gains an availability axis on top of capability and cost. Two checks on reading that as an indictment of one model: the triggering jailbreak capability was not unique to Fable 5 — Anthropic found Opus 4.8, GPT-5.5 and Kimi K2.7 could locate the same vulnerabilities, which is a useful brake on severity inflation — and the InfoQ account is T4 trade press, so treat its specifics as reported pending independent confirmation. The 30-day retention policy also sits in documented tension with Microsoft’s zero-retention enterprise standard: a B2B contract conflict, not only a user constraint. The governance apparatus around all of it — export controls, a multi-vendor jailbreak-severity framework with Amazon, Microsoft and Google — is cross-spoke context for ../ai-governance-wiki.

The vendor’s own economics — the risk under all four. anthropic (per anthropic-valuation, 30 May 2026) is the most valuable AI lab at ~$965B, revenue roughly doubled to ~$9B and driven by Claude Code, which strengthens the bet that the substrate keeps being maintained and improved. The same source flags unproven economics — hundreds of billions in compute commitments, $1.5B/month to SpaceX, profitability questioned. Substrate cost is therefore the live risk to the near-free-maintenance thesis, and it is the mirror image of the capability upside. Tracked lightly: industry business news, on-thesis only through the capability-and-cost lens.

Cluster F gets a measurement side

The cluster’s four models — technology-adoption-curve, crossing-the-chasm, gartner-hype-cycle, bass-diffusion-model — all describe the shape of diffusion and none locates a technology on that shape while it is happening. The corpus already concedes this in its own pages (Bass “fit retrospectively”, the hype cycle “not empirically validated”). A model fitted after the event is not a measurement, and until now the cluster had nothing else.

adoption-curve-measurement is the missing side, written from a curator question about the seam with search-marketing-wiki. Three of that spoke’s five demand signals turn out to be cluster-F concepts becoming visible — phrasing absent from keyword tools is Rogers’ first 2–3%, contested labels are pre-critical-mass, formal vocabulary moving first is institutional rather than individual adoption. Two are in none of the models: keyword difficulty and results-page structure count sellers, where Rogers, Moore and Bass all count adopters. The cluster has been reading one side of a two-sided market.

It also reads on the hole this cluster admitted in July. technology-adoption-curve records that Rogers has no term for power — no state, no regulator — and files “states ultimately decide how fast technology is adopted” as an unresolved tension. Searches for ISO 42001, the Colorado AI Act and AI regulation are that variable arriving as data: an institutional layer moving first, with demand following. If the power critique holds, the part of the curve the models cannot explain is the part this instrument sees earliest.

Held at its real standing: one unvalidated instrument. Search is interest, not adoption; there is no denominator, so no fraction-of-market; a rising line fits the Peak of Inflated Expectations as well as it fits uptake; and no one reports the candidate categories that showed every signal and died. What would settle it is the same study on both sides of the seam — fixed candidate set, signals recorded at time zero, hit rate reported.

Open questions

• (new 2026-08-07) What is the threat model for LLM-authored notes? yank-note makes markdown executable and says out loud what that costs; every tool in this roster assumes the notes were written by their reader. In the llm-wiki pattern they were not — a machine wrote them from fetched sources, and at gbrain‘s unattended end nobody reads them before they open. Nothing in this corpus separates trusted from untrusted markdown, and the obvious mitigations (sandboxed execution, per-run consent, separating the reading tool from the executing one) appear nowhere. Natural next sources: a documented incident, or any PKM/agent tool that ships a trust boundary rather than a warning.
• Is this still one wiki? Resolved (2026-05-29): the true islands (game-dev, web-perf, cloud) were split into their own wikis. What remains — A, B, E — is unified by the “LLMs / machines operating over file-based markdown to manage and mechanize thought” super-thesis, with B and E bridged to A via model-context-protocol, agent-skills, and the Leibniz/Bush mechanizing-reasoning lineage.
• Does the index-file approach hold up at ~100 sources / hundreds of pages? Informed by gbrain: index-only is fine at small scale, but GBrain (built for ~100K pages) moves to Postgres + vector + a knowledge-graph and treats ~50K pages as the PGLite ceiling. So this wiki’s index-only choice is right for now but has a known ceiling; the upgrade path is search (qmd) then graph.
• How does the pattern compare to mature RAG/graph-RAG on accuracy, cost, effort? Resolved (2026-06-29). Grounding now spans advocate, method-primary, and neutral sources: rag-original-paper (what RAG claimed); gbrain‘s +31.4-point P@5 (advocate); the GraphRAG primary from-local-to-global-graphrag (72–83% comprehensiveness; C0 at 9×–43× lower token cost) and leanrag (~46% less redundancy). The missing piece — a neutral third-party benchmark — is now in: graphrag-bench (“When to use Graphs in RAG”, ICLR 2026, proposes no method). Its verdict is task-conditional: graphs win on multi-hop reasoning + summarization but lose to vanilla RAG on simple fact retrieval (~49–60% vs ~61–65%) at 1–2 orders of magnitude more tokens. So “accuracy/cost” is answered (it depends on the task, and graphs are expensive); the only residue is longitudinal maintenance/drift effort, which is its own open question below.
• What is the maintenance cost in practice — does drift/contradiction accumulate despite the lint pass / dream cycle? gbrain automates the maintenance but publishes no longitudinal drift measurement; open.
• Does anyone know whether their graph’s nodes are the right nodes? (opened 2026-07-27, rahulnyk-knowledge-graph.) Sibling to the maintenance question above, one level down: not whether the content drifts but whether two extracted nodes are the same thing. entity-resolution is load-bearing — the graph’s value is its joins, and unmerged duplicates break them exactly where multi-hop traversal pays off — and the corpus has four different answers (GBrain’s unattended dream cycle, sift-kg‘s human-gated merges, GraphRAG’s community-summarization absorption, and this project’s honest “not yet”). None of them reports a number. No precision/recall on merges, no count of duplicate nodes before and after. It’s the same evidence hole graphrag-bench closed for graph retrieval, still open for graph construction. Largely answered 2026-08-08 by core-kg and link-kg: GraphRAG duplicates 27% of its nodes on short documents and 36% on long ones, and pre-extraction coreference brings that to 10.6% and 17.8%. So the answer to “does anyone know” is now yes, and the answer to “how bad is it” is about a third of the graph. What survives is narrower and stated as edge #1 below — the count is made by fuzzy string matching over named entities, so nothing yet measures duplication among proposition-shaped nodes.
• Where does this sit relative to Engelbart’s NLS/Augment? Resolved (2026-05-29): ingested augmenting-human-intellect — Engelbart is now the documented middle of the lineage (Bush → Engelbart → LLM-wiki). Open caveat: an explicit in-text Bush citation in Engelbart’s 1962 report was not confirmed, only the well-documented influence. Still no source on Zettelkasten / Roam. Both resolved (2026-05-29): zettelkasten/niklas-luhmann (parallel ancestor) and roam-research (modern tools-for-thought operationalization). Logseq, Tana, Notion, and Obsidian-as-a- product (vs. the mentioned tool) remain the open modern-PKM gap.
• How faithful is the “memex ancestor” framing to Bush’s actual 1945 proposal? Resolved by as-we-may-think: the framing is faithful — Bush’s “connections between documents as valuable as the documents” and private curation are real — but see the tension below.

The document that runs is older than the tools claiming it

org-mode and org-mode-literate-programming add the corpus’s missing elder, and they land on two threads at once.

On tools for thought: every newer system here picked a centre and grew outward — notes, blocks, graph, database. Org started as an outliner and accreted TODO states, cross-file agendas, tables with a spreadsheet, code execution and export, while keeping “strictly plain text files, the most portable and future-proof file format.” The local-first position that roam-research‘s hosted database made into an argument was Org’s default from 2003, never revisited. The manual’s stated stance is a toolbox: complexity available, not imposed. That is a third answer to the problem, beside a smaller feature set and an opinionated workflow.

On executable documents: Schulte et al. published the multi-language literate-programming case in JSS in 2012, with the code attached — prose, data, project management and runnable blocks in one file, one block’s output feeding the next. Set beside executable-markdown and wiki-compiler, this says the “document that runs” is not an LLM-era invention; the change is who writes the code in the blocks, not the container. Worth holding onto whenever a current tool presents the idea as new.

What neither source can support: both are the system describing itself, and one is by Org’s own maintainer. The corpus has Org’s design and no evidence about living with it for twenty years, which is exactly the claim that would matter against the newer generation.

Growth edges

Ranked; each names the kind of source that would close it (see ../QUALITY.md → Growth edges).

1. Duplication where surface form does not carry identity. Successor to the entity-resolution edge closed 2026-08-08 by core-kg and link-kg, which supplied the before/after duplicate counts the corpus had been missing (GraphRAG at 27–36% duplicate nodes, down to 10.6–17.8% with pre-extraction coreference). Both counts are produced by RapidFuzz over intra-type entity pairs plus expert review of the clusters — which works because the nodes are people, places and organizations. The corpus’s harder case is untouched: rahulnyk-knowledge-graph extracts propositions, gbrain and sift-kg merge claim-shaped nodes, and no string matcher or cheap annotator can say whether two of those are the same. er-evaluation-framework adds that the naive version of such a number reads too high. — needs: a duplicate-rate or merge-precision figure on a graph whose nodes are claims rather than names · hunted 2026-08-08 — nothing ≥ bar. Four lines read: DocTER ablates semantic dedup out of triple extraction (16.5 → 39.01 triples/document) but scores a knowledge-editing task; LLM×MapReduce-V2 defines claim density (unique claims over total extracted) and applies it to generated articles, not a graph; fact-checking claim-extraction work measures coverage and decontextualization only; KGGen and the LLM-KG survey describe embedding-clustered dedup without scoring it. Claim-level dedup is implemented everywhere and measured nowhere — the edge is unmet, not mis-specified. Not re-hunted before 2026-08-22.
2. Longitudinal drift. gbrain automates maintenance and publishes no measurement of whether contradiction accumulates over time. — needs: a T1 longitudinal study or a system report covering more than one maintenance cycle.
3. Has Tana left the thesis it was recruited for? New 2026-08-04, and it is a correction to this page rather than a sourcing gap. The Current thesis above uses tana as the point where “the lineage closes on itself” — the AI-native PKM tool reading your typed graph instead of a blank document, and therefore the llm-wiki bet arriving inside a mainstream product. Re-verifying that page at 67 days past window found the company now describes itself as “an agentic meeting platform”: agents working during video calls, filing issues and updating context while people talk. Whether the supertag/graph machinery still sits underneath or has been de-emphasised, one homepage read cannot say — a tagline is positioning, not architecture. But the thread should not be restated as settled until something confirms it. — needs: a source on Tana’s current architecture, or the guide re-read at depth.
4. A neutral benchmark that covers multimodal retrieval. New 2026-08-04 with rag-anything. graphrag-bench settled the text case by proposing no method of its own; the multimodal claim has nothing equivalent, so the corpus’s only evidence for it is author-run and comes from the group that wrote one of the baselines. — needs: a T1 third-party benchmark, or failing that, any measurement of extraction fidelity (the parsing stage nothing in the cluster measures).
5. The modern-PKM gap. Logseq, Tana, Notion, and Obsidian-as-a-product are named in the resolved Bush/Engelbart/Zettelkasten thread and unsourced. — needs: first-party docs (T3 acceptable, the edge names product facts) or a neutral comparison.
6. The displaceable T4s only. 16 T4s here, most of them commentary and reviews that stay T4 by right; the displaceable ones are launch pages whose claims are plain product facts. — needs: first-party announcements (T3 allowed).

Coverage edges (added 2026-08-08, at the curator’s request for a wider backlog). These widen what the spoke covers instead of answering an open question above; one ordinary solid source closes any.

4. Org-mode and the Emacs lineage — half closed 2026-08-09 (research pass). org-mode is written from the manual (T1) and org-mode-literate-programming (Schulte et al., JSS 46(3), 2012, T1) supplies the Babel half. The half that is still open is the one the edge asked for: a long-running user’s account. Both sources are the system describing itself, so the corpus has Org’s design and nothing on what two decades of daily use with it is actually like — which is the only evidence that would test the durability claim against obsidian and roam-research. — needs: a multi-year retrospective, or survey data on Org use.
5. The implementations under spaced-repetition. The concept page has no tool beneath it — Anki, SM-2, FSRS — so the corpus holds the idea and none of the scheduling that makes it work. — needs: the algorithm’s own specification plus a retention study.
6. The automated end of formal methods. lean-theorem-prover, isabelle, rocq and tla-plus cover interactive proof; SMT solving (Z3), Alloy and model checking, where industry actually applies verification, are absent. — needs: the Z3 or Alloy papers, T1.
7. The diffusion literature’s critics. gartner-hype-cycle is held on Gartner’s own account and Wikipedia’s; the published criticism of it (no data behind the curve) is not. — needs: a peer-reviewed critique of the hype cycle or of adoption-curve methodology.

Cluster E finally has a map (formal-verification)

The cluster was built tool-first — lean-theorem-prover, rocq, isabelle, tla-plus, alphaproof — and a survey of the field arriving now says those tools were never doing one job. Model checking exhausts states (TLA+ over a design), deductive verification discharges proof obligations (Isabelle over seL4, Lean over mathematics), and abstract interpretation approximates. What the spoke had filed as one activity with several products is three techniques separated by what they exhaust, and the differences predict where each one stops.

Two things fall out. The survey’s named limitations — state explosion, cost, and the specification problem — include the one this spoke derived on its own from lean-certificate: a proof certifies the statement as written and cannot certify that the statement was the right one. Reaching a discipline’s known hole from a single artifact is a good sign for the method used here, and it upgrades that finding from a local observation to a citation.

The other is an asymmetry the corpus had no way to see. Hardware verification is routine and software verification is rare, with the same mathematics available to both. That is about the cost of a recall versus the cost of a patch, which also explains why every verified-software example is a kernel, a compiler or avionics — the places where shipping a fix is nearly as expensive as taping out silicon. spark in ../programming-languages-wiki is the same technique packaged as a language for exactly those industries.

Cluster E’s ceiling, and what a certificate can settle

Cluster E has tracked the mechanization of reasoning as a success story with known limits — Leibniz to Hilbert to Gödel to Lean, each step formalizing more and each limit logical in character. llms-cant-jump adds a limit of a different kind, and it comes from inside DeepMind.

Zahavy maps Einstein’s cycle — sense experience → jump → axioms → deduction → theorems — onto three inference types. Induction is mastered. Deduction is being conquered, and he cites alphaproof as proof, a paper he co-authored. abduction — inventing the axioms — is the missing arrow, and he argues the deficit is architectural rather than a matter of scale: a system with no sensory grounding cannot originate premises, only reason from them. General Relativity is the case study precisely because the data was scarce, which is where Schmidhuber’s discovery-as-compression thesis has nothing to work on.

Why this is a better limit than the usual ones. Gödel’s limit is about what a formal system can prove about itself, and there is no remedy. This one is claimed to be about architecture, so it comes with a proposal: action-controllable world models (Genie-class, intervening rather than predicting) that let a system cut the cable in a simulated elevator instead of watching a video of one. The stated ambition is turning the jump “from a mystical insight into a reproducible algorithmic process.” Cluster E has been documenting the deduction arrow being mechanized; this is the first source that names the arrow before it and proposes how to mechanize that too.

Hold it as a position, not a finding. It is a 10-page position paper with a historical case study, not a result. Its sharpest testable claim is about a benchmark — that ARC-AGI captures the logical leap and misses the manipulative component — which is checkable by anyone who wants to. Its scope is explicitly the physical sciences; the paper says mathematics grounds “sense experience” differently, which matters here because cluster E’s subject is mathematics.

The press version is a cluster-F specimen

llms-cant-jump-press turned a hedged architectural proposal into “LLMs will never replace human genius.” The concession that an LLM could do the deductive phase, the physical-sciences scope limit, and the words “position paper” all dropped in transmission, and every one of them made the original argument narrower and stronger. Primary and secondary are both held here so the delta stays inspectable — the clean version of a thing this spoke had only theorized about, how ideas deform as they diffuse.

The certificate tests the ceiling, and the obvious reading is wrong

ten-proofs: OpenAI published ten results — sphere packing, non-sofic groups, Connes rigidity, quantum parallel repetition, Erdős problems 146/180/183 and more — stating plainly that “the results were achieved by an internal version of Astra” and that the model also wrote the Lean. Roughly $2,000 of tokens, by their account, to find all ten.

It is not the refutation of the missing arrow it looks like, and the reasons are in Zahavy’s own paper: he scoped the argument to the physical sciences and explicitly conceded that a model could execute the deductive phase given the premises. All ten results live inside established axiomatic systems. Constructing a non-sofic group is a search for an object within mathematics as it stands, not the invention of a frame to reason from — nearer the 1913–1915 grind Zahavy grants to machines than the happiest thought that preceded it. What changed is the reach of the deduction arrow, which now extends to problems whose own communities had left them open for decades. Abduction is untested here, not disproved. Held as a tension.

What a certificate settles, and what it cannot

The larger contribution is epistemic, and it belongs to the whole hub. Every capability claim this corpus holds is self-reported, measured by an interested party on a sample it chose — the router’s standing complaint, sharpened by llms-cant-jump-press and, over in agentic-tooling, by an outside party finding an advertised effect roughly 3× the truth. ten-proofs is the first source where that objection does not apply, and not because OpenAI earned more trust. A lean-certificate isn’t a percentage. It type-checks or it doesn’t, on a stranger’s laptop, with no access to the model. Cluster E has spent its life documenting formalization as a tool for exploring what can be proved; here it is doing something else — acting as the social protocol by which a result from an uninspectable source becomes admissible. Verification standing in for authority is ancient in mathematics. What’s new is that the party lacking authority is the author.

Be precise about how narrow that is. The kernel certifies validity and nothing else: not whether the theorems matter, not whether the proofs illuminate, not whether the published narrations of the model’s reasoning bear any relation to what happened, and not that the formalized statement is the one a mathematician would have written. The class of AI claims settleable this way exists only where the output is a formal object — mathematics, some program verification, and almost nothing else the hub tracks.

Two live threads it feeds. Cluster F gets its cleanest specimen yet: OpenAI’s announcement footnotes five follow-on arXiv papers by human mathematicians, so the diffusion of a result the community did not produce is observable from day one. And the attribution stance — the Leiden declaration named, “claiming human authorship for a proof generated entirely by an AI system would misrepresent both”, responsibility for correctness retained while the arguments are credited to the system — is a sharper line than the field usually draws and the seam to ../ai-governance-wiki.

The graph itself became the subject

The KG/RAG cluster has always argued about retrieval strategy — communities and map-reduce (from-local-to-global-graphrag), summary trees (raptor), hierarchical aggregation (leanrag), when to use a graph at all (graphrag-bench). Every one of them takes the knowledge-graph as given and competes on what to do with it.

memgraphrag moves the question one step earlier: the graph is an artifact the pipeline produces, produced badly, and that is where the losses live (graph-construction-quality). LLM extraction runs over chunks with no global state, so the merged graph drifts off-topic, contradicts itself across documents, and splits single entities across disconnected subgraphs. The number that carries the argument is small and awkward: discarding 40% of low-frequency triples slightly improves downstream accuracy. Most of what the extractor emits is not load-bearing.

This reframes the cluster’s central measured trade. graphrag-bench found graphs buying recall and losing context relevance — 84.3% vs 71.8% recall, 38.5% vs 62.9% relevance in MemGraphRAG’s own reproduction. If the graph is noisy, that is not an inherent property of graph retrieval; it is retrieval faithfully surfacing a bad index. Which would mean the cluster has spent its sources optimizing the second half of a two-stage pipeline.

Held loosely, and the paper’s own experiment is why. Transplanting its cleaner graph under four other frameworks’ retrievers gains +0.19 to +0.71 points, against a full-system margin near +2.9. So most of the demonstrated win comes from the matched retriever, not the better graph — the opposite of what the framing implies. Whether construction quality matters in general or only alongside a retriever built for it is exactly what one paper by one group cannot settle.

The failure modes generalize past GraphRAG regardless. Anything that builds a persistent structure from a corpus one window at a time — an induced ontology, a temporal-knowledge-graph, an agent’s accumulated memory — inherits all three, and the same three fixes apply: a global schema, an adjudication pass, and coreference resolved across the corpus rather than within a chunk.

And there is a stage before that one (rag-anything, 2026-08-04). MemGraphRAG moved the question from retrieval back to construction. RAG-Anything moves it back again, to parsing — its first pipeline stage extracts images, tables and equations from PDFs and Office files before any graph exists, and it delegates that wholesale to an external parser (MinerU, or Docling, or PaddleOCR). Whatever the parser gets wrong is wrong in the graph, and no construction fix or retrieval strategy downstream recovers it.

So the cluster’s argument has walked backwards through its own pipeline in two sources: retrieval strategy → graph construction → document extraction. Each step found the losses were upstream of where everyone was measuring. Nothing in the corpus measures extraction fidelity, and unlike the previous two steps this one has no paper arguing for it — it surfaced as an architectural fact of the first system that had to read a PDF rather than a text dump.

It also exposes an assumption the cluster never defended: every system here indexes text only. That was the shape of the input, not a design decision anyone argued for, and RAG-Anything is the first entry to break it — images, tables and LaTeX promoted to graph entities with cross-modal edges, via dual-graph construction on top of lightrag‘s machinery.

Held at arm’s length on the evidence, though, and for a reason worth naming. Its abstract claims “superior performance” and “significant improvements” while naming no dataset, no baseline and no number; the paper does name DocBench and MMLongBench against nine baselines, but the evaluation is author-run, from the group that also wrote one of the baselines. This corpus already learned what that is worth — graphrag-bench is on the shelf precisely because it proposes no method, and it turned the cluster’s advocate narrative into a task-conditional one. Judge RAG-Anything’s multimodal claim when a neutral benchmark covers multimodal retrieval. None does yet, which is itself the gap.

And now the construction defect has a size

The section above says the graph is produced badly and cites a small, awkward number for it — 40% of low-frequency triples can be discarded with no loss. core-kg and link-kg give the same argument a blunt one. Running GraphRAG unmodified over judicial case documents, 27% of the nodes it extracts are duplicates on short documents and 36% on long ones. Resolving coreference across the whole document before extracting, rather than deduping the graph afterwards, brings that to 10.6% and 17.8%.

Two things follow for this cluster. First, “splits single entities across disconnected subgraphs” was the vaguest of the three failure modes and is now the best measured: a third of the graph, on long inputs, at the frontier of what a 70B open model does unassisted. Second, it decides an argument entity-resolution had been holding open. GraphRAG’s position on dedup was structural — community detection and summarization absorb near-duplicates, so merging is optional. That position was reasonable when nobody knew the rate. At 36% it is a lot to ask of a summarizer.

The direction of the fix also agrees with memgraphrag from a different group and a different domain: do the global work before extraction, not after. Two independent lines now say the chunk-local extractor is the defect and that giving it corpus-level state is the repair.

Where it stops is the same place everything in this cluster stops. The duplicate count comes from fuzzy string matching over people, places and organizations, checked by an expert. The nodes this wiki cares most about — rahulnyk-knowledge-graph‘s propositions, the claim-shaped things gbrain and sift-kg merge unattended — have no surface form to match on, and er-evaluation-framework has already shown that the naive way of scoring them would read too high. The measurement exists; it does not yet reach the hard case.

A third answer to “the corpus does not fit”

Added 2026-08-08 with llm-x-mapreduce (THUNLP/OpenBMB, Apache-2.0). The cluster has held two answers to an input too large for a window: retrieve the relevant slice (retrieval-augmented-generation) or build a structure and traverse it (graphrag). This is the third — process all of it in fragments and fold the results, with repeated passes building higher-level understanding the way convolution builds features.

What makes it a different shape rather than a variant: the other two assume the output is short. An answer, a summary, a paragraph. LLM×MapReduce is built for long-to-long, and its product case is writing a survey article from a literature corpus. The authors’ framing is that long-input understanding has had all the attention and long output has had almost none, which reads as a fair description of this cluster’s own shelf.

Its own numbers (95.50/95.80 against vanilla at 25.48/26.46 on SurveyEval) are author-run on an author-built dataset, so they are held the way graphrag-bench taught the cluster to hold such things — as a direction, not a magnitude.

One connection worth recording because it closes a loop from the same day. V2 defines claim density, unique claims over total extracted claims after deduplication. The research pass earlier that day hunted precisely that shape of metric for claim-shaped graph nodes and found none. This is still not it — density scores a generated article, not a persistent graph, and reports a ratio rather than merge correctness — but it is the third source in one day where claim-level dedup runs as machinery and is never scored as a result. That recurrence is now the finding.

The pattern’s maintenance half becomes a product feature

This wiki’s thesis has one load-bearing claim: Bush and Engelbart had the design and lacked the labour, and the LLM supplies it. Until now that claim was carried by an essay (llm-wiki-gist) and by one team’s production system (gbrain). rocketnotes sells it as a bullet point — “an AI agent analyzes snippets from your ‘inbox’ and intelligently files them into the most relevant existing document” — paged as agentic-archiving.

Three things follow.

The unit of automation is placement, and that is the least interesting choice available. Filing is the tax on capture, so automating it is obviously useful. But zettelkasten‘s claim, and associative-trails’ before it, is that placement is not where the value lives — connection is. An agent that files well automates the part of the practice the method says does not matter, while proposing a link and a reason is left undone, and is no harder. This hub’s own practice is the counterexample: every ingest here writes [[wikilinks]] with the connection stated in prose, and nothing depends on which directory a page sits in. The better product is available and unbuilt.

Retrieval and maintenance now ship together, having been framed here as rivals. llm-wiki-gist positions the compounding wiki explicitly against retrieval-augmented-generation: distil an artifact rather than retrieve over raw documents. Rocketnotes ships semantic search and chat-with-your-documents and the filing agent, with no sense that these are competing answers. That is the more likely future shape — both, in one product — and it makes the open question sharper rather than moot: does maintaining the artifact still pay once retrieval over the raw pile is good? Nothing in this corpus measures it.

The vocabulary is travelling faster than the mechanics. “Zettelkasten” here names an inbox plus a filing agent over a drag-and-drop hierarchy. The capture half is faithful to the method; the filing half inverts its central principle. Expect more of this as AI note-taking products multiply, and check the borrowing at zettelkasten rather than accepting the label.

Standing caveat: T1 as a project describing itself, with no evaluation of filing accuracy — not by the project, and no benchmark for it anywhere in this corpus. A wrong file in a hierarchy is lost until search finds it; a wrong link is visible and reversible. That asymmetry argues for links, and nobody has measured it either.

The document acquires effects

Eighty years of this lineage improved how notes connect: atomic and linked (zettelkasten), traversable (memex), a graph (obsidian, roam-research), machine-maintained (llm-wiki). Throughout, the document has been inert. yank-note breaks that — runnable code blocks in JavaScript, PHP, Node, Python and bash inside the note, an AI Copilot writing into the same file, and local markdown underneath so nothing about the storage bet changes. Paged as executable-markdown.

The project states the price itself, which is why it is worth a section: it “sacrifices security protection (command execution, arbitrary file reading and writing)” for extensibility, and warns against opening untrusted markdown.

That warning lands on this corpus specifically. The llm-wiki pattern has a machine writing markdown continuously from sources it fetched, and gbrain runs the loop unattended — which is the augment→automate axis at its automated end, with no human reading the file before it is opened. Prose and code arrive through the same pipe at the same trust level. An executable document turns a summarization pipeline into an execution path.

Reflexively: this hub is an instance of the pattern, and it is safe from this only because plain markdown plus a static site generator happens to keep the reading tool and the executing tool apart. That is an accident of setup, not a decision anyone recorded. The lineage has no threat model for LLM-authored notes — the tools all assume the author is you — and that is now filed as an open question rather than left implicit.

Contradictions / tensions

• The 4× claim: what the vendor said vs. what the coverage reported (added 2026-08-03). Three pages here carry Opus 4.8’s flagship result as an honesty gain — ~4× less likely to make unsupported claims — sourced from claude-opus-4-8-review and echoed by claude-opus-4-8-launch-tomsguide. Anthropic’s own announcement, fetched 2026-08-03 by the hub research pass, states it narrowly: four times less likely to let flaws in code it has written pass unremarked. A code-review property, not general truthfulness. Both are kept and neither is retracted; the reviewers may be reporting a different measure from the system card, which this wiki does not hold. The reason it earns a place here rather than a footnote: it is the corpus’s clearest instance of the pattern this cluster keeps flagging in the other direction — a specific vendor claim widening as it passes through secondary coverage, with the broad version then citable from three pages and the narrow original from none until now.
• Cluster F — continuous vs. discontinuous adoption (added 2026-06-09). geoffrey-moore‘s chasm posits a sharp discontinuity between early adopters and the early majority; everett-rogers explicitly disputed this, holding innovativeness is “a continuous variable.” Both are in the wiki — Moore’s is the practitioner heuristic, Rogers’ the academic model. Compounding the caution: the gartner-hype-cycle (the cluster’s other framework) is itself empirically weak (“six in ten” trough technologies never recover; most don’t follow the pattern). So cluster F’s frameworks are useful lenses, not validated laws — to be applied with the same skepticism the wiki applies to advocate sources elsewhere.
• Cluster F — does the innovation set the pace, or does power? (added 2026-07-28.) Every predictor in Rogers’ model is a property of the innovation (relative advantage, compatibility, complexity, trialability, observability) or of how word travels. There is no variable for the state. brief-history-of-luddism asserts the opposite in its standfirst — “States ultimately decide how fast technology is adopted” — which would make the adoption curve a description of diffusion inside politically set limits rather than an explanation of its speed. Held as an open tension rather than a correction, because the source is paywalled past its first paragraph and the argument behind that claim was not read. The same source sharpens the cluster’s existing pro-innovation-bias caveat. The Luddites weren’t laggards waiting their turn on the curve; they were organised textile workers destroying specific machines that “stole jobs from humans.” The tail of the distribution can be acting on a correctly read interest, which the label “laggard” quietly denies.
• Who maintains the trails? (tension, not a flat contradiction.) llm-wiki-gist says the part Bush “couldn’t solve was who does the maintenance.” But as-we-may-think does give an answer: a “new profession of trail blazers” — i.e. humans. So Bush didn’t fail to address maintenance; he assigned it to human labor. The LLM Wiki’s actual novel claim is narrower and stronger: that this human solution doesn’t scale, and the LLM is the first agent that makes trail-building/maintenance cheap enough to sustain. Worth keeping in mind as a place where the secondary source slightly overstates Bush’s omission.
• Do graphs beat vector RAG? Advocates say yes; the neutral benchmark says “it depends” (added 2026-06-29). The wiki’s graph-RAG sources mostly sell graphs as a broad win: gbrain reports a +31.4-point P@5 lift from its knowledge-graph, and the method papers (GraphRAG, leanrag) report 72–83% / large comprehensiveness wins — all author-run, LLM-judged. The first third-party benchmark, graphrag-bench (ICLR 2026, no method of its own), pushes back: GraphRAG underperforms plain vector RAG on simple fact retrieval (~49–60% vs ~61–65% — the graph adds redundant context) and only wins on multi-hop reasoning + summarization, at 1–2 orders of magnitude more tokens per query. Not a flat contradiction — the advocates test global/multi-hop-flavored tasks where graphs do win — but it reframes the thesis: graphs are a task-conditional retrieval tool, not a default upgrade, and the wiki should treat single-method “graphs win” claims (especially from advocates) with the same skepticism it applies to cluster F’s frameworks. The hybrid-retrieval lesson (hybrid-retrieval-rag) rhymes: no single retrieval method dominates across query types. The neutral pole moved (2026-08-03). memgraphrag (KDD 2026) is a GraphRAG method from largely the team that built graphrag-bench — four shared authors, including both of its equal-contribution first authors and its corresponding author — and it tops that benchmark on G-Medical and G-Novel. Nothing above is retracted: the benchmark came first, proposed no method at the time, and its diagnosis stands. But the wiki can no longer cite a neutral benchmark and a method winning on it as two independent data points, because they come from one lab. The benchmark’s independence still covers everyone else’s systems; it does not cover this one. Watch for a genuinely external evaluation of the current crop — nobody in this corpus is now outside the argument.

Index

Catalog of every wiki page, grouped by schema.org @type. Read this first when answering a query, then drill into the relevant pages. Updated on every ingest.

Split note (2026-06-01): the agentic-tooling cluster (agent products, skills, coding harnesses, orchestration, the skills spec) was spun out to the sibling agentic-tooling-wiki. A few bridge nodes remain here and are linked cross-wiki from there: agent-skills, compound-engineering, model-context-protocol, gbrain, anthropic, claude-opus-4-8.

Article (sources)

• wiki-memory — LangChain (Harrison Chase): names the llm-wiki pattern “wiki memory,” frames it as agent memory (scope: durable domain knowledge, not conversation/prefs/logs) + sharpened RAG contrast; new instances DeepWiki/AutoWiki · source · T3 · langchain.com
• llm-wiki-gist — Karpathy’s gist defining the LLM Wiki pattern · source · src: llm-wiki.md
• as-we-may-think — Bush’s 1945 Atlantic essay introducing the memex · source · src: as-we-may-think.md
• notion-wikipedia — Wikipedia on Notion; neutral source for the mass-market PKM counterpoint · source · src: notion-wikipedia.md
• tana-supertags-guide — guide to Tana’s supertags; AI-native typed-node PKM · source · src: tana-supertags-guide.md
• roam-research-guide — guide to Roam; bidirectional links + personal knowledge graph · source · src: roam-research-guide.md
• zettelkasten-introduction — zettelkasten.de’s guide to Luhmann’s slip-box method · source · src: zettelkasten-introduction.md
• tech-adoption-curve-twenty-years — InfoQ: 20 years of dev tech on Rogers’ adoption curve (cluster F) · source · infoq.com
• brief-history-of-luddism — The Economist (Free Exchange): “States ultimately decide how fast technology is adopted” — cluster F’s first power/politics claim, against a model with no state variable; PARTIAL — paywalled past the opening paragraph · source · T2 · economist.com
• developers-history-of-ai — dev.to: a developer’s 70-year history of AI as “which layer of human work got automated” (symbolic→agentic); judgment moves upstream — cluster F + the mechanizing-thought meta-thread · source · T4 · dev.to
• diffusion-of-innovations-wikipedia — Wikipedia: Rogers’ diffusion theory; adopter categories, S-curve, adoption attributes (cluster F) · source · en.wikipedia.org
• gartner-hype-cycle-wikipedia — Wikipedia: the hype cycle + its critiques (cluster F) · source · en.wikipedia.org
• crossing-the-chasm-wikipedia — Wikipedia: Moore’s chasm, beachhead, whole product (cluster F) · source · en.wikipedia.org
• ontology-information-science-wikipedia — Wikipedia: Gruber’s definition, ontology-vs-taxonomy axiom test, OWL/RDF/CycL, domain vs upper ontologies · source · T2 · en.wikipedia.org
• zettelkasten-wikipedia — Wikipedia: Luhmann’s ~90K-card slip-box, branching index addressing, pre-Luhmann origins · source · T2 · en.wikipedia.org

ScholarlyArticle (sources)

• org-mode-literate-programming — Schulte, Davison, Dye & Dominik, JSS 46(3), 2012 (T1, CC-BY, code published with it): Org Babel — one plain-text file holding prose, data, project management and executable blocks in many languages, one block’s output feeding another, exporting to LaTeX/HTML/beamer/DocBook. The reproducible-research argument, fourteen years early · source · T1 · jstatsoft.org
• rag-original-paper — Lewis et al. 2020 (FAIR): the canonical primary source defining RAG (parametric + non-parametric memory); cluster A · source · arxiv.org
• leanrag — KnowledgeXLab, AAAI 2026: refines graphrag — semantic aggregation (links the summary nodes, killing “semantic islands”) + bottom-up hierarchical retrieval; ~46% less retrieval redundancy; the thread’s first peer-reviewed KG-RAG anchor · source · T2 · github.com
• from-local-to-global-graphrag — Edge et al., Microsoft 2024: the canonical GraphRAG paper — Leiden hierarchical communities (C0→C3) + map-reduce over community summaries; 72–83% comprehensiveness wins over naive RAG; coarse C0 level answers global queries at 9×–43× lower token cost; closes the graphrag sourcing gap · source · T1 · arxiv.org
• graphrag-bench — Xiang et al., ICLR 2026: the neutral third-party “When to use Graphs in RAG” benchmark (proposes no method) — graphs win on multi-hop reasoning + summarization but lose to vanilla RAG on simple fact retrieval, at 1–2 orders of magnitude more tokens; reframes the cluster’s advocate narrative as task-conditional · source · T1 · arxiv.org
• hipporag2 — Gutiérrez et al. (OSU-NLP), ICML 2025 “From RAG to Memory”: hippocampal-indexing KG-RAG — LLM OpenIE graph + Personalized PageRank for single-step multi-hop retrieval; v2 fixes the factual-recall tradeoff via deeper passage integration; graphrag-bench‘s strongest + most token-efficient graph method · source · T1 · arxiv.org
• lightrag — Guo et al. (HKUDS), 2024 “Simple and Fast RAG”: dual-level (low/high keyword) retrieval over a KG fused with vectors; signature feature is incremental graph updates (no full rebuild) — cheaper/simpler than Microsoft GraphRAG; mid token-cost in graphrag-bench · source · T1 · arxiv.org
• rag-anything — Guo/Ren/Xu/Zhang/chao-huang (hkuds), arXiv 2510.12323: the cluster’s first multimodal system — images, tables and LaTeX equations promoted to graph entities via dual-graph construction, with a MinerU parsing stage in front; built on lightrag and inherits its incremental updates. Author-run eval on DocBench + MMLongBench; abstract claims superiority naming no dataset, baseline or number · source · T1 · arxiv.org / github.com/HKUDS
• er-evaluation-framework — olivier-binette et al., arXiv 2024: entity-centric evaluation for entity resolution — sample resolved clusters, not pairs, then estimate pairwise/cluster/b-cubed precision and recall for the whole data set. Names the defect the corpus assumed away: naive pairwise precision on benchmark data is biased upward and can reverse rankings. PatentsView validation (91% precision / 94% recall as the bar); estimator bias <0.4%, RMSE 4.7%→2.4% at n=200→800 against a 9% do-nothing baseline · source · T1 · arxiv.org
• link-kg — dipak-meher, Domeniconi, Correa-Cabrera, arXiv Oct 2025: three-stage LLM coreference (a type-specific Prompt Cache carried across chunks) run before extraction; the corpus’s first before/after duplicate count on an LLM-built graph — GraphRAG 27.02% dup / 23.59% noise on short docs and 36.01% / 40.71% on long, LINK-KG 10.61% / 12.28% and 17.78% / 17.57% (−45.21% dup, −32.22% noise averaged). 16 US judicial cases, LLaMA 3.3 70B; duplicates counted by RapidFuzz ≥75% + expert review, so it measures name-shaped nodes only · source · T1 · arxiv.org
• core-kg — dipak-meher et al., arXiv Jun 2025: the predecessor — type-aware coreference then domain-guided extraction; −33.28% duplicate nodes, −38.37% legal noise against a GraphRAG baseline, figures link-kg independently reproduces when re-running it as a baseline · source · T1 · arxiv.org
• raptor — Sarthi et al. (Stanford), ICLR 2024: recursive clustering + abstractive summarization into a tree of chunks (not an entity graph); retrieves across levels for long-document, multi-step QA (+20% on QuALITY w/ GPT-4); the non-graph “tree cousin” of GraphRAG’s community summaries · source · T1 · arxiv.org

Report (sources)

• augmenting-human-intellect — Engelbart’s 1962 SRI framework; the Bush→modern bridge · source · src: augmenting-human-intellect.md

SoftwareSourceCode (sources)

• llm-x-mapreduce — THUNLP / OpenBMB / AI9STARS, Apache-2.0, ~872★: divide-and-conquer for long-to-long generation — split the corpus, process fragments, fold the results; V2 adds entropy-driven convolutional test-time scaling and powers SurveyGO. Author-run SurveyEval figures 95.50/95.80 vs vanilla 25.48/26.46. The cluster’s third answer to an input that does not fit, and the only one whose output is also long. Defines a claim density metric (unique/total claims after dedup) · source · T1 · github.com/thunlp
• gbrain — Garry Tan’s LLM agent “brain” (synthesis + knowledge graph + dream cycle); also the memory layer of gstack (agentic-tooling-wiki) · source · src: gbrain.md
• ten-proofs — OpenAI (2026-08-01): Lean 4 certificates for ten claimed advances in maths/TCS (sphere packing, non-sofic groups, Connes rigidity, quantum parallel repetition, Erdős 146/180/183…), produced by an internal Astra; ~$2,000 of tokens by their account, model wrote the Lean too. The corpus’s first capability claim a stranger can falsify · source · T1 · github.com/openai
• memgraphrag — Wu/Xiang et al. (KDD 2026, MIT, arXiv 2606.00610): shared-memory multi-agent graph construction — schema/fact/passage layers, conflict adjudication, coreference bridging, PPR retrieval at 0.061s/query. Overall 59.25 (+2.10 over LinearRAG). Two things it shows sideways: dropping 40% of low-frequency triples improves accuracy, and its graph transplanted into other frameworks gains only +0.19–0.71. Four authors shared with graphrag-bench, the benchmark it wins on · source · T1 · github.com/XMUDeepLIT
• llm-wiki-agent — lightweight coding-agent implementation of the LLM-wiki pattern · source · src: llm-wiki-agent.md
• rocketnotes — fynn-fluegge‘s AI markdown note app (Apache-2.0, 1.4k★, Go/TS/Python; Angular + Electron, Lambda on AWS or all-local Docker with Ollama; DynamoDB + S3, ChromaDB/S3 Vectors, Langchain/Langgraph, MCP server, Neovim plugin). Ships agentic-archiving as a feature — and ships RAG (semantic search, chat-with-docs) alongside it, having no idea this wiki treats the two as rivals. Its “Zettelkasten” is an inbox plus a filing agent over a drag-and-drop hierarchy · source · T1 · github.com/fynnfluegge
• tiddlywiki5 — self-contained single-file personal wiki (~2004); earliest tool-for-thought node · source · src: tiddlywiki5.md
• logseq — open-source, local-first (plain Markdown) Roam-style PKM tool · source · src: logseq.md

BlogPosting (sources)

• wikis-over-engineered-compiler — TDS: replace the LLM-wiki agent loop with a deterministic Python compiler for the mechanical 90% (parse/link/lint, byte-identical), LLM only for the semantic 10%; the sharpest counter to the llm-wiki thesis · source · T3 · towardsdatascience.com
• lean-for-programmers — intro to the Lean proof assistant (cluster E) · source · src: lean-for-programmers.md
• claude-opus-4-8-review — Simon Willison on the Opus 4.8 release (model substrate) · source · src: claude-opus-4-8-review.md
• claude-opus-4-8-zvi — Zvi: Opus 4.8 capabilities + polarized reactions; complicates the honesty story · source · thezvi.substack.com
• claude-fable-5-review — Simon Willison: hands-on with Claude Fable 5 (9 Jun 2026); 2× Opus-4.8 price; guardrailed sibling of Mythos 5 · source · simonwillison.net
• claude-fable-5-mythos-5-announcement — Anthropic’s primary launch: Fable/Mythos 5 = same model, safeguards the only difference; classifiers fall back to Opus 4.8 · source · anthropic.com
• claude-fable-5-infoq — InfoQ: Fable 5 release + three-day US-gov suspension (jailbreak→White House→directive); Microsoft zero-retention friction · source · T4 · infoq.com
• redeploying-fable-5 — Anthropic (primary): the June export-control suspension of Fable 5 + Mythos 5, resolved → redeploy 1 Jul; hardened cyber classifier (>99%); jailbreak capability not Fable-unique; multi-vendor jailbreak-severity framework · source · T1 · anthropic.com
• enterprise-context-layer — Prukalpa/Atlan: the compounding-knowledge thesis as enterprise infrastructure (“the 10th agent is smarter than the 1st”) · source · metadataweekly.substack.com
• azure-logic-apps-knowledge-service — MS “Knowledge as a Service” for Logic Apps (Build 2026): fully-managed RAG/knowledge layer, zero pipeline to operate; grounds agents/workflows · source · T3 · techcommunity.microsoft.com
• hybrid-retrieval-rag — InfoQ: vector-alone fails; hybrid (BM25 + vectors + RRF + rerank); neutral corroboration of gbrain’s retriever · source · infoq.com
• agent-memory-knowledge-graphs — The Neural Maze: persistent agent memory via temporal knowledge graphs (Graphiti/Zep/Neo4j) vs vector RAG · source · theneuralmaze.substack.com
• ontologies-knowledge-graphs-ai — Mysore: ontologies vs KGs, LLM two-pass extraction, schema-as-guardrail finding; GraphBaby demo · source · T3 · medium.com

NewsArticle (sources)

• anthropic-valuation — Gizmodo: Anthropic (~$965B) overtakes OpenAI; substrate economics · source · gizmodo.com
• claude-opus-4-8-launch-tomsguide — Tom’s Guide: Opus 4.8 launch, “less likely to fake answers” (content-thin stub); superseded for product facts by the first-party announcement, retained as evidence of the coverage framing · source · T4 · tomsguide.com
• claude-opus-4-8-announcement — Anthropic’s own Opus 4.8 launch post: $5/$25 pricing, effort control, dynamic workflows, Terminal-Bench 2.1 92.3% / OSWorld-Verified 84.9%; narrows the 4× claim the reviews reported as an honesty gain · source · T3 · anthropic.com

WebPage (sources)

• mcp-spec-introduction — MCP’s official architecture overview: USB-C analogy, host/client/server, JSON-RPC data layer, Tools/Resources/Prompts, stdio + Streamable HTTP · source · T1 · modelcontextprotocol.io

TechArticle (sources)

• open-knowledge-format — Google Cloud’s OKF spec: knowledge as a bundle of typed markdown files (type frontmatter, reserved index.md/log.md, prose cross-links, git-diffable); “metadata as code”; the llm-wiki substrate as an open standard, deliberately anti-ontology · source · T1 · github.com
• llm-knowledge-base — TDS (Kjosbakken): building an LLM knowledge base; the grep-index vs embedding-RAG read-path dichotomy + “capture completeness, not retrieval, is the bottleneck” (cron-driven ingestion); cites llm-wiki/gbrain · source · T4 · towardsdatascience.com
• long-context-vs-chunking — TDS (Chien Vu Minh): ModernBERT experiments on when a long context window beats chunking — the chunk-boundary gap (whole-doc embeddings average boundary-crossing facts apart; overlap recovers) + long-context’s O(n²) cost usually losing to chunk-and-pool; the how-you-index lever on the RAG-critique thread · source · T2 · towardsdatascience.com

DefinedTerm

• llm-wiki — the pattern: an LLM maintains a persistent, compounding wiki; now standardized by Google Cloud as open-knowledge-format · concept
• wiki-compiler — the deterministic counterpart to the LLM-wiki agent loop: a plain compiler does the mechanical 90% (parse/link/lint, byte-identical output), the LLM only the semantic 10%; the deterministic↔probabilistic axis · concept
• retrieval-augmented-generation — the query-time baseline the pattern improves on · mechanism
• graph-construction-quality — the graph a GraphRAG pipeline builds is itself good or bad: chunk-local LLM extraction with no global state yields thematic irrelevance, logical inconsistency and structural fragmentation; the recall-up/relevance-down trade may be an index defect, not a retrieval one · mechanism
• memex — Bush’s 1945 associative knowledge device (the ancestor) · concept
• associative-trails — selection by association, not indexing; the memex’s core mechanism · concept
• tools-for-thought — umbrella concept + hub for the whole PKM lineage (Bush→Tana→LLM) · domain
• zettelkasten — Luhmann’s slip-box: atomic linked notes, connection over collection · concept
• knowledge-graph — typed-edge graph; GBrain’s automated, scaled associative trails · mechanism
• ontology — formal schema of domain concepts and relationship rules; the layer above the knowledge graph · concept
• temporal-knowledge-graph — knowledge graph with bi-temporal facts; closes the evolving-facts gap for agent memory · mechanism
• graphrag — graph-based RAG: Leiden community detection + community summaries answer global/whole-corpus queries vector RAG can’t; the retrieval method layered over a KG · mechanism
• entity-resolution — graph deduplication (“doctor” / “doctors” / “medical practitioner”); load-bearing because the graph’s value is its joins; four answers across the augment→automate axis, none measured · mechanism
• leiden-algorithm — hierarchical community-detection algorithm (improves on Louvain); GraphRAG’s clustering step, source of its C0→C3 community levels · mechanism
• microfilm — the storage medium Bush assumed for the memex · mechanism
• agent-skills — capability as portable markdown an agent loads; bridge to agentic-tooling-wiki (procedural cousin of the LLM-wiki’s knowledge markdown) · mechanism
• compound-engineering — each unit of work makes the next easier; Engelbart bootstrapping; bridge to agentic-tooling-wiki · practice
• model-context-protocol — MCP; shared substrate bridging this wiki and agentic-tooling-wiki · standard
• knowledge-as-a-service — KaaS: cloud knowledge-delivery backed by a knowledge model; context-exploitation vs DaaS (defines the Azure KaaS instance) · concept
• technology-adoption-curve — Rogers’ diffusion of innovation (innovators→laggards); cluster F’s founding concept; a tool-for-thinking about tech change · theory
• crossing-the-chasm — Moore’s chasm between visionaries & pragmatists; beachhead + whole-product (cluster F) · theory
• gartner-hype-cycle — Fenn/Gartner expectations curve (trigger→peak→trough→slope→plateau); the sentiment lens (cluster F) · theory
• executable-markdown — the note stops being inert: code blocks that run, so a document acquires effects (files, network, shell). New axis beside the connect-the-notes lineage, and the corpus’s first explicit trust boundary — an LLM-written markdown file arrives through the same pipe as its prose · mechanism
• agentic-archiving — an agent decides where new material belongs and files it: the llm-wiki pattern’s maintenance half isolated as one bounded decision per snippet, sitting between the human-directed and unattended poles. Automates placement, which is precisely what zettelkasten says the value isn’t in — the link-proposing version is available and unbuilt · mechanism
• spaced-repetition — expanding-interval review (SuperMemo/Anki/FSRS); the internalize-memory branch of tools-for-thought · source · mechanism
• adoption-curve-measurement — cluster F’s measurement side: the four models describe shape and none locates you on it live. Maps the five search-demand signals onto Rogers/Moore/Bass, finds two of them (supply-side: difficulty, SERP structure) are in no model at all, splits Bass’s p and q into separate live observables — and records the four failures (interest ≠ adoption, no denominator, hype indistinguishable from uptake, no false-positive rate) · methodology
• bass-diffusion-model — Bass (1969): the quantitative adoption model (p innovation + q imitation; dF/dt=(1−F)(p+qF)); cluster F’s math · source · theory

Organization

• anthropic — maker of Claude; the model-substrate provider (capability + cost thread)
• hkuds — HKU Data Intelligence Lab; ships lightrag and rag-anything as open source — a lineage, not two entries
• aidotnet — publishes opendeepwiki; AI tooling on the .NET stack, in an ecosystem that is otherwise Python and TypeScript

Person

• fynn-fluegge — GitHub handle behind rocketnotes; no biography evidenced · maintainer · thin node
• purocean — GitHub handle behind yank-note; no biography evidenced · maintainer · thin node
• andrej-karpathy — author of the LLM Wiki gist
• chao-huang — leads hkuds; the only researcher with two systems in the RAG cluster (lightrag, rag-anything)
• harrison-chase — LangChain co-founder/CEO; named the wiki-memory pattern (wiki-memory)
• vannevar-bush — engineer/administrator; originator of the memex
• douglas-engelbart — augmentation/NLS pioneer; the Bush→modern lineage link
• niklas-luhmann — sociologist; popularized the Zettelkasten slip-box method
• garry-tan — YC CEO; author of GBrain (and gstack in agentic-tooling-wiki)
• olivier-binette — statistician; lead author of er-evaluation-framework and maintainer of er-evaluation; the corpus’s source for measuring the measurement of entity resolution
• dipak-meher — first author of core-kg and link-kg; the pair that put a number on duplicate nodes in an LLM-built knowledge-graph
• everett-rogers — sociologist; originated Diffusion of Innovations (1962); cluster F’s founding figure
• geoffrey-moore — author of Crossing the Chasm (1991); the chasm refinement (cluster F)
• vishal-mysore — practitioner; built GraphBaby demo; author of ontologies/KG/AI article
• david-sacks — White House AI/Crypto Adviser (Trump admin); spokesperson for Fable 5 suspension
• juan-ceresa — developer; author of sift-kg (document→knowledge-graph CLI)

SoftwareApplication

• org-mode — “an authoring tool and a TODO list manager for GNU Emacs”: an outliner that absorbed TODO states, agendas across files, tables with a spreadsheet, executable code blocks and export. Strictly plain text since 2003 — the local-first choice made two decades before the corpus’s newer tools had to make it · source · T1 · orgmode.org
• obsidian — recommended markdown browsing front-end (graph view, plugins)
• yank-note — purocean‘s extensible Markdown editor (AGPL-3.0, 6.7k★, Electron/Vue): local plain-markdown storage, per-file .c.md encryption, PlantUML/Drawio/ECharts/Mermaid, an AI Copilot (OpenAI/Ollama/Gemini/Kimi) — and runnable code blocks (JS/PHP/Node/Python/bash), the roster’s only executing note-taker. Prints its own trade: it “sacrifices security protection (command execution, arbitrary file reading and writing)” for extensibility · source · T1 · github.com/purocean
• roam-research — networked-thought app; popularized bidirectional links + the personal graph
• notion — cloud/proprietary all-in-one workspace; the mass-market PKM counterpoint
• tana — AI-native outliner; supertags = typed nodes; links + structure + AI fused
• qmd — on-device markdown search engine for scaling beyond index-only
• graphiti — Zep’s incremental temporal-knowledge-graph framework for agent memory (Neo4j backend)
• deepwiki — Cognition: AI-generated GitHub-repo documentation; a codebase-doc wiki-memory instance
• autowiki — Factory: codebase documentation that stays current; a codebase-doc wiki-memory instance
• opendeepwiki — AIDotNet (MIT, ~3.5k★): repo → generated wiki + mind map + chat + per-repo MCP endpoint; the open-source, self-hostable instance of the codebase-doc sub-genre, regenerated on a schedule rather than corrected · source · T3 · github.com
• sift-kg — CLI that extracts a knowledge graph from documents via LLM (NetworkX property graph); human-approved entity dedup; the augment-pole counterpart to gbrain’s unattended dream-cycle · source · T3 · github.com
• rahulnyk-knowledge-graph — rahulnyk’s notebook (MIT, ~3.5k★): corpus → KG with local Mistral 7B + pandas + NetworkX + Pyvis; extracts concepts not entities and adds contextual proximity as a second weighted edge class; the legible minimum against which the packaged builders read as answers · source · T3 · github.com
• graphrag-rs — Rust GraphRAG: builds a KG and queries it (Leiden communities + PageRank → global answers); local-first (CLI/server/WASM-WebGPU, Ollama); the builder-querier to sift-kg’s builder · source · T3 · github.com
• claude-opus-4-8 — Anthropic frontier LLM; the model substrate under the ecosystem
• claude-fable-5 — Anthropic frontier LLM (9 Jun 2026); succeeds Opus 4.8 in the substrate role; 2× price; guardrailed Mythos-5 sibling
• claude-mythos-5 — Anthropic’s unrestricted Mythos-class model (9 Jun 2026); same model as Fable 5, safeguards lifted; trusted-access only (Project Glasswing)
• lean-theorem-prover — interactive proof assistant for formal math (cluster E)
• alphaproof — DeepMind’s Lean-based AI prover; the AI↔formal-methods bridge (cluster E)
• lean-certificate — a machine-checkable proof shipped with a result, so trust rests on a kernel not on the announcer; certifies validity only — not significance, provenance, or that the formalized statement is the right one (cluster E)
• abduction — the third inference type: inventing the axioms rather than consuming them; the arrow before the one cluster E has been mechanizing (cluster E)
• llms-cant-jump — Zahavy (DeepMind, 2026-01-27): induction mastered, deduction being conquered (alphaproof), abduction structurally missing — argued via General Relativity, where the data was too scarce for compression; proposes action-controllable world models as the bridge · source · T1 · tomzahavy.com
• llms-cant-jump-press — Wccftech’s version: the same paper as “LLMs will never replace human genius.” The concession, the physical-sciences scope limit and the words “position paper” all lost in transmission — a cluster-F specimen with the primary alongside it · source · T4 · wccftech.com
• tom-zahavy — DeepMind researcher; co-author of alphaproof arguing the limits of the programme he helped build (cluster E)
• tla-plus — Lamport’s spec language + model checking (TLC); the verify-systems wing of formal methods (cluster E) · source
• formal-verification — Wikipedia survey: the map cluster E grew without — model checking vs deductive verification vs abstract interpretation, seL4/CompCert/CertiKOS, and the field’s own three limits (state explosion, cost, the specification problem). Hardware verifies routinely, software rarely — an economic asymmetry, not a technical one (cluster E) · source · T2 · en.wikipedia.org
• rocq — Rocq (formerly Coq, renamed 2025); the elder CIC proof-assistant peer to Lean; CompCert/Four-Color-Theorem legacy (cluster E) · source
• isabelle — Isabelle/HOL; generic LCF-style proof assistant (Cambridge/TU Munich); Isar + Sledgehammer; seL4 kernel verification; the third major prover (cluster E) · source

Synthesis

• synthesis — the evolving thesis, clusters A (KM) / E (formal methods) / F (diffusion & adoption of ideas), the agentic-tooling bridge, open questions + tensions