Akashic Protocol: The Universal Piping Layer

The protocol that connects everything.

What Is Akashic Protocol?

The Akashic Protocol is Rhizome's universal "piping" layer—a complete, self-contained protocol that:

Stands Alone: Operates independently, no dependencies on other protocols
Connects Everything: Universal translation layer connecting ActivityPub, Nostr, RSS, and future protocols
Represents Everything: Every distinct function from other platforms is fully represented
Transforms Easily: Seamless conversion between protocols
Simplifies Gracefully: "Simplification protocols" for sharing with less complex protocols

Think of it like this:
- ActivityPub = Simplified export format (like PDF)
- Akashic Protocol = Native format (like LaTeX source)
- You can always go from Akashic → ActivityPub, but ActivityPub → Akashic loses information

Core Principles

Protocol-Agnostic Foundation

Akashic Protocol is not ActivityPub-centric, not Nostr-centric—it's protocol-neutral. ActivityPub becomes one of many simplification protocols, not the primary one.

Lossless by Default

Full granularity is preserved internally. When exporting to simpler protocols, we gracefully simplify while documenting what's preserved and what's transformed.

Bidirectional Conversion

Seamless transformation to/from any protocol:
- Import: ActivityPub/Nostr/RSS → Akashic (with maximum information extraction)
- Export: Akashic → ActivityPub/Nostr/RSS (with graceful simplification)

Extensible & Future-Proof

New protocols emerge? No problem. Akashic Protocol accommodates them through its extensible schema.

Semantic Triplets: The Grammar of Everything

The Core Insight

Events & Entities as core, triplets as interpretations.

Events & Entities are the core:
Events = immutable history (what happened): "User X posted Y at time Z"
Entities = canonical objects (what exists): Person, Author, Tag, Media, Source - immutable, factual objects
Triplets are interpretations: Semantic triplets (Subject-Predicate-Object) are community-created interpretations layered ON TOP of events and entities, relating them to each other

Subject-Verb-Object (SVO) grammar provides a natural, grammatical way to model all interactions:

Threading: (User, references, Post) or (Post, references, Concept) - these are interpretations
Reactions: (User, likes, Post) or (User, tags, Post, with: "science-fiction") - these are interpretations
Relationships: (Post, about, Concept) or (User, follows, User) - these are interpretations

All interactions become semantic triplets—simple, queryable, extensible interpretations that can evolve, gain/lose resonance, and be added by anyone.

How It Works

Each Event Generates Triplets:

{
  "event_type": "POST",
  "user_id": "user123",
  "payload": {
    "content": "Thinking about surf movies...",
    "references": [
      "akashic://cultural/movement/surf-movies-1960s",
      "akashic://cultural/album/pet-sounds-1966"
    ]
  }
}

Becomes Triplets:

(user123, creates, post456)
(post456, references, akashic://cultural/movement/surf-movies-1960s)
(post456, references, akashic://cultural/album/pet-sounds-1966)
(post456, contains, "Thinking about surf movies...")

Powerful Query Patterns

SPARQL-style queries enable powerful graph traversal:

"What does User X reference?" → (X, references, ?object)
"What references Concept Y?" → (?subject, references, Y)
"What concepts are co-referenced with X?" → (?subject, references, X) AND (?subject, references, ?other)
"What reactions does User X have?" → (X, ?reaction_type, ?object)

Protocol Transformation

The Hierarchy of Granularity

Akashic Protocol (Full Granularity)
    ↓
ActivityPub (Simplified subset)
    ↓
Nostr (Simplified subset)
    ↓
RSS (Minimal subset)

Example: Multi-Reference Threading

Akashic Protocol (full granularity):

{
  "type": "Post",
  "author": "user123",
  "content": "Thinking about surf movies...",
  "references": [
    "akashic://cultural/movement/surf-movies-1960s",
    "akashic://cultural/album/pet-sounds-1966",
    "https://rhizome.example/post/456"
  ],
  "triplets": [
    {"subject": "post789", "predicate": "references", "object": "akashic://cultural/movement/surf-movies-1960s"},
    {"subject": "post789", "predicate": "references", "object": "akashic://cultural/album/pet-sounds-1966"},
    {"subject": "post789", "predicate": "references", "object": "https://rhizome.example/post/456"}
  ]
}

ActivityPub (simplified):

{
  "type": "Note",
  "content": "Thinking about surf movies...",
  "inReplyTo": "https://rhizome.example/post/456",
  "context": [
    "akashic://cultural/movement/surf-movies-1960s",
    "akashic://cultural/album/pet-sounds-1966"
  ],
  "rhizome:references": [
    "akashic://cultural/movement/surf-movies-1960s",
    "akashic://cultural/album/pet-sounds-1966",
    "https://rhizome.example/post/456"
  ]
}

RSS (minimal):

<item>
  <title>Thinking about surf movies...</title>
  <link>https://rhizome.example/post/789</link>
  <guid>https://rhizome.example/post/789</guid>
</item>

Transformation Rules

Lossless → Simplified:
1. Preserve core semantics (who, what, when)
2. Map to closest equivalent in target protocol
3. Store full granularity in custom properties (e.g., rhizome:references)
4. Document information loss in transformation metadata

Simplified → Lossless:
1. Infer missing information where possible
2. Use canonical URIs from Akashic Universal Mapping
3. Mark inferred data with confidence scores
4. Preserve original protocol data for round-trip

Integration with Rhizome

Akashic Universal Mapping

Canonical URIs as Subjects/Objects:
- Every triplet subject/object uses canonical Akashic URIs
- akashic://cultural/movement/surf-movies-1960s instead of freeform text
- Enables consistent querying across instances

Taxonomic Paths Inform Relationships:
- Taxonomic hierarchy suggests predicate types
- akashic://cultural/book/... suggests written_by, published_in predicates
- akashic://topic/... suggests about, discusses predicates

Event-Sourced Architecture

Events as Triplet Generators:
- Each event generates one or more triplets
- POST event → (user, creates, post) + (post, references, ...) triplets
- LIKE event → (user, likes, post) triplet

Event Log = Triplet Store:
- Event log can be queried as triple store
- Historical queries: "What did User X reference in 2024?"
- Temporal triplets: (user, references, concept, at: timestamp)

Queries = Triplet Pattern Matching:
- Graph queries become triplet pattern matching
- "Find related conversations" = find triplets sharing objects
- "Co-occurrence analysis" = find frequent triplet combinations

Rhizomatic Threading

Multi-Reference as Multiple Triplets:
- Single post with 3 references = 3 triplets
- No hierarchy, no broken threads
- Each triplet is independent

Graph Traversal via Triplets:
- "Show conversation graph" = visualize triplet relationships
- "Find related posts" = find posts sharing triplet objects
- "Discover connections" = find paths through triplet graph

The Future: Auto-Canonization

Automatic Triplet Generation:
- User types "Pet Sounds" → auto-canonize → generate triplet
- User posts about "surf movies" → auto-canonize → generate triplet
- System infers relationships from taxonomic paths

Triplet-Based Discovery:
- "You referenced Pet Sounds. Others who referenced Pet Sounds also referenced..."
- "This concept is often discussed with..."
- "Users who like this also like..."

Design Principles

Protocol-Agnostic Foundation: Akashic Protocol is protocol-neutral, not tied to any single protocol
Semantic Clarity: SVO triplets provide grammatical, queryable representation
Lossless by Default: Full granularity preserved, simplified on export
Extensibility: Can accommodate new protocols and interaction types
Canonical Consistency: Auto-canonization ensures triplet consistency
Event-Sourced: Triplets derived from events, queries on materialized views

What This Enables

✅ Universal Compatibility: Connect with ActivityPub, Nostr, RSS, and future protocols
✅ Semantic Richness: All interactions modeled as queryable triplets
✅ Graph Queries: Powerful SPARQL-style queries over social graphs
✅ Lossless Transformation: Maximum information preservation
✅ Graceful Simplification: Export to simpler protocols without breaking
✅ Future-Proof: Extensible schema accommodates new protocols

This is the foundation for a truly universal, semantic social web. 🌿

← Back to Splash