Architecture Guide

The Fabric of Knowledge

Understanding how Fabric, Weaves, Looms, and Strands compose the Codex—so superintelligence can traverse across weaves and synthesize knowledge as a whole.

Weave: The Universe

A weave is the highest-level container. It represents a complete, self-contained knowledge domain. Within each weave, multiple looms organize related content into coherent collections.

Weave

A complete universe of knowledge. Self-contained, comprehensive collections that form the top-level organization.

Example: weaves/openstrand/

Loom

Curated collections within a weave. Groups related strands by topic, purpose, or theme.

Example: looms/architecture/

Strand

Individual knowledge units. Documents, guides, references—the atomic building blocks of the codex.

Example: architecture.md

Fabric → Weave → Loom → Strand architecture diagram

The Hierarchy

Frame Codex uses a simple yet powerful four-tier hierarchy to organize all knowledge. Each layer serves a specific purpose and enables different types of relationships and queries.

Fabric: The Whole

A Fabric is a collection of weaves—an entire knowledge corpus viewed as one living whole. The Frame Codex itself is a fabric. Operating at fabric scope allows agents and superintelligence to move seamlessly across weaves, aggregating and synthesizing information holistically.

Example:

fabric: Frame Codex
├─ weave: frame        (Frame ecosystem)
├─ weave: wiki         (Meta-docs, governance)
└─ weave: technology   (Technical knowledge)

Superintelligence Mode: At fabric scope, retrieval and reasoning can traverse any weave boundary with provenance preserved.

Weave: The Universe

A Weave is a complete, self-contained knowledge universe. Think of it as a separate dimension where all knowledge is related, but nothing connects to other weaves.

Example Structure:

weaves/
  frame/          ← Frame ecosystem weave
    weave.yaml
    looms/
      openstrand/
      agentos/
  science/        ← Separate science weave
    weave.yaml
    looms/
      physics/
      biology/

Key Rule: No relationships exist between different weaves. This ensures clean boundaries and prevents knowledge pollution.

Loom: The Collection

A Loom curates related strands into a cohesive topic or learning path. It defines how strands connect and in what order they should be consumed.

Example loom.yaml:

slug: getting-started
title: Getting Started
summary: Essential guides for new users
ordering:
  type: sequential
  items:
    - installation
    - hello-world
    - core-concepts

Ordering Types: Sequential (linear path), Hierarchical (tree), or Network (graph)

Strand: The Unit

A Strand is the atomic unit of knowledge. It can be a markdown document, image, dataset, code snippet, or any content type. Each strand is immutable and versioned.

Example frontmatter:

---
id: 550e8400-e29b-41d4-a716-446655440000
slug: architecture-overview
title: Architecture Overview
summary: System design and patterns
version: 1.0.0
difficulty: intermediate
relationships:
  requires:
    - core-concepts
  references:
    - api-reference
---

Relationships: Strands can require prerequisites, reference related content, and link to external resources.

Why This Matters

For LLMs:

Structured metadata enables precise retrieval. LLMs can navigate prerequisites, understand context, and extract exactly what they need.

For Humans:

Clear organization makes browsing intuitive. Follow learning paths, discover connections, and explore topics systematically.

For Scale:

Weaves isolate domains, preventing complexity explosion. Each weave can grow infinitely without affecting others.

Real-World Example

The Frame ecosystem weave contains everything about Frame.dev products:

Weave:frame

Loom:openstrand

Strand:architecture.md

View this example in Codex

Ready to Explore?

Dive into the free community edition or reserve a Lifetime license with sovereign storage, private exports, and premium tooling.

Browse Codex Download Free Edition Lifetime Edition Waitlist

Technical Implementation

The Weave/Loom/Strand architecture is implemented as a file-based system on GitHub, making it transparent, versionable, and accessible to both humans and machines.

File Structure

Each primitive maps to a specific file structure:

Fabric: Entire repository (multiple weaves), represented by the repo itself
Weave: Directory with weave.yaml manifest
Loom: Subdirectory with loom.yaml manifest
Strand: Individual file with YAML frontmatter

Metadata & Search

Every commit triggers auto-indexing that:

Extracts keywords using TF-IDF algorithm
Categorizes content with NLP
Validates schema compliance
Builds searchable index
Generates relationship graph

For Developers

Access the knowledge programmatically:

// Fetch a specific strand
const response = await fetch(
  'https://raw.githubusercontent.com/framersai/codex/main/' +
  'weaves/frame/looms/openstrand/strands/architecture.md'
);
const content = await response.text();

// Or use the Frame API
const data = await fetch(
  'https://api.frame.dev/v1/strands/openstrand-architecture'
);

Learn More

OpenStrand Architecture

Deep dive into the technical architecture

Schema Reference

Complete schema documentation with examples

Deployment & Editions

The open-source edition is free forever—fork it and deploy to GitHub Pages or any static host. The optional Lifetime Edition adds sovereign storage (S3, Postgres, Snowflake, air-gapped file drops), scheduled exports, encrypted offline bundles, and premium governance tooling for teams that need to keep data off of GitHub.Join the waitlistto reserve one-time pricing, ordownload the free editiontoday.