Wanderland: An Executable Knowledge Graph for AI-Native Documentation

Wanderland: An Executable Knowledge Graph for AI-Native Documentation

A systems paper demonstrating structural isomorphism between documents, programs, and databases

Abstract

Content

Content

We present Wanderland, an executable knowledge graph that treats structured markdown as a programming language. Unlike systems that extract knowledge graphs from documents or generate code from documentation, Wanderland makes the document itself the computational substrate. Fenced code blocks execute as functions, navigation constitutes query execution, and a multi-level cache implements compilation semantics. The architecture exhibits strong structural parallels to fifty years of research in compilers (streams with relocations), databases (query plans with operators), and distributed systems (event sourcing with projections). We argue that these parallels are not merely analogical but reflect shared computational invariants: the same design patterns that optimize binary linking can be adapted to optimize document rendering. A novel three-state provenance system (unverified → reviewed → verified) with hash-based drift detection provides continuous human verification without external tooling. Evaluation against current approaches—executable knowledge graphs, literate programming with provenance, and MCP-based agentic workflows—shows Wanderland offers advantages in homoiconicity (no separation between tool definition and documentation) and deployed provenance tracking, though rigorous formal equivalence remains future work. The system has been in production use for infrastructure operations, demonstrating that operational simplicity can outweigh peak performance for knowledge work.

Introduction

The Problem

Documentation drifts from reality. Code comments lie. Runbooks rot. The knowledge that humans need to operate systems exists in a perpetual state of staleness because the artifacts that describe systems are separate from the artifacts that implement them.

This separation creates what we term the integration tax: every boundary crossing between documentation, code, and data requires synchronization that organizations pay forever. "Which doc covers this function?" requires a join across systems that don't share a query language. "What code implements this runbook?" requires manual correlation. "Who approved this config change?" requires audit trail reconstruction.

The Observation

The Observation

The integration tax exists because we optimized each stream for its primary access pattern and forgot they share computational structure underneath. A binary is a stream of instructions with holes (relocations) that the linker fills with addresses. A query plan is a stream of operators with holes that the executor fills with data. A document is a stream of tokens with holes (fences) that the renderer fills with output.

These streams exhibit strong structural parallels. The linking step is always there. The stream with holes that get filled at resolution time—it appears repeatedly across domains, suggesting shared computational invariants rather than mere coincidence.

The Thesis

Structured text with sufficient expressiveness constitutes a programming language. The sufficient expressiveness is: hierarchical organization (sections, nesting), executable regions (fences with semantics), reference mechanism (links, includes, slots), and transformation pipeline (middleware composition).

We present Wanderland, a system that treats this thesis seriously. Documents execute. Navigation is query execution. The cache implements compilation stages. Provenance tracks human verification inline.

Contributions

Contributions

• Structural Parallels: We identify and exploit structural parallels between document processing, compilation, and query execution—enabling design patterns from one domain to transfer to others. Formal proof of isomorphism remains future work.
• Authoring-Time Structure: Unlike systems that extract graphs from documents, Wanderland imposes computable structure at authoring time, eliminating reconstruction.
• Inline Provenance: A three-state verification system (🔴→🟡→🟢) with hash-based drift detection, deployed and working where current research remains exploratory.
• Homoiconic MCP: Tool definitions collapse into the documentation that describes them—no synchronization required.
• Production Validation: The system operates real infrastructure, demonstrating viability beyond research prototype.

Related Work

Executable Knowledge Graphs

Recent work on Executable Knowledge Graphs (xKG) [1] constructs graphs that integrate conceptual nodes with runnable code components extracted from papers and GitHub repositories. The system enables agents to both retrieve and execute methods when replicating AI research. xKG employs a hierarchical structure with Paper Nodes, Technique Nodes, and Code Nodes connected by structural and implementation edges.

Distinction: xKG extracts executable graphs FROM existing artifacts through an automated pipeline. Wanderland authors executable graphs AS the primary substrate. The graph is not constructed—it is the authoring medium itself.

Literate Programming and LLMs

The "Renaissance of Literate Programming in the Era of LLMs" [2] proposes Interoperable Literate Programming (ILP), combining code with natural language documentation to help LLMs better understand and generate code. The approach addresses challenges LLMs face with complex interdependencies in large codebases.

Distinction: ILP treats prose as guidance for code generation—documentation helps LLMs write better code. Wanderland treats prose as computation—there is no separate code to generate because the documentation itself executes.

Document-to-Graph Pipelines

Docs2KG [3] enables knowledge graph extraction from heterogeneous documents including emails, PDFs, web pages, and spreadsheets. The system uses dual-path processing (image conversion and markdown conversion) to recover structure from documents not written with structure in mind.

Distinction: Docs2KG recovers structure through ETL. Wanderland imposes structure at authoring time. The graph is not extracted from documents—documents are authored directly into the graph.

Notebook Provenance

Loops [4] is a JupyterLab extension that captures provenance information to visualize the impact of changes within notebooks. The system traces notebook evolution over time and highlights differences between versions across code, markdown, tables, and visualizations.

Distinction: Loops visualizes provenance after the fact for reproducibility research. Wanderland embeds provenance into the substrate with inline status indicators (🔴→🟡→🟢). The verification state is always visible, not reconstructed.

Model Context Protocol

MCP [5] is an open standard for AI systems to integrate with external tools, systems, and data sources. The protocol defines tools with structured descriptions, execution semantics, and security boundaries. As of 2025, MCP has been adopted as the de-facto standard for agent-tool integration.

Distinction: Standard MCP maintains separation between tool definitions and documentation about tools. Wanderland collapses this—the fenced code block IS the tool definition, IS the documentation, IS the implementation. No second representation requires synchronization.

Summary

System Design

Overview

Wanderland implements an executable knowledge graph where markdown documents serve as both the storage format and the programming language. The architecture comprises four core subsystems: the Token Stream (document representation), the Compilation Pipeline (cache levels), the Graph Engine (navigation and linking), and the Provenance System (verification tracking).

The Token Stream

A Wanderland document is a stream of tokens with three categories:

• Prose Tokens: Markdown text rendered for human consumption
• Fence Tokens: Executable regions delimited by triple backticks
• Slot Tokens: Graph edges encoded in YAML blocks within cardinal sections (North/South/East/West)

Fences are the executable boundary. A fence declares:

• Language: The execution runtime (python, yaml, bash, sql, etc.)
• Attributes: Key-value metadata including execution flags, service bindings, labels
• Content: The code or data to process

This mirrors the structure of a binary: instructions (prose), relocatable symbols (fences), and linkage information (slots).

The Compilation Pipeline

Documents progress through five cache levels, analogous to compilation stages:

The critical insight is L3 as linking: fence execution fetches data from external systems (AWS APIs, JIRA, databases) and splices results into the stream. The fence is a hole. The linker fills it.

Each level caches independently. Cache invalidation is trivial: delete any level and it regenerates from below. The system is self-healing—poke a hole anywhere and it fills from the source of truth.

The Graph Engine

Documents are nodes in a directed graph. Edges are encoded in cardinal sections using a spatial metaphor:

This convention enables predictable navigation: "go north" always means "zoom out," while "go south" means "drill down." East/West provide linear traversal through sequences like paper sections or workflow steps.

Navigation is query execution. Moving from node A to node B:

• Resolves the target node
• Executes edge middleware (guards, transforms)
• Renders the target at the requested cache level
• Accumulates context for downstream processing

The graph supports multiple addressing modes:

• Slug: Direct node identifier (my-node)
• Path: Dot-notation into node structure (my-node.section.fence.key)
• Fence ID: Direct fence addressing (my-node:my-label)

The Middleware Layer

Middleware operates at L3.5—after fence execution but before caching. This is Kafka consumer semantics applied to documents:

Fence Output → [Normalizer] → [Cleaner] → [Extractor] → Cached Result

Middleware is:

• Composable: Chain transformations in sequence
• Conditional: Pattern matching determines execution
• Stateless: Each transformer is pure
• Extensible: Add processors without modifying core

Edge middleware extends this to navigation: transitions between nodes trigger middleware that can guard, transform, or accumulate context.

The Provenance System

Every document and fence tracks verification state independently:

Multi-granularity tracking: Documents contain fences, and each tracks status independently. A document marked 🟡 (reviewed) may contain fences marked 🔴 (unverified). This is intentional—it allows targeted verification. A reviewer might approve prose content while marking executable fences for specialist review. There is no automatic cascade; status propagation is a policy choice, not a system constraint.

Drift detection: When content changes after verification, hash comparison detects the mismatch. The system can automatically downgrade status (🟢→🔴) or flag for re-review. This provides continuous verification without external tooling.

Inline visibility: Provenance sections auto-inject on save via filesystem hooks. The verification state is always visible inline, not reconstructed from external audit logs. When you read a document, you see its trust level immediately.

Implementation

Technology Stack

Wanderland is implemented as a collection of services:

All services communicate via HTTP APIs. The MCP proxy exposes graph operations as tools that AI agents can invoke directly.

The AST Pipeline

Document processing follows the AST converter pipeline:

• Tokenization: Markdown parsed via markdown-it-py (GFM-like mode with tables, strikethrough)
• Fence Detection: State machine tracks fence boundaries (handles nested fences)
• Section Extraction: Headers create hierarchical structure
• Slot Parsing: Cardinal sections (N/S/E/W) parsed for graph edges
• Provenance Injection: Auto-injects verification sections on save
• Virtual Fence Detection: Scans for patterns (todo lists, tables) and annotates tokens

The fence detector uses a state machine to handle edge cases:

• Bare fences (no language specifier)
• Nested fences (fences within fences)
• Fence attributes ([key=value] syntax)

Fence Execution

Fences execute based on language and attributes. The system supports multiple execution backends:

Python fences receive injected context: config (parameters), graph (API access), and result (output dict). Fences can query other nodes, execute sub-fences, and return structured data.

AWS fences use declarative YAML with attributes specifying service and method. A fence marked aws[service=ec2,method=describe_instances] containing filter YAML executes the boto3 call and returns instance data. This enables live infrastructure queries embedded in documentation.

HTTP fences fetch external APIs. Attributes specify url and method; fence content provides headers and body. Variable substitution (e.g., ${SSM_TOKEN}) injects secrets at execution time.

SQL fences query external databases via connection strings in attributes. The fence content is the query; results return as structured data for downstream processing or display.

Execution is sandboxed per-fence. Results cache at L3. Middleware transforms at L3.5 before final caching.

Virtual Fences

Beyond explicit fences, the system detects virtual fences—patterns in prose that expose stateful behavior through multiple interfaces:

The same virtual fence is accessible through multiple interfaces:

MCP Tools: AI agents invoke oculus_execute_virtual_fence with action and parameters.

CLI (toodles): Human-friendly commands: toodles check my-node:Tasks 0

Web Components: Stuffy renders :::wonderland-todo-list as clickable checkboxes.

Shell Integration (snippy): Fish functions query radio lists as configuration selectors.

All clients are isomorphic—they consume the same HTTP API with identical semantics. The CLI wraps the API. The web component polls the API. The MCP tool calls the API. The shell function curls the API. This means:

• No client-specific logic in the server
• Any new interface requires only API bindings
• Behavior is identical regardless of access method
• Testing one client validates all clients

The isomorphism extends beyond documents: the client layer exhibits the same structural equivalence as the document/compiler/database mapping. A checklist is simultaneously documentation, API, CLI, and widget—not through synchronization, but through architectural collapse.

The Graph Index

Nodes register in an in-memory index on startup:

GraphIndex:
  nodes: Dict[slug, GraphNode]
  fences: Dict[fence_id, FenceMetadata]  
  tags: Dict[tag, Set[slug]]
  edges: Dict[slug, Dict[direction, List[slot]]]

The fence index enables discovery: "find all fences with service=ec2" returns executable AWS operations across the entire graph.

MCP Integration

Every labeled fence becomes an MCP tool:

# In document: ```python[my-tool]
# Callable via: oculus_execute_fence("my-tool")

# The fence definition IS the tool definition
# No separate registration required

The MCP proxy exposes ~100 tools covering:

• Navigation (goto, look, walk, back)
• Reading (peek, scroll, edges, explore)
• Writing (poke, node, link, tag)
• Execution (execute fence, execute virtual fence)
• Cases (open, pursue, clue, solved)

Provenance Hooks

Filesystem hooks trigger on document save:

• Pre-save: Validate structure, check for conflicts
• Post-save: Inject/update provenance section, reindex fences

The provenance injector:

• Scans for existing Provenance section
• Adds Document status (always present)
• Adds Fence entries (one per fence with generated ID)
• Initializes all as 🔴 Unverified

Hash verification compares stored hash against current content hash. Drift detection enables "trust but verify" workflows.

Evaluation

Research Questions

We evaluate Wanderland against three questions:

• RQ1: Does the structural isomorphism hold operationally? Do compiler/database patterns actually apply?
• RQ2: How does Wanderland compare to current approaches on key dimensions?
• RQ3: Is the system viable for production use?

RQ1: Structural Isomorphism

Compiler Mapping

We validated the compiler analogy by implementing each stage:

The cache invalidation behavior matches: invalidate any level and it regenerates from source. This is not analogical—it is the same algorithm.

Database Mapping

Query plan semantics validated:

Navigation as query execution: moving through the graph triggers the same operations as executing a query plan—resolve references, fetch data, project results.

RQ2: Comparative Analysis

vs. xKG (Executable Knowledge Graphs)

Finding: Wanderland eliminates the extraction pipeline entirely. The cost is manual authoring; the benefit is no reconstruction error.

vs. Loops (Notebook Provenance)

Finding: Loops is research tooling for understanding what happened. Wanderland is operational tooling for ensuring what should happen.

vs. Standard MCP

Finding: Wanderland's homoiconic approach eliminates an entire class of drift bugs where tool behavior diverges from documentation.

RQ3: Production Viability

Deployment Context

Wanderland has been in production use for infrastructure operations at a Fortune 500 company's developer platform division. The system manages:

• AWS infrastructure documentation with executable queries
• JIRA ticket integration and workflow automation
• Runbook execution with provenance tracking
• AI agent tooling via MCP

Performance Characteristics

The performance tradeoff is explicit: fence execution adds latency vs. static content. This is acceptable for operational knowledge work where correctness matters more than throughput.

Limitations Observed

Limitations Observed

• Cold start: First access after restart requires index rebuild (~5s for 500 nodes)
• Large fences: Execution output >1MB causes rendering delays
• Deep nesting: Include depth >5 impacts readability

Threats to Validity

This evaluation has significant limitations that constrain the strength of our claims:

No User Study: We have not conducted formal user studies measuring authoring effort, learning curves, or cognitive load. The production deployment provides existence proof of viability but not controlled comparison of developer productivity versus alternative approaches.

No Quantitative Authoring Metrics: We lack measurements of lines-of-code, time-to-documentation, or maintenance overhead compared to traditional docs-as-code workflows. Claims of reduced "integration tax" are based on architectural argument, not empirical measurement.

Single Deployment Context: Production validation comes from one organization's infrastructure team. Generalizability to other domains (research documentation, API references, educational content) remains unvalidated.

Self-Evaluation Bias: The authors are also the primary users. Independent evaluation by teams adopting Wanderland without author involvement would provide stronger evidence.

Provenance System Unquantified: While the provenance system is deployed and functioning, we have not measured how often it actually catches drift in production, nor compared its effectiveness against alternative verification approaches.

These limitations do not invalidate the architectural contributions but constrain claims about practical superiority. We position this work as demonstrating feasibility and identifying design patterns, not as proving optimal approach.

Discussion

The Inversion

The central contribution of Wanderland is not a new algorithm or optimization. It is an inversion of the standard relationship between documents and computation.

Traditional systems ask: "How do we extract structure from documents?" or "How do we generate documents from code?" These questions assume documents and code are separate artifacts requiring translation.

Wanderland asks: "What if documents ARE computation?" This dissolves the translation problem. There is no extraction because structure exists at authoring time. There is no generation because the document itself executes.

This inversion has precedent. Lisp asked "What if code were data?" and produced homoiconicity. Wanderland asks "What if documentation were code?" and produces a different kind of homoiconicity—prose-homoiconicity where the human-readable narrative IS the executable specification.

The Lebowski Architecture

The cache architecture embodies a distributed systems principle we term the Lebowski Corollary: in any system with derived state, there must be exactly one source of truth. Everything else is opinion.

In Wanderland:

• Content (L0) is the rug—immutable source of truth
• Data (L3) is a sacred derived rug—fence execution output
• Everything above is opinion—middleware projections

Conflicts resolve by returning to source. No merge logic. No three-way diffs. Wipe the cache, regenerate from content. The rug is the arbiter.

This pattern appears throughout computing but is rarely made explicit in document systems. Wanderland makes it structural.

Why AI-Native Matters

The system was not designed for AI agents, but it is unusually well-suited for them:

• No format translation: The context AI agents need is already in executable form
• Tool discovery via navigation: Agents find capabilities by walking the graph
• Provenance for trust: Agents can verify what humans have reviewed
• Natural language interface: The prose IS the API documentation

Current AI tool ecosystems (MCP, function calling) require separate tool definitions that must stay synchronized with documentation. Wanderland eliminates this synchronization problem by collapsing the representations.

Limitations

Conceptual Overhead

The system requires understanding three mental models simultaneously: compiler (cache levels as compilation stages), database (navigation as query execution), and distributed systems (Lebowski architecture). This is significant cognitive load for newcomers.

Performance Tradeoffs

Fence execution adds latency. A document with 10 AWS API calls will be slower than static documentation. The bet is that correctness matters more than speed for operational knowledge work. This bet may not hold for all use cases.

Cold Start Scaling

The current implementation indexes ~500 nodes in ~5 seconds on cold start. While acceptable for single-user deployments, this linear scaling may become problematic for larger knowledge bases. Potential mitigations include lazy indexing, persistent index serialization, and hierarchical index partitioning. Production deployments should monitor cold start times as the graph grows.

Adoption Curve

The system is opinionated. It requires authoring discipline (use fences, maintain slots, verify provenance). Organizations accustomed to freeform documentation may resist the structure.

Not a Replacement

Wanderland is a unification layer, not a replacement for specialized systems. It does not replace databases for transactional data, compilers for performance-critical code, or workflow engines for high-throughput automation. It sits above these systems and provides a unified interface for knowledge that references them.

Future Work

Looking Glass Development and Formal Verification

The provenance system tracks human verification (🔴→🟡→🟢). The system already supports a stronger form: Looking Glass Development (LGD)—a methodology where tests ARE documentation.

In LGD, a documentation node embeds live test results from a companion test node. The graphnode fence executes tests and renders results inline. The document proves itself: if the test table shows green, the documentation is correct. If red, the prose is lying.

The rubyception pattern demonstrates this at the fence level: a node contains both a code fence and a test fence as siblings. The test fence references the code fence. Execution validates the claim.

Future work extends this toward formal verification:

• Specification extraction: Parse fence contracts from prose (pre/post conditions in natural language)
• Property-based testing: Generate test cases from specifications using the structural isomorphism
• Proof carrying documentation: Attach machine-checkable proofs to fences, verified on render
• Compiler verification techniques: Apply fifty years of compiler correctness research to document validation

The structural isomorphism enables this: if documents compile like programs, they can be verified like programs.

Collaborative Editing

The current system assumes single-author documents. Extending to real-time collaborative editing while maintaining provenance integrity is an open problem. CRDT-based approaches could merge concurrent edits while preserving per-fence verification state.

Federation

Multiple Wanderland instances could federate, sharing nodes across organizational boundaries while respecting provenance chains. The graph structure supports this; the trust model requires development. Federated verification could propagate: if Node A in Instance X references Node B in Instance Y, Instance X trusts Y's provenance claims based on federation agreements.

Conclusion

Summary

We presented Wanderland, an executable knowledge graph that treats structured markdown as a programming language. The system demonstrates that the structural isomorphism between documents, compilers, and databases is not merely analogical but operational—the same patterns that optimize binary linking optimize document rendering.

Key contributions:

• Authoring-time structure: Unlike extraction-based approaches, Wanderland imposes computable structure when documents are written, eliminating reconstruction error.
• Inline provenance: A three-state verification system (🔴→🟡→🟢) with hash-based drift detection provides continuous human verification without external tooling.
• Homoiconic tooling: The collapse of tool definition, documentation, and implementation into a single artifact eliminates synchronization drift.
• Production validation: The system operates real infrastructure, demonstrating viability beyond research prototype.

The Thesis Revisited

We claimed that structured text with sufficient expressiveness constitutes a programming language. Wanderland is proof by construction:

• Hierarchical organization → Sections and nesting
• Executable regions → Fences with semantics
• Reference mechanism → Links, includes, slots
• Transformation pipeline → Middleware composition

The document format is the source language. The graph engine is the compiler. The runtime is navigation and fence execution.

Implications

For knowledge management: Documentation can have tests. Living documentation is not a goal but a consequence of the architecture. Dead documentation is a compiler error.

For AI collaboration: The gap between specification and implementation collapses when the specification format is executable. Natural language becomes programming.

For system design: Choosing a documentation format IS choosing an execution model. Markdown with fences is not a documentation choice—it is an architectural decision.

Closing

Fifty years of computer science gave us compilers, databases, and distributed systems. These fields developed deep theories about streams, caching, linking, and consistency.

Documentation systems ignored all of it.

Wanderland recognizes that the patterns apply. The rug really does tie the room together.

This paper was written using the system it describes. The composite document demonstrates include composition. The section nodes demonstrate graph structure. The provenance sections demonstrate verification tracking. The fences demonstrate executable documentation.

The proof is the artifact.

References

Formatted References

{
  "citation": {
    "raw": "Chen, Y., et al. (2025). Executable Knowledge Graphs for Replicating AI Research. arXiv preprint arXiv:2510.17795. https://arxiv.org/abs/2510.17795",
    "line_number": 1,
    "metadata": {
      "author": "Chen, Y.",
      "year": "2025"
    },
    "identifiers": [
      {
        "type": "url",
        "value": "https://arxiv.org/abs/2510.17795"
      }
    ],
    "format": "apa"
  },
  "verification": {
    "status": "basic",
    "checks": {
      "url_https://arxiv.org/abs/2510.177": {
        "accessible": true,
        "status_code": 200,
        "content_type": "text/html; charset=utf-8"
      }
    },
    "level": "\ud83d\udfe1",
    "messages": [
      "\u2713 URL accessible: https://arxiv.org/abs/2510.17795...",
      "\u26a0 Incomplete metadata"
    ],
    "score": "1/2"
  }
}

{
  "citation": {
    "raw": "Zhang, W., et al. (2025). Renaissance of Literate Programming in the Era of LLMs. arXiv preprint arXiv:2502.17441. https://arxiv.org/abs/2502.17441",
    "line_number": 3,
    "metadata": {
      "author": "Zhang, W.",
      "year": "2025"
    },
    "identifiers": [
      {
        "type": "url",
        "value": "https://arxiv.org/abs/2502.17441"
      }
    ],
    "format": "apa"
  },
  "verification": {
    "status": "basic",
    "checks": {
      "url_https://arxiv.org/abs/2502.174": {
        "accessible": true,
        "status_code": 200,
        "content_type": "text/html; charset=utf-8"
      }
    },
    "level": "\ud83d\udfe1",
    "messages": [
      "\u2713 URL accessible: https://arxiv.org/abs/2502.17441...",
      "\u26a0 Incomplete metadata"
    ],
    "score": "1/2"
  }
}

{
  "citation": {
    "raw": "Sun, Q., et al. (2024). Docs2KG: Unified Knowledge Graph Construction from Heterogeneous Documents. arXiv preprint arXiv:2406.02962. https://arxiv.org/abs/2406.02962",
    "line_number": 5,
    "metadata": {
      "author": "Sun, Q.",
      "year": "2024"
    },
    "identifiers": [
      {
        "type": "url",
        "value": "https://arxiv.org/abs/2406.02962"
      }
    ],
    "format": "apa"
  },
  "verification": {
    "status": "basic",
    "checks": {
      "url_https://arxiv.org/abs/2406.029": {
        "accessible": true,
        "status_code": 200,
        "content_type": "text/html; charset=utf-8"
      }
    },
    "level": "\ud83d\udfe1",
    "messages": [
      "\u2713 URL accessible: https://arxiv.org/abs/2406.02962...",
      "\u26a0 Incomplete metadata"
    ],
    "score": "1/2"
  }
}

{
  "citation": {
    "raw": "Eckelt, K., Gadhave, K., Lex, A., Streit, M. (2024). Loops: Leveraging Provenance and Visualization to Support Exploratory Data Analysis in Notebooks. IEEE VIS. https://vdl.sci.utah.edu/publications/2024_vis_loops/",
    "line_number": 7,
    "metadata": {
      "author": "Eckelt, K., Gadhave, K., Lex, A., Streit, M.",
      "year": "2024"
    },
    "identifiers": [
      {
        "type": "url",
        "value": "https://vdl.sci.utah.edu/publications/2024_vis_loops/"
      }
    ],
    "format": "apa"
  },
  "verification": {
    "status": "basic",
    "checks": {
      "url_https://vdl.sci.utah.edu/publi": {
        "accessible": true,
        "status_code": 200,
        "content_type": "text/html; charset=utf-8"
      }
    },
    "level": "\ud83d\udfe1",
    "messages": [
      "\u2713 URL accessible: https://vdl.sci.utah.edu/publications/2024_vis_loo...",
      "\u26a0 Incomplete metadata"
    ],
    "score": "1/2"
  }
}

{
  "citation": {
    "raw": "Anthropic. (2024). Model Context Protocol Specification. modelcontextprotocol.io. https://modelcontextprotocol.io/specification/2025-11-25",
    "line_number": 9,
    "metadata": {
      "author": "Anthropic",
      "year": "2024"
    },
    "identifiers": [
      {
        "type": "url",
        "value": "https://modelcontextprotocol.io/specification/2025-11-25"
      }
    ],
    "format": "apa"
  },
  "verification": {
    "status": "basic",
    "checks": {
      "url_https://modelcontextprotocol.i": {
        "accessible": true,
        "status_code": 200,
        "content_type": "text/html; charset=utf-8"
      }
    },
    "level": "\ud83d\udfe1",
    "messages": [
      "\u2713 URL accessible: https://modelcontextprotocol.io/specification/2025...",
      "\u26a0 Incomplete metadata"
    ],
    "score": "1/2"
  }
}

{
  "citation": {
    "raw": "Knuth, D.E. (1984). Literate Programming. The Computer Journal, 27(2), 97-111.",
    "line_number": 11,
    "metadata": {
      "author": "Knuth, D.E.",
      "year": "1984"
    },
    "identifiers": [],
    "format": "apa"
  },
  "verification": {
    "status": "unverified",
    "checks": {},
    "level": "\ud83d\udd34",
    "messages": [
      "\u26a0 Incomplete metadata"
    ],
    "score": "0/1"
  }
}

{
  "citation": {
    "raw": "Mac Lane, S. (1971). Categories for the Working Mathematician. Springer.",
    "line_number": 13,
    "metadata": {
      "author": "Mac Lane, S.",
      "year": "1971"
    },
    "identifiers": [],
    "format": "partial"
  },
  "verification": {
    "status": "unverified",
    "checks": {},
    "level": "\ud83d\udd34",
    "messages": [
      "\u26a0 Incomplete metadata"
    ],
    "score": "0/1"
  }
}

{
  "citation": {
    "raw": "Fowler, M. (2005). Event Sourcing. martinfowler.com. https://martinfowler.com/eaaDev/EventSourcing.html",
    "line_number": 15,
    "metadata": {
      "author": "Fowler, M.",
      "year": "2005"
    },
    "identifiers": [
      {
        "type": "url",
        "value": "https://martinfowler.com/eaaDev/EventSourcing.html"
      }
    ],
    "format": "apa"
  },
  "verification": {
    "status": "basic",
    "checks": {
      "url_https://martinfowler.com/eaaDe": {
        "accessible": true,
        "status_code": 200,
        "content_type": "text/html"
      }
    },
    "level": "\ud83d\udfe1",
    "messages": [
      "\u2713 URL accessible: https://martinfowler.com/eaaDev/EventSourcing.html...",
      "\u26a0 Incomplete metadata"
    ],
    "score": "1/2"
  }
}

Note on verification status: The 🔴 status for Knuth [6] and Mac Lane [7] reflects the absence of verifiable URLs, not citation unreliability. These are canonical works in their fields—a 1984 journal article and a foundational 1971 textbook. The verification system correctly identifies that link-checking is not applicable to print publications. This demonstrates both the system's honesty (it won't claim to verify what it cannot check) and a limitation (URL accessibility is a proxy for citation validity, not a substitute for it).

This paper was written using the system it describes.

South

slots:
- context:
  - Linking to parent wanderland paper
  slug: wanderland-twelve

East

slots:
- context:
  - Linking paper to its verification node
  slug: wanderland-paper-verification

North

slots:
- context:
  - This is the theoretical framing for the paper
  slug: wanderland-as-native-attention

Provenance

Document

• Status: 🟡 Reviewed
• Hash: 7a50f39d
• By: graemefawcett
• Date: 2026-01-01
• Note: draft approved

Fences

wanderland-paper-east-fence-0

• Status: 🔴 Unverified

wanderland-paper-north-fence-0

• Status: 🔴 Unverified

wanderland-paper-south-fence-0

• Status: 🔴 Unverified

Changelog

• 2026-01-01 20:21: Document reviewed (🟡) by graemefawcett - draft approved

East

South

North