Bird's-Eye Architectural Map: Rhizome & Akashic Protocol

Date: 2025-11-06
Source: Perplexity AI Research
Context: Comprehensive architectural overview after design refinement
Status: High-level system architecture documentation

Executive Summary

This document provides a bird's-eye architectural map of Rhizome/Akashic—as it stands after all design refinement. Focus is on structure, flows, and key abstractions, not code.

Core Philosophy: You're building something alive and adaptive—where meaning is forged and reforged in real time by the swarm, not dictated by the database.

1. Foundations

A. Event Log Layer ("Factum")

Source of Truth: Immutable, append-only log—every action, social post, reaction, comment, share, annotation, etc.
Tamper-Proof: Signed, hash-chained. Survives censorship, supports sneakerware.
Portable: Everything exportable/importable (USB, mesh, network).

Key Characteristics:
- Events are immutable facts
- Cryptographic signatures ensure integrity
- Hash-chaining prevents tampering
- Foundation for all other layers

2. Semantic Layer ("TripletForge")

A. Triplet Materialization

Triplet Store = Graph View: Every event is analyzed/parsed/generated into semantic triplets (Subject-Predicate-Object), optionally time-stamped.
Community Annotation: Anyone can add new triplets—relate things, tag, interpret. This layer blossoms over time.
Canonicalization: Subjects and objects always use canonical URIs (Akashic Universal Mapping), preventing fragmentation.

Key Characteristics:
- Events generate triplets (materialized view)
- Community can add creative triplets
- All URIs are canonical (prevents fragmentation)
- Triplets are queryable, graph-traversable

B. Taxonomic Backbone

Ontology & Taxonomic Paths: All concepts, entities, topics, works, places are organized via Akashic taxonomy (navigable hierarchy/graph).
Triplet predicates/relations often suggested/generated by taxonomy.

Key Characteristics:
- Taxonomic paths inform predicate types
- Ontological classes guide triplet semantics
- Taxonomy itself modeled as triplets
- Enables semantic navigation

3. Conversation/Threading Layer ("Rhizome")

Posts reference any number of events/entities/concepts.
No hierarchy: Rhizomatic: any node can connect to any other—no single root, no tree structure.
Threads, topics, "conversations" are emergent, not imposed.
Visualized as a multi-dimensional graph (with filters/taxonomic overlays).

Key Characteristics:
- Multi-reference threading (not linear)
- No broken threads (each node independent)
- Conversations emerge from connections
- Graph visualization reveals patterns

4. Community/Curation Layer

Resonance & Social Sorting: Triplets are aggregated, ranked, endorsed, flagged, discussed.
Triplet meta-annotations: Communities can comment on, endorse, or even relate triplets (meta-triplets: triplets about triplets).
Moderation/analytics atop graph:
Most-adopted paths
Emergent vocabularies
Triplet "trails" for exploring related topics/posts

Key Characteristics:
- Social sorting determines visibility
- Community creates meaning through resonance
- Meta-triplets enable commentary on interpretations
- Analytics reveal emergent patterns

5. Federation/Protocol Transformation Layer ("Pipes/Adapters")

Akashic Protocol: Universal superset. Internal representation, lossless, extensible.
Simplification Protocols/Adapters: On export, Akashic → ActivityPub, Nostr, RSS, etc. On import, other protocols → Akashic (as far as info allows).
Transformation Manifests: Every conversion step records what was preserved/lost, supporting round-trip fidelity and user transparency.

Key Characteristics:
- Akashic Protocol is source of truth
- Bidirectional transformation (import/export)
- Lossless by default, simplified on export
- Transformation manifests track information loss

6. Discovery/Search Layer

Powerful Queries: SPARQL-like pattern search over triplets (What posts reference X and Y? Who has endorsed connection P-Q?).
Semantic Navigation: Users step through taxonomic/graph relationships, not just keyword/content search.

Key Characteristics:
- Pattern matching over triplets
- Graph traversal queries
- Taxonomic navigation
- Co-occurrence discovery

7. UX/UI Layer

Compose: Event creation with multilayer referencing, auto-suggested taxonomic concepts.
Browse/Explore: Feeds, graph visualization, taxonomic overlays, triplet trails.
Annotate/Relate: Interaction for creating new triplets/relations atop events or concepts.
Export/Import: Seamless sneakerware, connection to adapters.

Key Characteristics:
- Multi-reference input with autocomplete
- Graph visualization
- Triplet creation interface
- Export/import workflows

Data & Flow Map

┌─────────────────────────────────────────────────────────────┐
│              IMMUTABLE EVENT LOG (Factum)                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │   Post   │  │ Reaction │  │ Comment  │  │Annotation │  │
│  │  Event   │  │  Event   │  │  Event   │  │  Event    │  │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘  │
└───────┼─────────────┼──────────────┼──────────────┼────────┘
        │             │              │              │
        └─────────────┴──────────────┴──────────────┘
                           │
                           ▼
        ┌──────────────────────────────────────────┐
        │    TRIPLET MATERIALIZATION (TripletForge) │
        │  ┌────────────┐  ┌────────────┐          │
        │  │   SVO      │  │ Community  │          │
        │  │ Triplet(s) │  │ Triplet(s) │          │
        │  └─────┬──────┘  └─────┬──────┘          │
        │        │                │                 │
        │        └────────┬───────┘                 │
        │                 │                         │
        │        ┌────────▼────────┐                │
        │        │  Meta-Triplets  │                │
        │        └────────┬────────┘                │
        └─────────────────┼────────────────────────┘
                           │
        ┌──────────────────┼──────────────────┐
        │                  │                  │
        ▼                  ▼                  ▼
┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│   AKASHIC    │  │   RHIZOMATIC │  │   COMMUNITY  │
│   TAXONOMY   │  │     GRAPH    │  │   CURATION   │
│              │  │              │  │              │
│ Pet Sounds   │  │ Conversation │  │ Resonance &  │
│ Surf Movies  │  │ Graph        │  │ Social       │
│              │  │ Topic Trails │  │ Sorting      │
└──────┬───────┘  └──────┬───────┘  └──────┬───────┘
       │                 │                 │
       └─────────────────┴─────────────────┘
                         │
                         ▼
        ┌────────────────────────────────────┐
        │   PROTOCOL ADAPTERS (Federation)   │
        │  ┌──────────┐  ┌──────────┐        │
        │  │ Akashic  │  │ActivityPub│      │
        │  │ Protocol │  │          │        │
        │  └────┬─────┘  └────┬─────┘        │
        │       │             │              │
        │       └──────┬──────┘              │
        │              │                     │
        │       ┌──────▼──────┐             │
        │       │ RSS/Nostr/  │             │
        │       │ Other       │             │
        │       └─────────────┘             │
        └────────────────────────────────────┘

Summary: Living Architecture

Core Principles:

Immutable facts (events) are the roots - Source of truth, tamper-proof, portable
Triplets and annotations are the rhizomes - Branching, creative, semantic, community-driven
Taxonomy is the backbone of meaning - Canonical URIs, ontological classes, taxonomic paths
Community filters, ranks, and discovers what matters - Resonance deepens paths, social sorting surfaces meaning
Federation/conversion ensures survival, interoperability, and outreach - Akashic Protocol as superset, graceful simplification
UI reveals the multidimensional graph - Making sense of the whole through visualization and navigation

Key Abstractions

Event Log ("Factum")

Immutable, append-only
Signed, hash-chained
Portable (sneakerware-ready)

Triplet Store ("TripletForge")

Materialized from events
Community-enriched
Canonical URIs only

Rhizomatic Graph

Multi-reference threading
No hierarchy
Emergent conversations

Community Curation

Resonance-based sorting
Meta-triplets
Emergent vocabularies

Protocol Adapters

Akashic Protocol (superset)
Bidirectional transformation
Transformation manifests

Flow Patterns

Event Creation Flow

User Action → Create Event → Event Log
                    ↓
            Materialize Triplets
                    ↓
            Update Triplet Store
                    ↓
            Update Rhizomatic Graph
                    ↓
            Propagate via Adapters (if needed)

Triplet Annotation Flow

User Creates Triplet → Validate Canonical URIs
                    ↓
            Store Triplet
                    ↓
            Update Graph
                    ↓
            Track Resonance
                    ↓
            Surface if Resonant

Protocol Transformation Flow

Akashic Protocol (Full Granularity)
            ↓
    Transformation Layer
            ↓
    ┌───────┴───────┐
    ↓               ↓
ActivityPub      RSS/Nostr
(Simplified)    (Minimal)

Implementation Layers

Layer 1: Event Log

RhizomeEvent model
Cryptographic signing
Hash chaining
Export/import functionality

Layer 2: Triplet Materialization

Event → Triplet parser
Community triplet submission
Canonical URI validation
Triplet store (materialized view)

Layer 3: Taxonomic Backbone

AkashicUniversalMapping model
Taxonomic path generation
Ontological classification
Canonical URI resolution

Layer 4: Rhizomatic Graph

Multi-reference threading
Graph query service
Conversation discovery
Co-occurrence analysis

Layer 5: Community Curation

Triplet endorsement
Resonance tracking
Meta-triplet support
Analytics/insights

Layer 6: Protocol Adapters

Akashic Protocol serializer
ActivityPub adapter
RSS adapter
Nostr adapter (future)
Transformation manifests

Layer 7: Discovery/Search

SPARQL-like queries
Graph traversal
Taxonomic navigation
Pattern matching

Layer 8: UX/UI

Compose interface
Graph visualization
Triplet creation
Export/import UI

Design Principles

Event-Sourced: Events are immutable facts, everything else is derived
Semantic: Triplets provide grammatical, queryable representation
Rhizomatic: No hierarchy, multiple entry points, emergent meaning
Community-Driven: Meaning emerges from resonance, not top-down
Protocol-Agnostic: Akashic Protocol is source of truth, others are exports
Canonical: All URIs are canonical, preventing fragmentation
Extensible: New predicates, objects, ontologies can be added
Lossless: Full granularity preserved, simplified on export

Success Criteria

✅ Events are immutable, tamper-proof, portable
✅ Triplets materialize from events, community can add more
✅ All URIs are canonical (Akashic Universal Mapping)
✅ Conversations are rhizomatic (multi-reference, no hierarchy)
✅ Community resonance determines triplet visibility
✅ Akashic Protocol can represent everything from other protocols
✅ Bidirectional transformation preserves maximum information
✅ Graph queries enable semantic discovery
✅ UI reveals multidimensional graph structure

References

Event-Sourced Architecture: rhizome_app/models/rhizome_event.py
Akashic Universal Mapping: rhizome_app/models/akashic.py
Rhizomatic Threading: docs/implementation_plans/rhizomatic_threading_system.md
Akashic Protocol: docs/implementation_plans/akashic_protocol_semantic_triplets.md
Triplet Layering: docs/perplexity_research/triplet_layering_community_meaning.md

Next Steps: This architectural map provides the high-level overview. For implementation details, see:
- Event log implementation: Sneakerware Foundation Architecture
- Triplet materialization: Akashic Protocol and Semantic Triplets design
- Rhizomatic threading: Rhizomatic Threading System design
- Community curation: Triplet Layering and Community-Made Meaning research

← Back to Splash