wanderland-twelve-grounding

The Twelve Principles

How Wanderland implements each principle

I. The Answer Already Exists

Metaphor	Wanderland Implementation
User: The page exists, we find it	Graph contains nodes; `peek` reads any path
Executive: Alpha exists in the market	Everything addressable via `slug:path`; traverse to find
Technical: Probability space contains all outputs	Foundation model + navigable graph = answer space

The primitive: peek(slug, path) — read anything at any address.

Wanderland components: Slug-based addressing, dot-notation paths, cardinal link traversal

II. Better Questions, Better Answers

Metaphor	Wanderland Implementation
User: We help you ask better	Reading lists sequence context; cases link resources
Executive: Query architecture matters	Structured paths, tagged content, curated entry points
Technical: Context shapes traversal	Level parameter: same content, different representation

The mechanism: Structure your path, structure your answer.

peek(slug, level=L3) → code
peek(slug, level=L4) → data
peek(slug, level=L5) → document

Wanderland components: Level parameter, reading lists as sequenced context, cases with linked resources

III. Attention is the Product

Metaphor	Wanderland Implementation
User: Finding IS the product	Query returns value directly; no separate "retrieve then process"
Executive: The system IS attention	Level parameter = Q, Fence = K, Result = V; externalized Q/K/V
Technical: RAG as native attention	Retrieval IS attention, not a step before attention

The core insight: The level system implements attention semantics.

Level   │ Query (Q)                    │ Value (V)
────────┼──────────────────────────────┼─────────────────
L3      │ "what are you made of?"      │ Code/definition
L4      │ "what do you produce?"       │ Executed data
L5      │ "how do you present?"        │ Rendered document

Scope as attention scope:

peek(slug:fence) = single-head attention
peek(slug) = multi-head (all fences on page)
query(pattern) = global attention over corpus

Cache as persisted attention: L4 cache = "I learned this data." L5 cache = "I learned how to present it." The cache IS attention results, materialized so you don't re-attend.

Wanderland components: Level parameter on all reads, peek/poke as attention primitives, cache layers at L4/L5, oracle_search as global attention

IV. Expertise Transfers

Metaphor	Wanderland Implementation
User: Learn from the best instantly	Reading lists package expertise; execute them in sequence
Executive: Tacit knowledge becomes portable	Curated paths through content = transferable skill
Technical: Skills as injectable context	Reading list = ordered peek sequence; run it, get the context

The mechanism: A reading list is a skill. Execute it, load the expertise.

execute("attention-thesis-foundations", "read")
→ Walks you through 12 nodes in order
→ Context accumulates
→ You now have the background

Wanderland components: Reading list fences, execute to walk sequences, accumulated context as expertise

V. Watch, Learn, Apply

Metaphor	Wanderland Implementation
User: Gets better with use	Every operation carries context; you can query what you've done and why
Executive: Extract what makes best people best	Logs are contextualized; links explain themselves
Technical: Capture, cluster, inject	`poke` with context parameter; `peek` the activity log; feed it back

The mechanism: Every write includes WHY. Every link includes WHY. Query the why, learn from it.

poke(slug, path, value, context="Adding task from sprint planning")

Later:

peek("activity-log") 
→ Shows what was done, when, and WHY
→ Feed that back into future decisions

Wanderland components: Context parameter on all writes, activity logging, queryable history with intent

VI. Identity is Portable

Metaphor	Wanderland Implementation
User: Preferences move with you	Everything interpolates; change one value, shift everything that references it
Executive: Hot-swappable specialization	One linchpin document can shift entire classes of documents
Technical: Variable substitution at render	`{{variable}}` interpolation; change the variable, change every document that uses it

The mechanism: Documents reference other documents. Change the reference, change everything downstream.

# config.yaml
environment: production

# Any document referencing {{config.environment}}
# automatically shifts when config changes

One poke to a config node → entire document tree transforms.

Wanderland components: Variable interpolation ({{slug.path}}), render-time substitution, cascading updates

VII. One Pattern, Everywhere

Metaphor	Wanderland Implementation
User: One way that works	Everything is: name, arguments, context
Executive: Universal operational principle	Tools call tools call tools—same interface all the way down
Technical: Homoiconic documents	The document IS the code IS the tool IS the documentation

The pattern: (name, arguments, context) — that's it.

peek(name, args, context)     → Read
poke(name, args, context)     → Write
execute(name, args, context)  → Run

A fence calls a fence calls a fence. Same signature. Tools are tools are tools.

Homoiconic: The markdown that describes the tool IS the tool. The prose that documents the fence lives in the same file as the fence. Change the documentation, you're changing the thing. Read the thing, you're reading the documentation.

Wanderland components: Uniform (name, args, context) signature, fences in markdown, prose and code colocated

VIII. See It Before You Use It

Metaphor	Wanderland Implementation
User: Know what tool when	Read about the tool ON the tool, because they're the same thing
Executive: Recognition gates capability	The documentation IS the capability; reading it IS discovering it
Technical: Homoiconic discovery	`peek(fence)` returns both what it does AND how to call it

The mechanism: You read about the thing ON the thing.

The fence lives in a document. The document describes the fence. They're the same file. When you peek the node, you see:

What the tool does (prose)
How to call it (the fence itself)
Examples (more fences)

No separate documentation. The thing that IS the thing is the thing you're reading about.

peek("my-tool-node")
→ Returns markdown with description AND the executable fence
→ Read it to understand it
→ Execute it to use it
→ Same address, same content

Wanderland components: Fences embedded in descriptive markdown, peek returns both docs and code, homoiconic structure

IX. Same Process, Every Scale

Metaphor	Wanderland Implementation
User: Works for small and big	Run it locally, sync to central, scale to organization
Executive: Principles scale without loss	Distributed-first: local → team → org, same API at every tier
Technical: Routing budget, not fixed topology	Fan-out queries, stateless execution, compute elasticity

The architecture: Same as Git.

Every engineer runs a local copy
Syncs to team repository
Team syncs to org-wide
Same operations at every level

Routing is the only knob:

Want to deep-dive every document? Pay the compute to parallelize.
Want to go deep on one path? Pay the TTL to wait.

Serverless-native: Stateless execution. Every node responds independently—fan-out queries hit the entire corpus in parallel, fan-in merges results. Horizontal scaling without coordination overhead.

Local graph (your laptop)
    ↓ sync
Team graph (shared repo)  
    ↓ sync
Org graph (central)
    ↓ query fan-out
Every node in parallel → results merge

Wanderland components: Git-like sync model, configurable routing budget, embarrassingly parallel query fan-out

X. The System Improves Itself

Metaphor	Wanderland Implementation
User: Tomorrow better than today	Create a tool, now you have a tool; compose tools into tools
Executive: Self-optimizing operations	Three orders of composition is all you need to create anything
Technical: Tool composition + event sourcing	Middleware chains, event-sourced graph, distributed by design

Tool composition: Create a fence → it's a tool. Compose tools → it's a tool. Three levels deep and you can build anything.

Tool → calls Tool → calls Tool

That's it. That's sufficient for arbitrary capability.

Middleware: Every fence call is chainable. Data comes out the same shape; middleware transforms it 14 different ways depending on who's asking. Same source, different views.

Event sourced: The graph is the source of truth. Everything else is a view. Every poke is an event. Every read is a projection. The log IS the database.

Distributed by design: Built for teams to share the same data without overloading the system by constantly fetching. Local copies, sync when needed, fan-out when querying. Your graph is your cache; central is the ledger.

Wanderland components: Fence composition, middleware chains, event-sourced graph, local-first with sync

XI. Value is Contrast

Metaphor	Wanderland Implementation
User: Personalized, not average	All your documents behind one interface; patterns emerge naturally
Executive: Deviation from baseline = signal	Same attention heads seek everything; contrasts surface automatically
Technical: Meaning is delta	Uniform access + consistent query = pattern detection as side effect

The mechanism: Every document sits behind the same interface. The same attention heads seek all of them.

Finding patterns in your data isn't a separate step—it's a natural consequence of using the system. You query, things surface, contrasts appear.

When everything is addressable the same way, when everything responds to the same peek/poke/execute, when the same model attends to all of it—patterns that exist WILL be found. Not because you asked for pattern-finding, but because uniform access makes contrast visible.

The value: You don't hunt for insights. You use the system. Insights are the exhaust.

Wanderland components: Uniform interface across all content, consistent query semantics, pattern emergence through use

XII. Distance is Opportunity

Metaphor	Wanderland Implementation
User: Novel ideas become tomorrow's standard	Scan entire knowledge space in one query; surface what you didn't know to look for
Executive: Contrarian positions = asymmetric returns	Link across disparate areas; find patterns even you haven't seen
Technical: Graph frontier = opportunity	Fan-out query finds connections human traversal would miss

The opportunity: Scan your entire knowledge space in one go. Return insights about things you didn't know existed.

The value isn't in the nodes you visit regularly. It's in linking across disparate areas—finding a pattern that connects your infrastructure documentation to your onboarding guide to your incident postmortem. A pattern that even you haven't seen.

Query fans out → hits every node → model finds connection
→ "These three things relate in a way you never noticed"

Human traversal follows familiar paths. Parallel query finds the paths you'd never think to walk. That's where the asymmetric returns live.

Wanderland components: Parallel query fan-out, cross-domain linking, model-surfaced connections across distance

The Wanderland Stack

Instant Tools

Write a labeled fence → immediately have an MCP-compatible tool.

```python[my-tool]
def run(x, y):
    return x + y


That's now callable:
- CLI: `oculus execute my-tool --params '{"x":1,"y":2}'`
- MCP: `execute_fence({fence_id: "my-tool", params: {x:1, y:2}})`
- API: `POST /execute/my-tool`

**No deployment. No registration.** Write code, it's a tool.

**Virtual fences**: Write a TODO list, it becomes queryable:

```markdown
- [ ] First task
- [x] Done task

Automatically becomes:

execute(slug, "list") → get all tasks
execute(slug, "add", {content: "New"}) → add task
execute(slug, "toggle", {item: 0}) → check/uncheck

Patterns become tools. You write naturally; the system extracts capability.

The Stack

┌─────────────────────────────────────────────────────────────┐
│  execute (run fences, virtual fences, labeled tools)        │
├─────────────────────────────────────────────────────────────┤
│  poke (write with context, interpolation, cascading)        │
├─────────────────────────────────────────────────────────────┤
│  peek (read at any level: code/data/document)               │
├─────────────────────────────────────────────────────────────┤
│  Graph (nodes, links, fences, virtual fences)               │
├─────────────────────────────────────────────────────────────┤
│  Foundation Model (the landscape)                           │
└─────────────────────────────────────────────────────────────┘

Each node is a programmable attention head. Queries fan out organization-wide. Embarrassingly parallel. No coordination overhead.

Three operations. Everything else emerges.

Provenance

Document

Status: 🔴 Unverified

Changelog

2026-01-09 21:40: Node created by mcp - Creating grounding document - how Wanderland implements each principle across all three metaphors

West

slots:
- slug: wanderland-twelve-technical
  context:
  - Linking technical to grounding as siblings
- slug: wanderland-twelve-user
  context:
  - Cross-linking all twelve docs
- slug: wanderland-twelve-executive
  context:
  - Cross-linking all twelve docs

North

slots:
- slug: wanderland-twelve
  context:
  - Linking parent to grounding variant

↑ northwanderland-twelve

← westwanderland-twelve-technicalwanderland-twelve-userwanderland-twelve-executive