The Metagraph · Looikos

1. The thesis

Everything captured so far 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. Together they make 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 the WikiDesignCo data-platform design (WikiDesignCo is the substrate, the intermediate representation and the compiler wrapped around it). It's also what the harness queries before acting and writes to after, and it's the lens that tells a recon desk whether a graph, memory, or data repo helps us build, hold, or query this thing.

Current state (2026-06-19 finding). WikiDesignCo isn't built this way yet. I 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 sprawl is the metagraph's absence showing through, and it's the failure my mechanical-owner-loop law names (consistency has to come from a mechanical loop, not from human discipline): the artifacts outran the loop meant to keep them consistent. The fix is the thesis itself: a typed genome (one typed definition for every kind of thing in the business) and a template/IR that the artifacts are generated from and held consistent by, not 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)

The substrate chapter of Echolocation lays out the escalation 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. Addressable edges give you rules about rules, confidence on the confidence, and a record of where a fact came from, what it depends on, when it was true, and what it contradicts.

That third property is what lets the world-model hold its 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 doesn't 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), and extended SurrealDB is the someday option. Build the shovel before the cathedral.

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

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

The Looikos entity types, drawn from all the assets, fall into four layers:

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 drawn from the community's language, the first-person 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 a 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 (graded on a medallion scale from bronze to diamond)

Cross-cutting

Decision (a choice + heuristic + authority + rationale; the fact at the hierarchy's seventh rung), Person (Andy, clients, collaborators, people earning ownership through 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. The hierarchy's nine rungs (Mission, Objective, Initiative, Project, Task, Action, Decision, Data, Event) are themselves node types, and Purpose, the rails above them, is the alignment property every node inherits. The hierarchy is the structural spine of the graph, not metadata bolted on, which is 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. These are 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 ownership share that grows over time recorded in 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 spans five memory stores, with the world-model distributed across them by the time-and-truth rule and one store 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, which makes it the working brain. It gets seeded with a minimal set of foundational facts from the raw knowledge base and grows through 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's syntax tree (AST), a separate graph for "where is the code," kept apart from the business metagraph.
Agent instruction files, skills, and hooks hold agent character, not world-state.
claude-mem, where it's used, holds the strategist agent's private memory of its past sessions.

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 here too: the maintenance agents that crawl Graphiti for stale facts and conflicts are the loop that keeps the metagraph accurate without relying on human discipline.

6. How the harness operates on it

The harness 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 I 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 same model, because its live call transcripts become episodes and its emergent rep skills become edges shaped like an agent's skill edge, 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 judgments as well as facts, and that's 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 score (from a checklist of common design failures) as annotations on the node itself, so prioritizing the capability 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 each angle's valuation 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 the generalization their scoring rubric demands. Each graph, memory, or data repo faces a precise question in place of the vague "does it strengthen the harness": 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.

For the brand desks, the metagraph is the schema their deep-dives populate: each brand deck describes one Brand node plus its Angles, Personas, Market, and build edges. The 32 brand 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 work 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 still stands as the world-model canon. What it didn't 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 touch the platform, so the world-model doesn't 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. That pipeline applies the metagraph's provenance and bi-temporal discipline to experience as well as to facts. The platform is fractal in content AND in memory: many agents share one memory.

One rule holds 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 on every screen a user sees. Users see Sources, Coverage, Freshness, and Where-this-came-from, and the interface never uses Goertzel, quantum, or "metagraph" as 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 and the statements layer becomes the world-model, which means two representations, one graduation pass, and 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 grades the current build structure by structure and specifies this claims layer; the memory-layer design builds the episodic pipeline on top of it.

Serialization update (OKF). The five-store serialization model from section 5 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 only the interchange skin, and the claims layer stays the reasoning substrate. The result is one IR with several serializations (Graphiti episodes, vector records, OKF files).

Related reading: the ecosystem overview, the Floor, the IR and compiler frame, the five-store memory design and its Graphiti schema, the Echolocation substrate chapter, the nine-rung hierarchy, and the data-architecture and convergence-flow-framework skills, which carry the ECS derivation engine.