The Metagraph · Looikos

The Looikos ecosystem modeled as a metagraph: the data model the WikiDesignCo platform holds and the harness operates on. This stretches the captured context (the ecosystem, the three-angle model, the Floor, the valuation grounding, the personas) across all the assets by treating them as one typed world-model, which is simultaneously the data-platform design, the harness's world-model, and the target the data/memory recon desks judge their repos against. Written 2026-06-19 from,, the Echolocation metagraph chapter, the nine-rung hierarchy, and the Harness V2 memory architecture. Extrapolations marked. Voice: zero em dashes, no AI-tells, direct.

1. The thesis

Everything captured this session is the same object seen from different sides. The ecosystem is a graph of brands. Each brand is a node with three valuation angles, a set of personas, a customer base, a service operating model, a software stack, and a finance profile. The Floor is a graph of pods, reps, calls, and the emergent skills between them. The harness is a graph of agents, issues, PRs, capabilities, and the repos those capabilities were harvested from. The operational hierarchy is a graph from Mission down to Event. These are not separate diagrams. They are one connected world-model, and the data structure that holds a world-model that knows what it knows is a metagraph.

So modeling Looikos as a metagraph is not a side exercise. It is the WikiDesignCo data-platform design (WikiDesignCo is the substrate, the intermediate representation and the compiler wrapped around it), it is what the harness queries before acting and writes to after, and it is the lens that tells a recon desk whether a graph/memory/data repo actually helps us build, hold, or query this thing.

Current state (2026-06-19 finding). WikiDesignCo today is not yet this. Andy went to update an element and found that each article the agents wrote is a separate, independent HTML file with no shared template (a few were produced in templatized bundles; the rest are a mess under the hood). That is the metagraph's absence showing through, the exact failure the mechanical-owner-loop law names: artifacts outran the consistency loop. The fix is the thesis itself, a typed genome and a template/IR the artifacts are generated from and held consistent by, never hand-rolled one-offs. The templateless HTML sprawl is the before; the metagraph-plus-genome is the after.

2. Why a metagraph (the escalation, recapped)

From the Echolocation substrate chapter, the shape escalates in three steps and the third is the one that matters:

A graph gives nodes and edges. This relates to that.
A hypergraph lets one edge bind many participants at once, because a real fact has many participants bound into one event.
A metagraph makes the edges themselves addressable: you can point at a relationship, annotate it, connect it to other relationships, and reason about it. Rules about rules. Confidence on the confidence. Where a fact came from, what it depends on, when it was true, what it contradicts.

That third property is what lets the world-model hold its own uncertainty. Every fact carries a confidence, a provenance (the episode that produced it), and a bi-temporal validity window (when it became true, when it was superseded). The graph is the memory; the loop around the graph (evaluation, confidence propagation, the maintenance agents that crawl it for stale facts and unresolved conflicts) is the intelligence. The metagraph is the only data structure that does not lie to itself, because it can revise a belief when evidence moves instead of defending it.

The pragmatic build tiers stay as Echolocation set them: Graphiti on Neo4j is the pseudo-metagraph that ships now (a temporal layer stamping every fact with validity), Goertzel's Atomspace is the north star (the real metagraph where even the programs are subgraphs), extended SurrealDB is the someday. Build the shovel before the cathedral.

3. The genome (entity types, the Pydantic-IR)

Every node is a typed Pydantic model. That is the genome and the intermediate representation: one model definition, every backend (graph, vector store, table), per the Pydantic-as-IR discipline. ECS applies: an entity is a typed model, a component is a typed attribute, a system is a pure function that transforms entities. Entities stay thin (a node holds a judgment and a pointer, never the 5,000-word doc; that lives in Notion and the node references it).

The Looikos entity types, synthesized across the assets:

Ecosystem / business layer

Brand (the self-standing project; status, cluster, the apex it ladders to)
Angle (Finance / Software / Service; the three valuation faces of a brand)
Persona (5+ per brand; the world-experience, the Lexicon-of-Pain language, the I-Am framing)
Customer / Account (retainer payer; MRR, tier, lifecycle)
Service (a retainer engagement, any vertical; the $2-12k+ unit)
Offer / Product (the accessible $1-2k tier through the premium tiers)
Market (the demand pool a brand fishes in; the Wardley value chain it sits on)

Operating layer (the Floor)

Pod (3-8, optimal 3-5), Rep (customer-success human), Call (a customer conversation), Transcript (the live overhearable substrate, the episode source), Skill (the emergent expertise between reps and agents)

Build / harness layer

Capability (a thing the harness can do; the unit the value rubric scores), Repo (the external OSS source a capability is harvested from), AgentConfig (a specialized agent / desk), FeatureFactory (a domain's harness bundle), Issue / PR / CodeArtifact (the execution units), Asset (medallion-tiered bronze→diamond)

Cross-cutting

Decision (a choice + heuristic + authority + rationale; the rung-7 fact), Person (Andy, clients, collaborators, owners on the franchise on-ramp), Topic / Concept (the cultural priors: the nostalgia index, the catharsis map, the joke taxonomy from the substrate chapter), Episode (the raw occurrence that produced a fact)

The nine-rung spine in the graph. Mission, Objective, Initiative, Project, Task, Action, Decision, Data, Event are themselves node types, and the Purpose rails are the alignment property every node inherits. The hierarchy is not metadata bolted on; it is the structural spine of the graph, which is exactly why every artifact carries all nine rungs. The graph IS the hierarchy made navigable.

4. The relationships (edges, themselves addressable)

The value lives in the edges, and because this is a metagraph each edge is a node you can annotate with confidence, provenance, and validity. The load-bearing relations:

BRAND_HAS_ANGLE (Brand → Finance/Software/Service), BRAND_SERVES_PERSONA, PERSONA_CARRIES_PAIN (→ Topic), BRAND_FISHES_MARKET
ACCOUNT_PAYS_RETAINER_FOR (Account → Service → Brand), OFFER_LADDERS_TO (accessible → premium)
POD_COVERS_CALL, REP_WORKS_CALL, TRANSCRIPT_OF_CALL, REP_HAS_SKILL, AGENT_HAS_SKILL (the emergent-specialization edge that is the same shape for humans and agents)
CAPABILITY_HARVESTED_FROM (Capability → Repo), BRAND_BUILT_FROM (Brand/FeatureFactory → Capability), AGENT_SPECIALIZES_IN (AgentConfig → domain), ISSUE_PRODUCES_PR, PR_TOUCHES_CODE
DECISION_ABOUT (Decision → anything), PERSON_OWNS_SHARE_OF (the franchise on-ramp edge, with the share-grows-over-time property as the edge's bi-temporal annotation), CONTENT_COVERS_TOPIC, ASSET_USED_IN
The hierarchy edges: MISSION_HAS_OBJECTIVE … DATA_FROM_EVENT, top-down for constraint and bottom-up for evidence.

The edge-as-node property is what lets the platform reason about the business itself: "how confident are we, and since when, that this persona's pain drives this brand's retainer demand" is a query against an annotated edge, not a guess.

5. Where it lives (the five-surface mapping)

The metagraph is not one store; it is the world-model distributed across the five memory surfaces by the time-and-truth rule, with one surface as its live home:

Graphiti is the live metagraph instance (the pseudo-metagraph today). It holds the entities, the annotated edges, the episodes, the confidence and validity. Agents query it before acting and write an episode after. This is the working brain. Seed minimally (cornerstones from RAW_knowledgebase), grow by work.
Notion holds the durable documents the nodes reference (the 5,000-word spec a Brand or Service node points at). The node is thin; Notion is the full text.
Graphify holds the code AST, a separate graph for "where is the code," never conflated with the business metagraph.
+ skills + hooks hold agent character, not world-state.
claude-mem (conditional) holds the strategist's private episodic continuity.

The genome (Pydantic-IR) is what keeps these coherent: the same typed model serializes into Graphiti, a vector store, or a Convex table, so the world-model has one definition and many homes. The mechanical-owner-loop law applies: the maintenance agents that crawl Graphiti for stale facts and conflicts are the loop that keeps the metagraph honest without human discipline.

6. How the harness operates on it

This is where the business context and the build close into a single loop. Every agent queries the relevant slice of the metagraph before it acts and writes a distilled episode back afterward, so the world-model grows along the path of current work rather than as a separate documentation chore that rots the moment it is written. The GLM parallelization layer deepens that same loop: when it runs several candidates for a high-priority asset, evaluates them, and reconsolidates the winner, both the winner and the contest that produced it persist as nodes and annotated edges, which turns the thing Andy used to do by hand with no record into a permanent, queryable contribution that the next decision builds on instead of rediscovering. The Floor writes into the very same model, because its live call transcripts become episodes and its emergent rep skills become edges of exactly the shape an agent's skill edge takes, so the human desk and the agent fleet are feeding one graph and the human/agent isomorphism stops being a metaphor and becomes literal in the data.

The graph carries the judgments, not only the facts, and that is what makes the rest of the system a query rather than a manual chore. A Capability node holds its Wardley evolution stage, its target system, its promise-dependencies, and its seven-sins-checked score as annotations on the node itself, so prioritizing the wish-list becomes a traversal of the metagraph rather than a spreadsheet maintained anxiously beside it. Valuation works the same way: each brand's three Angle nodes carry the unit economics, the comparable exits, and the live sentiment, so the market-maker read across fundamentals, technicals, and sentiment is a structured query over the graph, and the per-angle floor is computed from real nodes instead of asserted on a slide.

7. Why this grounds the recon (the payoff for the desks)

The data, memory, and orchestration desks now have a concrete target to judge their repos against, which is exactly the generalization the rubric demands. The question for a graph/memory/data repo is no longer the vague "does it strengthen the harness" but the precise: does it help us build, hold, query, or maintain THIS metagraph? Does it give us addressable edges? Bi-temporal validity? Confidence propagation? Community detection over the world-model? A cheaper path from Pydantic-IR to a queryable store? The Graphiti-to-Atomspace-to-SurrealDB tiering is the build axis they map candidates onto. A repo that moves us toward the real metagraph (edges as first-class, self-maintaining loop) scores high in the data domain; one that is just-another-vector-store scores low.

And for the brand desks, the metagraph is the schema their deep-dives populate: each deck is really a description of one Brand node plus its Angles, Personas, Market, and build edges. The 32 decks are the first real seeding of the Looikos metagraph.

8. The one-line version

Looikos is a metagraph; WikiDesignCo is the platform that holds it; the harness is what reads and writes it; the Floor and the fleet are the two kinds of agent that feed it; the three-angle valuation, the personas, the capabilities, and the nine rungs are its entity and edge types; and the recon is the first seeding. Model the world once, as a metagraph that knows what it knows, and every asset becomes a view over the same source.

9. Addendum: the four faces and the V1 build (2026-07-04)

This document is the world-model canon and it still holds. What it did not yet name is that WikiDesignCo, the platform that holds this metagraph, presents as one thing with four faces, and the metagraph described above is the fourth of them. The other three are how operators and clients actually touch the platform, so the world-model does not read as an abstraction:

The central knowledge platform: one central pool of assets typed by primitive format, with workspaces and first-class knowledge bases as fractal views over it. The corpus answers "what do we have"; the metagraph answers "what do we know and how sure are we."
The client-powering engine: a workspace per company and client, a world-model business brief as the first workload, and a domain authority map (Sources, Coverage, Freshness, Where-this-came-from) as the workspace home view. The map is the metagraph made legible to a non-graph-theorist.
The unified memory layer: CRM threads, docs, agent conversations, and customer-service threads all land as assets and consolidate into episodes, then assessments, then improvement proposals, then permanent greenlit-or-archived-with-reasoning decisions, all queryable. This is the metagraph's provenance and bi-temporal discipline applied to experience, not just to facts. Fractal in content AND in memory: many agents, one shared memory.

The load-bearing rule for all four faces: the machinery this document names (reified statements, confidence on confidence, bi-temporal validity, contradiction engine, the self-maintaining loop) stays abstracted behind plain words in every user-facing surface. Sources, Coverage, Freshness, Where-this-came-from. Never Goertzel, never quantum, never "metagraph" as UI vocabulary. The habit is what ships; the theory stays under the hood.

Build tiering, made concrete by the V1 build. "Build the shovel before the cathedral" resolved into a decision: the claims layer (reified statements plus a statementRelation table for facts-about-facts and contradictions) ships Convex-native now, because Convex rows already have ids, so an edge modeled as a row can be referenced by another row (the cheap reification seam). The co-occurrence graph stays as the HippoRAG retrieval index; the statements layer becomes the world-model; two representations, one graduation pass, no always-on graph store. The documented graphitiGroupId namespace is the seam that graduates this to Graphiti on Neo4j later without a rewrite. The alignment audit at grades the current build structure by structure and specifies this claims layer; the memory-layer design at builds the episodic pipeline on top of it.

Serialization update (OKF). §5's five-surface serialization model gains one interchange target: the Pydantic-IR genome emits Open Knowledge Format bundles (a directory of markdown files with YAML frontmatter, Google's vendor-neutral spec) as the portable, git-native, human-and-agent-readable file form. OKF's flat typed frontmatter with one required key is the exact shape of a thin Pydantic node, so emitting it is a short serialization path rather than a translation project. OKF is the interchange skin, not the reasoning substrate; the claims layer stays the reasoning substrate. One IR, several serializations (Graphiti episodes, vector records, OKF files). Verdict:.

Platform source-of-truth set:,,,,,,.

Related:,, (the IR/compiler frame), §6 (the five-surface memory + the Graphiti schema), (the Echolocation substrate chapter),, and the data-architecture / convergence-flow-framework skills (the ECS derivation engine).