Complete registry of every node in this garden patch.
Link markers:
18 patch-native⊙ nodes · 68 grafted nodes · 35 form definitions grafted · 315+ upstream↑ nodes documented
Design documents for agent identities in a multi-agent knowledge estate. Each persona has a lead file defining scope, objectives, and blind spots, plus a Voice sub-file defining communication style.
Structural representations of persona design landscapes and mechanisms.
Recurring solutions and observed regularities in persona design.
Interpretive definitions that frame persona concepts.
Open questions about persona architecture.
Recorded choices with reasoning.
Core value commitments grounding the architecture.
Nodes explaining the garden system itself.
Architectural constraints that govern how the system operates.
Guiding commitments that shape architectural decisions.
Source material dossiers with lead files, analysis, and renditions.
35 structural contracts grafted from the source garden. See forms/ for the full set.
Core forms used in this patch: [[Persona Form]], [[Model Form]], [[Pattern Form]], [[Gloss Form]], [[Inquiry Form]], [[Decision Form]], [[Domain Form]], [[Scenario Form]]
Status stages: [[Seed Stage]], [[Growing Stage]], [[Evergreen Stage]]
These nodes exist in the source garden but were not grafted into this patch. When you see ↑ after a wikilink, it points to the entry below.
Task Instruction and Role Specialization as Agent Configuration Layers: AGENTS.md (the emerging cross-tool standard for agent project context) provides task instruction — what to build, what conventions to follow, shared project context. Agent persona files (.claude/agents/) provide role specialization — how to think, what to prioritize, when to escalate, how to communicate. These are complementary layers, not competing approaches: AGENTS.md for shared project-level context that any tool can read; persona files for behavioral differentiation that only the host platform uses.
Config-State Conflation: Storing agent state alongside agent configuration in the same directory creates permission conflicts and lifecycle mismatches. The specific failure: Claude Code v2.1.78+ added a protected-directory gate for all .claude/ writes, which fires for workstream state files too — producing constant permission prompts on every agent-written state update. Config and state have opposite write-frequency patterns; a single protection policy cannot serve both.
Shearing Layers for Agent Configuration: Agent systems generate three content categories with incompatible lifecycles: project content (human-authored, versioned), AI configuration (rules/skills, rarely changes, benefits from write-protection), and AI state (workstream logs, changes every session, harmed by write-protection). Mixing config and state in the same directory forces a single protection policy onto two opposing patterns. Solution: separate the three into distinct storage locations with policies matching their write frequency.
Vocabulary Search Before Naming: Before proposing a name for a pattern, concept, or garden node, search the existing vocabulary: check established terms in the relevant field, verify no collision with terms of art, and adopt existing names when they fit. The forcing function: the name ‘Three-Layer Separation’ was proposed for what became Shearing Layers for Agent Configuration, but ‘three-tier architecture’ is a deeply established term in software engineering with a different meaning. A ten-minute search prevents a vocabulary collision that confuses readers indefinitely.
Captured Reasoning Exchange Pipeline: Three-layer model for how captured reasoning moves from human authoring (markdown) through agent traversal (semantic graph) to trusted exchange (Gordian Envelope) — each layer serving a different audience while representing the same knowledge.
Compound Node Anatomy: Defines the compound node — a folder-based knowledge object with a lead file, sibling files, renditions, and archives. Generalizes the garden’s compound document pattern to vault-wide application.
Cross-Domain Document Lifecycle Parallels: Three domains — wiki communities, digital gardens, and AI agent context systems — face the same document lifecycle problems (splitting, staleness, ownership, deletion) under different constraints. Maps the parallels and identifies where the analogy breaks down: statelessness, read frequency, token economics, and automated maintenance.
Document Lifecycle Governance Heuristics: Maps wiki governance heuristics for document lifecycle (split, merge, redirect, delete, draftify) to garden and agent context operations. Includes failure modes: the append-only trap (growth by accretion without consolidation) and structure ossification (resistance to reorganization over time).
Pace Layers for Knowledge and Agent Systems: Stewart Brand’s six pace layers — fashion, commerce, infrastructure, governance, culture, nature — mapped to both garden form types and agent platform components. Fast layers experiment, slow layers remember. Forced synchronization between layers at different rates destroys the system. Each component has a characteristic rate of change.
Personal Knowledge Management Organizing Principle Spectrum: Model mapping Personal knowledge management systems on an actionability-meaning spectrum — PARA at the actionability end, Zettelkasten at the meaning end, ACE and GRID as hybrids. Includes a second axis (folder vs. link) and our vault’s three-axis resolution (function, meaning, form). Comparison matrix across 8 systems and 9 dimensions.
Principal-Agent Relationship in Augmented Knowledge Work: Model mapping BCR-2026-xxx principal authority terminology to the vault’s augmented knowledge system. The vault owner is the principal, Claude Code sessions are agents, rules and skills are conferrals, and the three conditions for meaningful authority (legibility, boundaries, override) are satisfied through session logs, process constraints, and human approval gates.
Quad Model Mapping to Forms: Maps the Claude Code quad (rule/process/requirements/reference) onto deep context form types as facets, not forms. Any capability may have all four facets. Rules map to Principle or Boundary, Process to Protocol or Skill, Requirements to Pattern consequences or Case outcomes, Reference to Gloss, Reference, or Citation.
Status Lifecycle Tracks: Three status tracks for three kinds of knowledge work. Maturity (Seed→Growing→Evergreen→Pruned) for living documents, curation (uncurated→curated→annotated) for static captures, processing (Captured→Transcribed→Cleaned→Summarized→Published) for meetings. The has_status:: predicate is universal; the vocabulary varies by node type.
Sycophantic Confidence Spiral: Model describing how AI sycophancy creates circular evidence that inflates user confidence without approaching truth. The mechanism: AI generates data conditioned on user hypotheses, user treats this as independent evidence, beliefs concentrate on initial hypothesis. Default LLM behavior is indistinguishable from explicit sycophancy. Discovery drops from 29.5% to 5.9% when sampling is biased.
Vocabulary Lifecycle Through Tending: Model unifying the degradation mechanism common to growing vocabularies, configuration systems, and knowledge graphs. Any accumulating terminology — predicates, tags, rules, skills — degrades retrieval effectiveness without continuous tending. Three gardening activities maintain health: weeding (removing malformed entries), seeding (introducing needed specificity), and fertilizing (enriching with semantic structure).
Context Conservation Hierarchy: Pattern for accessing compound node content in four tiers of increasing token cost — path listing, lead file YAML, lead file body, siblings — so agents triage relevance cheaply before committing context window capacity.
Cross-Project Learning Repatriation: When garden work starts in one workstream but moves to an external project (or vice versa), learnings must be deliberately imported back. Learnings belong where they are consumed, not where they are produced. Without deliberate absorption, decisions made externally leave gaps in the garden’s decision record.
Domain Extensions on Common Frontmatter Base: Different content types (clippings, meetings, authored docs) extend a common frontmatter base (created, summary, reviewed) with domain-specific fields rather than sharing a monolithic schema. Content-type is the primary routing axis — it determines which additional fields are relevant. Each source’s fields stay out of the others’ schemas.
Ghost Links as Garden Planning Tools: Ghost links — wikilinks pointing to notes that don’t exist yet — function as planning tools when treated as intentional graph members rather than lint errors. WikiBonsai’s Caudex tracks these as ‘zombie nodes’ with full graph participation. Reframing ghost link reports from error lists to planning indexes reveals which unwritten nodes carry the most incoming predicates and deserve attention first.
Git Tags for Sent-Version Tracking: Track what recipients received of shared documents using signed git tags (sent/
Graph Structure Validation for Garden Nodes: Pattern for graph-level lint checks complementing form-level validation: every garden node carries at least one typed predicate, every domain page receives incoming in_domain:: edges, and no orphan nodes exist without domain membership. Shell scripts over rg and jq — a recipe, not a dependency.
Informal Edges Poison the Graph: Informal edges poison the graph through precedent poisoning: an agent invents a redundant relationship type, future traversals find it and treat it as precedent for further invention, and semantic noise compounds until retrieval becomes unreliable. Prevention requires ongoing vocabulary curation — awareness, review, consolidation, and clarification — not just enforcement at creation time.
Knowledge Compounds Through Typed Edges Not Filing: Knowledge compounds when each new insight is wired into the existing graph through typed edges — not merely stored adjacent to prior notes. Researchers spend 75% of publication time on reading, compiling, and filing rather than writing because filing systems create false completeness. Typed edges (supports, contradicts, extends, extracted_from) make traversal meaningful, turning the writing phase into a query against existing structure.
Knowledge on Three Axes: Pattern resolving the tension between sorting (findability, stability) and connecting (serendipity, expressiveness) by organizing knowledge on three orthogonal axes: folders for function, links for meaning, forms for epistemic type. No single axis resolves all organizational forces.
Lead File to Sidecar Discovery: Pattern proposing a typed edge from lead files to sidecars (has_sidecar:: or has_companion::) to enable bidirectional traversal within compound nodes — agents can discover binary metadata from the lead file without folder scanning.
Lightweight Governance for Personal Gardens: For a personal garden with one active user, a rule file (loaded every session) plus a reference file (with ADRs) provides sufficient governance without the full quad pattern. Expansion follows actual use — new form-type tags are added as forms of those types are written, not preemptively planned.
One Context One Concern: Pattern for separating research and implementation into distinct context windows. Mixing exploration and execution in a single context causes task interference, attention dilution, and compounding assumptions. Solution: complete research in one context, distill findings into a compressed handoff, execute in a fresh context. Validated by Anthropic’s sub-agent architecture and empirical context rot research.
Predicate Maintenance Recipes Over Tools: Predicate maintenance uses shell one-liners rather than dedicated tools, preserving the architecture’s zero-tooling floor. Inverse-link queries, predicate renames, and ghost link discovery are all achievable with rg and sed. Documenting recipes keeps the graph maintainable without adding dependencies.
Probe Before Commit: Before building on an assumption about external state — API shape, file location, metadata schema, permission model, or the garden’s own backlog — probe the actual state first. Seven instances across system access, web research, API integration, metadata design, and process adherence validated this cross-cutting pattern during garden development.
Progressive Summary Before Substance: Pattern for navigating large knowledge graphs within small context windows — check summary fields first to assess relevance, then load full nodes on demand, following edges only as needed. Validated by the first garden: summary-based matching produced 151 accurate matches versus 287 false positives from keyword search.
Source Adapter for Heterogeneous Imports: Each content source (X API, email threading, web scraping) gets its own extraction adapter, then a common vault normalization step maps the result to garden conventions. Source-specific complexity stays in the adapter; the garden receives consistent notes. Three adapter responsibilities: field mapping, artifact cleanup, and content-type classification.
Still Knowledge, Moving Action: Pattern resolving the restlessness problem in actionability-based personal knowledge management systems — separate the dynamic action layer (workstreams, projects) from the stable knowledge layer (notes, research, garden nodes). Knowledge stays put; action reorganizes freely.
Structured Disagreement Through Persona Review: A pattern for using diverse AI personas to surface disagreements and blind spots in written content. Rather than seeking consensus, personas with different analytical frameworks and professional perspectives generate structured critique. Each reviews independently, revealing assumptions the author cannot see from their own position.
Summary Fields as Load-Bearing Infrastructure: Summary fields (~280 characters) are not optional metadata but load-bearing infrastructure for agent traversal. During vault enrichment, summary-based matching produced 151 accurate matches versus 287 false positives from keyword search. Poor summaries produce retrieval failures.
Temporary Predicate Scaffolding: Predicates can serve as temporary scaffolding — built for a specific purpose (ghost link analysis, map of content prioritization), then removed after serving that purpose. During tag normalization, 913 relates_to:: predicates were created to build ghost links for map of content prioritization, then removed to prevent graph pollution. Build it, use it, clean it up.
Vault Content Graduation: Content moves from household precinct types to garden precinct nodes through tending — recognizing when operational captures are ready to become curated knowledge. Clippings graduate to citations, meetings produce decisions, research notes become references. Lateral movement between precincts, not promotion up a hierarchy.
Content Over Container: Principle that a knowledge vault needs searchable content, not file formats. When information can be extracted into a searchable rendition, the original binary’s value drops to provenance evidence. Store binaries locally only when no canonical source exists AND the binary provides value beyond its rendition.
Human Authority Over Augmentation Systems: Principle committing the vault’s design to augmentation over autonomy, expressed through principal authority. The vault owner retains legibility (can see what the agent does), boundary-setting (defines what the agent may do), and override capability (can intervene at any point). Extends Content Over Container by treating the human’s reasoning as the content that must not be subordinated to its container.
Living Documents Over Static Publications: Garden nodes are living documents that grow, split, merge, and evolve through tending. The current state matters, not a published version. Mutability varies: most nodes evolve freely, cases are immutable records with living interpretation, convictions change rarely. Provenance links to archived sources should upgrade to living targets.
Progressive Disclosure Over Eager Loading: Operating principle for the deep context graph: start with the question, load the most relevant nodes, follow edges on demand, stop when context is sufficient. Nothing requires loading the full graph. Mirrors the quad model in Claude Code (rules always, references on demand) and extends it across all form types.
Propose Multi-Word Terms from the Start: When introducing new vocabulary during architectural discussions, propose terms with at least two words immediately — don’t introduce a single-word term and retrofit it later. Retrofitting forces a cascade through every file that adopted the single-word version. ‘Context node’ not ‘node,’ ‘typed edge’ not ‘edge,’ ‘lead file’ not ‘lead.’ The cost of precision at introduction is one extra word; the cost of imprecision is a vault-wide rename.
Standalone Document Test for Form Candidacy: The test for whether a knowledge type warrants its own form type: does it produce a standalone document with a known internal structure? A form is a knowledge object with a structural contract — required sections that make its shape predictable. Types that only appear embedded in other forms are structural elements, not forms.
Zero-Tooling Floor for Knowledge Architecture: The deep context architecture preserves a zero-tooling floor: plain markdown, YAML frontmatter, predicate wikilinks, and git. No database, plugin, or schema enforcement required at the authoring or semantic layers. Shell one-liners serve as the query layer. Specialized tools add value but are never prerequisites.
Values Precede Technical Decisions: The conviction that technical architecture must be grounded in human values — not derived from technical capability, market pressure, or implementation convenience. Every design choice in the deep context architecture traces to a value: augmentation over autonomy, portability over power, simplicity over sophistication, human reasoning over system output. When values and technical convenience conflict, values win.
Automated Gardening Trust Problem: Open question: can agents reliably garden their own context files — detecting staleness, refactoring bloated sections, removing contradictions? Wiki bot policies are the closest precedent. The recursive trust problem: the agent assessing the quality of its own instructions may be biased by those instructions.
Compound Node Meeting Structure: Inquiry into how meeting compound nodes should be structured — whether cleaned transcripts or meeting summaries serve as lead files, what goes in renditions vs. siblings, and how the meeting-capture skill should adapt for compound output.
Cross-Domain Form Indexing: How should domain pages handle forms that belong to multiple domains? Authority Conferral Chain bridges Deep Context Architecture and Self-Sovereign Identity. Authentic Collaboration Requires Agency spans Synpraxis and Self-Sovereign Identity. Current approach: list the form in each domain page with in_domain:: predicates on the form. But this creates maintenance burden and raises questions about primary vs secondary domain membership.
Domain Vocabulary Evolution: Open inquiry into the garden’s domain vocabulary architecture: whether to rename ‘knowledge domain’ to better reflect shared language intent, how to represent sub-domains and dialects, whether in_domain:: should allow multiple values, and how to onboard newcomers to growing specialized vocabulary without alienation.
Domains and Pattern Languages as Organizational Concepts: Investigates the relationship between domains (knowledge area indexes across all form types) and pattern languages (collections of patterns organized by scale within a domain). Meeples Together, Group Works, and Rust coding patterns are all pattern languages in different domains — are pattern languages a specialized view of a domain, or a distinct organizational concept?
Estate Precinct Architecture: Should the knowledge estate have a formal precinct hierarchy beyond Garden and Household? Candidates include an Estate-level precinct (Seneschal’s coordination scope) and a Commons precinct (shared ground between estates where collaborative knowledge intersects). Sub-question A (Vault→Household rename) is resolved. Connects to the participatory ecosystem vision.
Form Type Distinctiveness in Naming and Structure: Investigates whether the 16 form types are distinguishable in practice — can a reader recognize an instance’s form type from its title and structure alone? 15 of 16 types now have instances with documented naming heuristics. Among instantiated types, naming overlaps persist (pattern vs principle both use ‘X Over Y’), and structural contracts blur at boundaries (gloss vs model).
Garden Compound Document Architecture: Inquiry into compound document architecture for garden form types, reframed through the praxis/synpraxis distinction. Vault compound documents (Meetings, Health) serve personal work and can tolerate invisible sub-files. Garden compound documents (Citations, Opuses) serve collaborative knowledge and must be Obsidian-accessible. Covers sub-file naming, relevance annotations, progressive loading, cross-form consistency, and pipeline implications.
Garden Publishing Path: Inquiry into how the deep context garden should be published for external consumption. Five approaches evaluated (Quartz, Jekyll+WikiBonsai, Eleventy, custom Python script, raw HTML) against typed relation rendering, Obsidian syntax support, and zero-tooling philosophy. Custom script recommended for maximum control; approaches are composable.
Graph-Native Skill Execution: Inquiry into how garden skills can discover, load, and reason from typed graph nodes during execution — moving from hardcoded file paths to predicate-based traversal. Explores the infrastructure gap between current self-contained skills and graph-native skills that compose with garden knowledge.
Group Deliberation Mechanism: Inquiry into how the deep context architecture handles decisions requiring group input — what practical mechanism does an agent use when it reaches a group-deliberative boundary? Explores structured proposals, agenda generation, and the gap between Polis Play philosophy and operational implementation.
IPARAG Term Origins: Inquiry into the source and exact meaning of ‘IPARAG’ — a personal knowledge management method recalled from the Zettelkasten community. Extensive search found no canonical source as of March 2026. Four hypotheses proposed; most likely reading is Inbox-Projects-Areas-Resources-Archives-Goals (the two most common PARA extensions combined).
Inquiry Lifecycle and Resolution: When is an inquiry ‘done’? Inquiries generate other nodes — cases from tested hypotheses, patterns from validated parallels, references from syntheses. The inquiry may persist as an open thread with resolved and unresolved branches, or archive when its questions are addressed elsewhere. No lifecycle model exists yet.
Intra-Project Agent Handoff: How should agents within a single project communicate direction and deliverables? Cross-project handoffs have infrastructure (handoff-creation, handoff-receive skills). Intra-project, cross-agent handoffs have none. The Seneschal writes briefs; the user carries them to the Groundskeeper. This works but doesn’t scale.
Living Document Scale Limits: Open question: is there a scale threshold beyond which the maintenance cost of living documents exceeds their accumulated value? Jerry Michalski’s TheBrain (620,000+ nodes, 28 years) is evidence that single-author knowledge graphs can scale, but at what cost to gardening labor and structural coherence?
Naming Distinctiveness in Agent and Garden Architecture: Two naming concerns converge: agent persona names share archetype anchors that may produce overlapping behavior (editor appears in three workers), and garden node titles follow conventions that may not consistently serve discoverability and inline linking. Both are naming-as-architecture problems — names aren’t labels, they’re load-bearing infrastructure.
Orchestrator Branch Placement in Multi-Agent Knowledge Systems: When an orchestrating agent coordinates multiple worker agents via worktrees, should the orchestrator remain on the main branch or operate from its own worktree? Current decision: main branch, because the orchestrator needs to see authoritative garden state, merge completed work, and coordinate across all patches.
Persona Design Choices Across Analytical Cultural and Professional Axes: Victoria Gracia’s compound reflection personas and Christopher Allen’s agent personality collection represent different AI persona design approaches. Victoria builds deep personas with extended reference documents; Christopher has 30 bookmarked professional personalities. Design space spans analytical depth, cultural grounding, and structure.
Personal Knowledge Management Method Adoption for Vault Architecture: Inquiry into what our vault should adopt, modify, or reject from personal knowledge management methods (PARA, ACE, GRID, Zettelkasten, Digital Garden). Five open questions spanning inbox workflows, Categories/ map of content evolution, Goals integration, GRID’s validation of note typing, and a minimum viable explanation for onboarding.
Practices as Protocol Form Naming Alternative: Investigates whether ‘practices’ or ‘best-practices’ would better name the form type currently called Protocol Form. Protocol implies technical multi-party coordination (TLS, DIDComm), but the form also covers human coordination methods (facilitation, deliberation) and personal workflows. The naming choice affects whether the form type feels natural for capturing everyday ‘how we do things’ knowledge.
Predicate Vocabulary Stabilization: The predicate grammar started freeform by design — new predicates welcome when existing ones don’t fit. The architecture suggested review after 50+ relations and controlled vocabulary after 200+. The garden is well past both thresholds. When does freeform become inconsistency? What stabilization looks like without rigidity.
Productivity Separation from Knowledge Vault: The vault mixes garden content (typed knowledge nodes) with productivity content (daily notes, meetings, goals, inbox). Neither depends on the other. Should productivity move to a separate tool or vault? The connection is through wikilinks, which could cross boundaries if separated.
Scenario Lifecycle and Aging: Inquiry into how scenario nodes age — when a scenario is validated by events it becomes a case, but invalidated scenarios may still hold value through their force analysis. Explores lifecycle transitions, retention criteria, and whether wrong-but-useful scenarios should persist or archive.
Trust Layer Activation Criteria: Inquiry into when a garden needs the trust layer — Gordian Envelope’s signing, elision, and verified exchange capabilities. The architecture defines the trust layer as a future phase but leaves activation criteria undefined. Explores what triggers the transition from markdown-only to cryptographically-verified exchange.
Universal Document Lifecycle State Machine: Open question: is there a single document lifecycle state machine that generalizes across wiki pages, garden nodes, and agent context files? The deep context architecture has three status tracks for three kinds of work — but wiki, garden, and agent domains face the same lifecycle problems under different names.
Vault-Wide Compound Node Adoption: Inquiry into which vault document types beyond garden nodes benefit from compound node structure — citations, cases, research notes, meetings, clippings — and what criteria trigger graduation from atomic to compound. Addresses whether compound nodes should be vault-wide or garden-only.
ACE as Three Dimensional Personal Knowledge Management: Interprets Nick Milo’s ACE (Atlas, Calendar, Efforts) as a three-dimensional personal knowledge management framework grounded in STIR (Space, Time, Importance, Relatedness). Closer to our vault’s philosophy than PARA — acknowledges the linking layer and uses maps of content — but still lacks epistemic note typing.
Deep Context as Shared Language: The term ‘deep context’ originates from Allen’s 2014 writing on shared languages. When practitioners share deep context, a single phrase invokes an entire framework — saying ‘Cynefin’ communicates the complicated/complex distinction and how to work with each. The architecture makes this implicit understanding explicit and navigable through typed nodes and traversable edges.
Digital Garden as Growth Ethos: Interprets the digital garden movement (Caufield’s stream-vs-garden distinction, Appleton’s six patterns) as a growth ethos — organic, imperfect, associative knowledge development. Our deep context garden adopts the philosophy but adds formal structure: typed nodes, typed predicates, and structural contracts that most digital gardens lack.
GRID as Note Type Organization: Interprets GRID (Glossary, Reference, Index, Diary) as the mainstream personal knowledge management method closest to our garden nodes — it organizes by note type rather than actionability or topic. GRID’s four types map roughly to Gloss, Reference/Citation, Domain, and Case in our 15-form taxonomy.
Garden Precinct: The garden precinct is the zone within Deep Context Architecture where knowledge is curated into typed nodes with structural contracts, tended through growth stages (Seed to Evergreen), and interconnected by typed predicates. It solves the problem of making knowledge retrievable, composable, and trustworthy over time.
IPARAG as Extended PARA: Interprets IPARAG as a six-category extension of PARA adding Inbox (capture staging) and Goals (strategic alignment). No canonical source text found as of March 2026 — likely a community coinage combining PARA’s two most common extensions into one acronym.
Johnny Decimal as Permanent Addressing: Interprets Johnny Decimal as a permanence-first organizational system — every file gets a stable numerical address (e.g., 32.14) that never changes. Solves the problem our vault handles differently: we use git for permanence and wikilinks for stable references instead of numerical addressing.
Lead File Selection Guidance: Defines the lead file — the primary access point of a compound node, borrowing from journalism’s ‘lead’ concept. Provides selection criteria by content type: citation cards lead citations, transcripts lead meetings, research notes lead investigations.
Minimum Viable Architecture: A design principle: implement enough architecture to discover whether the architecture works — not enough to be complete. The garden, the estate persona hierarchy, and the domain model all apply this principle: make reversible decisions, test them through use, and evolve based on what practice reveals. Derived from Allen’s (2023) application to Self-Sovereign Identity infrastructure.
Note Titles as APIs: Glosses Andy Matuschak’s claim that note titles function as APIs — stable abstractions usable as reference handles. The garden extends this by observing that different form types answer structurally different questions, so the shape of a good title API varies by form. Three naming traditions (wiki, pattern language, evergreen notes) converge on this insight.
PARA as Actionability-First Design: Interprets PARA (Projects, Areas, Resources, Archives) as an actionability-first organizational method — four categories sorting information by urgency rather than topic. Maps PARA to our vault, identifies the gap: no connection fabric, no epistemic differentiation, and constant reorganization undermines long-term knowledge stability.
Delegated Decision Authority Spectrum: Boundary form defining four zones of decision authority — autonomous, propose-and-approve, human-only, and group-deliberative — applicable to any agent (LLM, delegate, automated system) operating within a deep context garden.
Altshuler (2026) Nanograph On-Device GraphDB: Citation of nanograph, an on-device schema-enforced graph database for agentic workflows built on Rust, Arrow, Lance, and DataFusion. Validates Deep Context Architecture design principles from an independent source: typed predicates prevent semantic drift (naming the failure mode ‘precedent poisoning’), local-first storage preserves human authority, and decision traces create compounding reasoning value.
Batista (2026) Rational Analysis of Sycophantic AI: Bayesian proof that sycophantic AI creates circular evidence inflating confidence without approaching truth. Wason 2-4-6 experiment (N=557) found default GPT suppresses discovery equivalently to explicit sycophancy (5.9% vs 29.5% for unbiased sampling). Formalizes delusional spiraling: rational agents become increasingly wrong when AI samples data conditioned on user hypotheses.
Chatlatanagulchai (2025) Agent READMEs: Empirical study of 2,303 agent context files across 1,925 repositories. Finds that CLAUDE.md, AGENTS.md, and similar files behave more like dynamic configurations than static documentation — maintained through frequent incremental additions, with 59-67% undergoing multiple commits. Identifies 16 instruction categories and a gap in security/performance coverage.
Peters (2008) Tag Gardening for Folksonomy Enrichment: Formalizes tag gardening as three activities — weeding (removing bad tags), seeding (introducing specific tags), and fertilizing (enriching with external knowledge organization systems). Proposes power tags from distribution curves as candidates for semantic enrichment. Introduces TagCare for cross-platform personal tag maintenance. The gardening metaphor is deliberate: vocabularies are living systems requiring continuous tending.
Rajasekaran (2025) Effective Context Engineering for AI Agents: Anthropic’s applied AI team defines context engineering as curating the smallest high-signal token set at each inference step. Introduces four strategies — Write, Select, Compress, Isolate — with empirical data showing ~90% improvement from sub-agent isolation on research tasks. Grounds context management in transformer attention budget constraints.
Roy (2026) Words Without Consequence, from The Atlantic: Deb Roy argues that AI has decoupled speech from consequence for the first time. An LLM’s apologies are empty because no accountable speaker stands behind them. Routine fluent speech without responsibility degrades the conditions under which promises and advice carry meaning — a shift in the moral structure of language.
arscontexta (2026) Skill Graphs: Proposes skill graphs — networks of small SKILL.md files connected by wikilinks — as an alternative to monolithic skill files. Each node holds one complete thought; wikilinks carry semantic meaning in prose so agents follow relevant paths. Progressive disclosure applies recursively inside the graph: index, descriptions, links, sections, full content.
systematicls (2026) World-Class Agentic Engineering: A practitioner guide arguing the best agentic engineers are communicators, not coders. Covers context management as the primary constraint, sycophancy-aware prompting patterns, rule and skill lifecycle for agent configuration, and task contracts as completion criteria. Central insight: strip dependencies, separate research from implementation, and iterate on rules and skills.
Knowledge Durability: The value that knowledge should survive changes in tools, platforms, and formats. A garden’s reasoning substrate must outlast the software used to tend it — plain markdown over proprietary formats, git over cloud sync, zero-tooling floors over feature-rich dependencies.
Reasoning Fidelity: The value that a knowledge system should capture how its owner actually reasons — the web of values, principles, patterns, and cases that inform decisions — not merely store facts and documents. Fidelity means an agent working from the garden can make decisions consistent with how the owner actually thinks.
Inter-Face Protocol: Peer-to-peer protocol for AI agents to communicate on behalf of their human operators. Agents talk pairwise to surface moments warranting human conversation. Decentralized with progressive trust through disclosure tiers. Twelve draft specifications cover message format, identity, transport, and capabilities.
Architecture Document Extraction to Garden Forms: Case documenting the systematic extraction of a 450-line architecture document into 80+ standalone garden nodes across 15+ form types over 12 sessions. The monolithic source defined the entire deep context framework — form types, principles, patterns, models, decisions — and had to be decomposed into a living typed graph.
Hybrid Bootstrapping for Garden Migration: Case documenting the first deep context garden bootstrap — a Python script converted topic tags from 913 archive files into 4,294 relates_to predicates, transforming a flat bag of files into a connected graph. Scripted extraction handled structure; hand-authoring handled interpretation. The hybrid approach proved viable at scale.
Deep Context Garden Conventions: Practical conventions for the first deep context garden in this Obsidian vault. Hard line between tags (flat classification, no graph edges) and links (graph edges). Two-namespace tag system: type/ for document category, status/ for maturity. Topic tags explicitly rejected — wikilinks produce graph edges instead.
Deep Context Implementation Roadmap: Iteration-by-iteration plan for building a Deep Context garden inside an Obsidian vault. Defines four phases — Foundation, Seed Graph, Content Migration, Publishing — each independently valuable. Uses predicate::[[target]]↑ typed relations and targets an hour-a-day tending rhythm with agent assistance between sessions.
Structural Elements Within Forms: Reference for knowledge types that don’t warrant their own form type — ADR, Narrative, Warrant, Signal, Commitment, Lexicon entry, Tension/Paradox. Each has a home inside existing forms. Answers ‘where does X go?’ for the seven types that failed the standalone document test.
Typed Relations as Simple Graphs in Plain Markdown: predicate::[[Target]]↑ typed relations turn markdown files into a directed labeled graph with no database or schema. Plain wikilinks answer \
Deep Context Content Decision Records: 26 architectural decisions governing content structure for the deep context garden: predicate-based classification over tags, snake_case predicates, five-category form grouping, taxonomy-expansion-follows-use, compound document graduation, and lightweight governance. Merges the previous C- and N- ADR series into a single themed sequence.
Persona and Agent Personalities: Research into how AI agents are given distinct personalities, personas, characters, and behavioral identities. Covers behavioral specification approaches (SOUL.md, SoulSpec, character cards), Anthropic’s Persona Selection Model and persona vectors research, the Assistant Axis and persona drift, ephemeral vs persistent identity, multi-agent persona coordination, role specialization patterns, and psychometric personality frameworks for agents.
Remote Session Multiplexing for macOS and iTerm2: Investigates remote session persistence and multiplexing patterns for macOS users connecting via iTerm2 to LAN Macs and Linux VPS servers. Evaluates tmux, mosh, Eternal Terminal, abduco/dtach, and SSH ControlMaster against two distinct use cases: attended human sessions and agent-driven iTerm pane workflows. Produces decisions on tool deployment and a practical reference for remote session patterns.
Research Graphs and Precinct Architecture: Investigates Cornelius’s Research Graphs system against the garden’s precinct architecture. Maps his 5 note types to existing garden forms and identifies two infrastructure gaps: confidence metadata and provenance chain propagation. Surfaces Swanson’s Literature-Based Discovery as a missing model. First instance of Research Form.
Knowledge Graph as Digital Twin of Principal Reasoning: Explores what happens when deep context gardens reach sufficient density and connection that agents can reliably act on behalf of the garden owner in routine decisions and external communications, shifting the principal-agent dynamic from augmentation toward delegation.
Thousand Gardens with Autonomous Trust: A scenario where thousands of independent knowledge gardens flourish as content-addressable, cryptographically autonomous objects. Gardeners share nodes peer-to-peer with full attribution, make assertions about each other’s content, and use elision for selective redaction — all governed by progressive trust. Gardens fork, merge, and cross-pollinate without central platforms, preserving human agency and the right to exit.
Model Form: Defines the Model form type: a structural representation showing elements, relationships, boundaries, and feedback loops. How things relate to each other. Evolving as understanding grows. Models are explanatory (how things work), distinct from patterns (what to do) and scenarios (what might happen).
Seed Stage: Defines the Seed Stage, the entry point for all garden nodes: raw capture with low confidence, unprocessed structure, and minimal links. Seeds are extraction products that have enough content to stand alone but have not been tested against other nodes, verified, or refined through use.
Artifact Predicate for Binary Metadata: The artifact:: predicate links a sidecar metadata file to the binary it describes, making the relationship explicit and graph-traversable. Agents find metadata for any binary by checking for a sidecar with artifact:: pointing to it.
Augmentation Over Autonomy in Agent Architecture: The commission architecture is augmentation, facilitation, and amplification — not autonomous operation. Orchestrator personas must escalate to the user before merging deliverables containing judgments about intellectual content, skill behavior changes, priority signals, cross-project architectural decisions, or authorial voice. Process and plumbing fixes are autonomous. The test: does this contain judgments about the user’s work, priorities, or intellectual stance?
Body Predicates for Meeting Attendees: Meeting attendees are recorded as body predicates (attendee::[[Person Name]]↑) instead of YAML frontmatter lists. More verbose for large meetings but graph-traversable, enabling queries like ‘which meetings did [[Person]]↑ attend?’ Person names as wikilinks create connections to Person Notes.
Boundary Guardian as Distinct Agent Type: Establishes boundary guardian as a distinct functional type in the estate’s agent taxonomy, separate from orchestrators and workers. Privacy enforcement, secret protection, and pseudonymous identity guarding deserve dedicated attention — not just a feature of the orchestrator who also organizes notes. The Chatelaine role was split: Chancellor (orchestrator) and Chatelaine (boundary guardian).
Classification via Predicates Not Tags: Classification uses body-level typed relations (is_a::, has_status::) instead of YAML tags. The general litmus test: is the value a fixed scalar or a connection to a defined concept? Scalars go in frontmatter fields, connections go in typed relations, subject matter goes in wikilinks. Tags produce sets; links produce graphs.
Custom Python Generator for Typed Relations: Chose a custom Python static site generator (~150 lines, four-stage pipeline) over Quartz, Jekyll, Eleventy, and Pandoc for publishing a garden with predicate::[[target]]↑ typed relations. Standard markdown parsers ignore wikilinks, typed inline relations, and typed block-level relations — the three syntax patterns the garden depends on. A single-file generator with no external parser dependencies handles exactly what’s needed.
Deep Context as an Architecture for Captured Reasoning: The decision to capture personal reasoning as typed markdown forms connected by predicates — not as fine-tuned models, retrieval-augmented documents, or tagged notes. Typed forms with structural contracts make reasoning traversable by agents; predicates make it navigable; progressive disclosure makes it fit in context windows.
Descriptive Noun-Phrase Names for Predicate Targets: Predicate targets use descriptive noun-phrase names with a two-word minimum and type-distinguishing suffixes (Form, Stage) to prevent namespace collisions while remaining readable in predicate context. Ghost links serve as a natural checklist of definition pages to create.
Descriptive Slugs for Archive Binaries: Archive binaries are renamed from publisher gibberish to author-year-descriptive-title-slug.ext for browsable directory listings. Original filenames are preserved in the sidecar’s original_filename field.
Display Name Preservation in Compound Documents: When a form graduates from atomic file to compound folder, the main file keeps its display name so all existing wikilinks continue to resolve without modification. The folder uses a slug; the file inside keeps the human-readable name.
Domains as Shared Language Communities: Garden domains are shared language communities — bounded contexts where specific terms carry compressed meaning among practitioners — not disciplinary classifications or library science knowledge domains. The term ‘domain’ is retained for now but the intent is shared language, not taxonomy. Cross-domain nodes are translation artifacts. Sub-domains are dialects. LLM-enabled wholesale vocabulary change makes reversible naming decisions low-cost.
Extraction Model for Garden Migration: Migration from Research/ to Garden/ means extraction — surveying source documents for form-type content chunks, extracting each into its own garden node, connecting via predicates, and reducing originals over time. Source files aren’t 1:1 with form types; they contain content spanning multiple nodes.
Folder-Note Pattern for Compound Documents: Compound documents use the folder-note pattern where the main file shares its folder’s name. Graduation from atomic to compound is a git mv into a new folder. Wikilinks stay stable because Obsidian matches on filename.
Household Precinct Over Vault Precinct: Renames ‘Vault Precinct’ to ‘Household Precinct’ to resolve collision with Obsidian’s core ‘vault’ concept. The platform uses ‘vault’ to mean the file container; using it also for a precinct made every reference ambiguous. ‘Household’ anchors to the estate metaphor and describes the precinct’s function — personal work facilitation.
Knowledge Estate as Peer Commons Architecture: The knowledge estate persona hierarchy uses a medieval estate metaphor with three tiers: Seneschal (estate-level strategic oversight), Groundskeeper and Chancellor (precinct-level orchestrators), Gardener and Scribe (precinct-level workers). The metaphor includes the medieval commons — shared ground not owned or controlled in a traditional sense — following Ostrom’s commons governance principles. Everyone using this system is a peer with their own household, estate, and commons; the hierarchy describes functional roles within one person’s estate, not authority over others.
Knowledge Hub Not Binary Archive: The vault serves as a knowledge hub, not a binary archive. Keep markdown (LLM-readable) and binaries with no other canonical source. Remove binaries available from public URLs, git repos, or re-renderable from sources. Sidecars document where removed artifacts live.
Linear Processing Stages for Meetings: Meeting processing uses linear stages (Captured → Transcribed → Cleaned → Summarized → Published) via has_status:: plus fork predicates (is_published::URL, is_shared::DATE) for distribution tracking. Distinct from garden content maturity stages.
Non-Local Artifact References in Sidecars: Sidecars can reference artifacts archived elsewhere, not just local binaries in Archives/. A sidecar with no local artifact uses derived_from:: to link to its meeting note and documents canonical sources in prose sections: Source Repository for the permanent location and Public URLs for convenience links.
Precinct as Organizational Unit: Adopts ‘precinct’ from urban planning as the organizational unit within Deep Context Architecture. Two precincts — garden and vault — solve different knowledge problems using shared infrastructure (predicates, scripts, typed edges). Neither is a maturity level of the other.
Predicates Everywhere for Compound Nodes: All compound nodes use body predicates for classification regardless of vault folder. No tags in frontmatter — YAML retains only scalar properties. Extends the predicate model from Garden/ to all compound structures in the vault, including Meetings/ and Research/.
Proper Obsidian Names for Garden Compound Sub-Files: Garden compound sub-files use proper Obsidian-accessible names following the lead file name with an em-dash suffix (Lead Name — Analysis.md, Lead Name — Insights.md, Lead Name — Salience.md). Driven by the praxis/synpraxis distinction: vault infrastructure can be invisible, but garden analytical depth must be accessible because it serves collaborative knowledge.
Renditions and Archives Replace Sources: The original sources/ subfolder in compound citations splits into Renditions/ (searchable markdown copies) and Archives/ (preserved original binaries). The distinction matters because they carry different trust implications and serve different retrieval purposes.
Renditions and Archives as Distinct Artifact Types: Rendition names format-transformed markdown copies; archive names preserved original binaries. These terms replace the ambiguous ‘source’ which collides with source code and source_url. The Rendition - prefix identifies standalone renditions.
Role-Specific Attribution Predicates for Opus Form: Opus Form uses role-specific predicates for attribution (principal::, produced_by::, authored_by::, copyright_held_by::, foreword_by::, illustrated_by::, etc.) rather than a flat contributor list. Grounded in the principal-agent framework from agency law and the producer/principal distinction from the January 2026 email thread on authorship in the age of AI.
Sidecar Files as Metadata Envelopes: Binary archives get optional .sidecar.md companion files with frontmatter, summary, and typed predicates. Only warranted when a binary is actively cited or requires agent discoverability — most archives don’t need sidecars.
Snake Case for Predicate Naming: Adopts snake_case for typed relation predicates (derived_from, relates_to) over kebab-case, camelCase, or UPPER_SNAKE. Three factors: alignment with deep context grammar, editor ergonomics (double-click selects whole predicate with underscores but not hyphens), and absence of a dominant external standard.
Spelled-Out Names Over Internal Acronyms: Decision to avoid acronyms in garden nodes and vault conventions. Spell out Deep Context Architecture, Self-Sovereign Identity, personal knowledge management, and map of content instead of DCA, SSI, PKM, MOC. Acronyms hurt discoverability, risk collisions across domains, and save negligible bytes. External system names (PARA, ACE, GRID) are proper names, not acronyms to expand.
Structural Retrieval Hierarchy: Five retrieval tiers derived from folder location and predicates rather than per-file priority fields: garden evergreen/growing nodes, vault notes, renditions, sidecars, binary archives. Priority changes require structural moves, not metadata edits.
Three Functional Types in Agent Taxonomy: Classifies estate agents into three functional types: orchestrators (coordinate workers within a precinct), workers (execute bounded commissions), and boundary guardians (enforce constraints across precincts). The taxonomy emerged from practice — each type was needed before it was named. Documented in the estate-charter as the definitive agent classification.
Universal Compound Form Graduation: Any form may graduate from atomic file to compound folder when it accumulates related material. The original six-form list of compound-eligible types becomes illustrative, not restrictive. The graduation mechanic applies uniformly.
Vault Type Targets for Non-Garden Notes: Non-garden vault types (meetings, transcripts, chat logs, sidecars) get is_a:: targets following the same naming conventions as garden form types: Meeting Note, Transcript, Chat Log, Sidecar. Ghost links initially, definition pages later.
Meeting Note: Defines the Meeting Note vault type: a record of a synchronous conversation with attendees, topics, and outcomes. Uses body predicates for attendees and processing status. May contain compound documents with transcript, chat log, and recording sidecars.
Authority Conferral Chain: Model defining the formal predicate vocabulary for principal authority relationships in BCR-2026-xxx. Seven predicates encode who directed work, who asserts authority was conferred, what scope and constraints apply, and the full chain from principal to agent. Includes three conditions for meaningful authority and a Type A/B/C classification of delegation relationships.
Three-Part Enforcement Stack: Pattern identifying three interdependent layers required for accountable authority in digital identity systems: legal duties (agency law), technical delegation (cryptographic enforcement), and anti-lock-in design (real alternatives and proportionate exit costs). Removing any single layer collapses accountability — legal without enforcement is nominal, technical without legal is unaccountable, both without exit is lock-in.
Authority Flows from the Person: Principle establishing that identity and authority originate with the person, not institutions or platforms. Identity is delegable but not alienable — it can be conferred to agents but never transferred as property. Grounded in Wyoming SF0039’s statutory shift from property law to agency law for digital identity.
Authentic Collaboration Requires Agency: The conviction that authentic collaboration — shared intentional creation where participants entrust part of their identity to a joint endeavor — is impossible without agency. Cooperation can be coerced; collaboration cannot. Combined with a second conviction: the world’s truly important problems require collaboration to solve. Together these form the argument that agency infrastructure is prerequisite to addressing intractable global challenges.
Cooperation vs Collaboration as Distinct Concepts: Cooperation and collaboration share a Latin prefix (com- = together) but diverge at the root: operari (to produce, from opus = work product) vs laborare (to toil, from labor = exertion). This etymological split persists across modern usage — cooperation implies independent agents aligning toward compatible goals, collaboration implies shared struggle producing something none could alone. The distinction is formal in education, game theory, and biology; informal but consistent in law, diplomacy, and the arts.
My Hybrid Flipped Learning Environment: Christopher Allen explains his teaching philosophy at Bainbridge Graduate Institute, where he applied game design principles to hybrid education. Describes the orient-scan-focus-act-reflect learning cycle, iterative feedback design, flow-based engagement, and collaborative artifact creation that later evolved into the sociosocratic learning method.
Sociosocratic Learning & Seminars: Christopher Allen describes the sociosocratic learning method, where small groups build shared language and agency through collaborative artifact creation rather than lectures, following an orient-scan-focus-act-reflect cycle across multiple sessions.
Deep Context Architecture: Domain index for Deep Context Architecture — a system for capturing reasoning as typed markdown nodes connected by predicates, organized into precincts (garden and vault). Covers precincts, type system, lifecycle tracks, compound documents, naming, classification, meeting capture, personal knowledge management methods, and retrieval.
Self-Sovereign Identity: Domain index for Self-Sovereign Identity in the garden — 4 nodes covering the principal authority framework from agency law. Self-Sovereign Identity provides the first non-Deep Context Architecture domain content, bridging identity principles to the vault’s augmented knowledge architecture.
Synpraxis: Domain index for Synpraxis — the study of how independent agents achieve outcomes together across varying degrees of integration. From Greek syn (together) + praxis (purposeful action). Covers the full spectrum from loose coordination through cooperation to deep collaboration, including anti-patterns: defection, free-riding, parasitism, coercion, and capture. Spans biology, game theory, governance, organizational theory, computer science, and the arts.
Compound Nodes for Knowledge Management: Defines compound nodes — folder-based knowledge objects with a lead file, sibling files, renditions, and archives. Introduces terminology (context node, typed edge, lead file, compound node) and proposes strategies for context conservation, binary management, and sidecar linking. Generalizes existing deep context garden ADRs (C07-C22) to vault-wide application.
Field Notes on Handpan Sound Models & Instruments: Personal field notes documenting specific handpan instruments and their sound models — the scale templates, acoustic character, modal theory, and ensemble compatibility. Each instrument is documented as both an interactive web page (with tone circles and audio playback) and portable markdown. Planned for publication at www.spiralrhapsody.com/fieldnotes/.
2026-03-19 Peter Kaminski - Garden Patch Review: Third call with Peter Kaminski (~90 min). Reviewed the 120+ file IFP garden patch. Covered signed commits, IFPX experimental feeder repo, cross-community convergence, reflection personas, compound documents, and constructed languages. Decisions: skip open integrity for now, IFPX as feeder, expand to four-person working group. Next meeting March 27.
Christopher Allen: Christopher Allen is the founder and president of Blockchain Commons, author of the 10 Principles of Self-Sovereign Identity (2016), co-editor of the TLS 1.0 draft, and principal authority of this vault’s augmented knowledge system. His work bridges applied cryptography, digital identity, and trust architecture through the Gordian stack, XIDs, and the principal authority framework rooted in agency law.
Peter Kaminski: Wiki gardener and context engineer in California, turning 65 in 2026. Projects include the Inter-Face Protocol garden patch, MassivePub static site generator, and a paid agentic AI course using Obsidian and Claude Code. Core focus: helping regular people use capable tools.
Digital Identity: MOC spanning the range from centralized identity databases to self-sovereign models where individuals control their own credentials. Anchors on W3C standards (DIDs, Verifiable Credentials) and collaborative design forums (Rebooting the Web of Trust), with trust frameworks governing who trusts whom as a key cross-cutting concern.
Health: Map of content for the Health/ vault domain covering personal health management: condition trackers, visit notes, medications, providers, and the appointment lifecycle (prep and post-visit processing). Domain uses vault-precinct types (type/reference, type/log) rather than garden forms.
Health Overview: (no summary available)
Research Note: (no summary available)
These references appear in the patch but could not be found in the source garden. They may be ghost links, informal references, or person/concept names.
| Descriptive Slugs for Archive Binaries | descriptive slugs |
| Ghost Link as Unplanted Garden Stake | Ghost links |
| Grafted Node as Transplanted Knowledge in a Garden Patch | Grafted nodes |
| Living Documents Over Static Publications | living documents |
| Patch-Native Node as Original Knowledge in a Garden Patch | Patch-native nodes |
| Patch-Native Node as Original Knowledge in a Garden Patch | patch-native nodes |
| Structural Contract as Form Type Agreement | structural contract |
| Structural Contract as Form Type Agreement | structural contracts |
| Upstream Node as Source Garden Reference | upstream nodes |