RDF stands for Resource Description Framework. But it probably shouldn’t.
In 1980, Gilles Deleuze and Félix Guattari published A Thousand Plateaus and introduced the concept of the rhizome — a structure with no beginning, no end, no hierarchy, and no center. Any point can connect to any other point. There is no trunk from which branches grow. There are only connections.
In 1999, the W3C published the Resource Description Framework — a data model where there are no objects, no tables, no schemas. There are only triples: subject, predicate, object. Any node can connect to any other node through any relationship. There is no root. There is no hierarchy unless you choose to assert one.
The resemblance is not a coincidence. It is a convergence. Two completely different disciplines — Continental philosophy and web standards engineering — arrived at the same structural insight independently: the most expressive way to represent knowledge is a flat, non-hierarchical network of relationships.
Deleuze and Guattari defined six characteristics of a rhizome. Every single one maps directly onto RDF.
“Any point of a rhizome can be connected to any other, and must be.”
In RDF, any IRI can be the subject or object of any triple. There are no type restrictions at the data model level. A person can be connected to a number, a concept, a geographic coordinate, another person, or a quoted triple about any of these. The graph imposes no constraints on what can connect to what — those are application-layer choices, not structural ones.
:Deleuze :influences :RDF .
:RDF :enables :Deleuze .
# Both valid. Neither is primary.“A rhizome ceaselessly establishes connections between semiotic chains, organizations of power, and circumstances.”
RDF triples are radically heterogeneous. In the same graph, you can store a person’s name, a mathematical proof, an embedding vector, a geographic boundary, a legal contract, and a musical score. They are all triples. They all live in the same index. There is no “type system” separating them into different storage structures — the heterogeneity is the point.
Relational databases enforce homogeneity: every row in a table has the same columns. Document stores allow some flexibility but still cluster by “collection.” RDF is the only mainstream data model where heterogeneity is the default.
“There are no points or positions in a rhizome, such as those found in a structure, tree, or root. There are only lines.”
In RDF, nodes have no intrinsic properties. A node is nothing but the set of relationships it participates in. Remove all triples involving :Alice and Alice ceases to exist — not because she was “deleted,” but because there is nothing left to say about her. Identity is constituted entirely by relationships.
This is profoundly different from relational databases, where a row exists independently of its foreign keys. In RDF, there are no rows. There are no objects. There are only relationships between identifiers.
“A rhizome may be broken, shattered at a given spot, but it will start up again on one of its old lines, or on new lines.”
RDF graphs are robust to partial destruction. You can delete any subset of triples and the remaining graph is still a valid, queryable RDF graph. There is no “schema migration” required. There is no integrity constraint that forces cascading deletes. The graph simply has fewer statements, and everything else continues to work.
This is the Open World Assumption in action: the absence of a statement means we don’t know, not that it’s false. A ruptured rhizome doesn’t become invalid — it just becomes less complete.
“A rhizome is not amenable to any structural or generative model. It is a map, not a tracing.”
An RDF graph is a map of a domain, not a schema that generates instances. You don’t define a “Person table” and then fill in rows. You make statements — :Alice rdf:type :Person — and the “schema” emerges from the data. OWL ontologies describe the territory after the fact; they don’t prescribe it.
This is why Loka stores first and reasons second. The database is a map of what you’ve asserted. OWL validation happens in the SDKs, not in the storage engine. The map is never rejected for failing to match a tracing.
“A rhizome is not a tracing but a map that is always detachable, connectable, reversible, modifiable, and has multiple entryways and exits.”
SPARQL queries can enter the graph from any node and traverse in any direction. There is no “starting table.” There is no “root entity.” Every query is a pattern that can match anywhere in the graph. The SPO, POS, and OSP indexes exist precisely to ensure that any entry point is efficient — subject-first, predicate-first, or object-first.
Property paths (:knows+) traverse arbitrary depth without specifying a direction at the schema level. The graph is as traversable backward as forward. There is no canonical direction.
Relational databases, XML, JSON, file systems. Data flows from a root through branches. Every node has exactly one parent. The structure prescribes the data.
CREATE TABLE person (
id INT PRIMARY KEY,
name VARCHAR(255),
parent_id INT REFERENCES person(id)
);A person must have an id. A person must have a name column, even if empty. The tree defines what can exist.
Knowledge graphs, linked data, the semantic web. Any node connects to any node. No root. No required structure. The data constitutes the structure.
:alice :name "Alice" .
:alice :knows :bob .
:bob :teaches :alice .
# No schema needed. Just statements.Alice exists because we said something about her. She has no “required fields.” The graph is whatever we assert it to be.
Large language models and AI agents operate rhizomatically. They don’t traverse a tree from root to leaf — they associate across a network of concepts, following whatever connection seems most relevant in context. A query about Napoleon might traverse through “emperor” to “coronation” to “Notre-Dame” to “Gothic architecture” to “flying buttresses.” There is no predetermined path.
Storing knowledge for AI in a tree structure (SQL tables, JSON documents) forces the AI to think in terms of joins and key lookups. Storing it in a rhizome (RDF) lets the AI think in terms of traversal — which is how it already reasons internally.
Loka makes this explicit: the graph is the knowledge, the HNSW index is the associative leap, and SPARQL+ is the language for expressing both structured traversal and semantic proximity. The rhizome is the database.
SQL databases operate under the Closed World Assumption: if a row doesn’t exist, the fact is false. This is arborescent thinking — the tree defines the universe, and anything outside the tree doesn’t exist.
RDF refuses this closure. The graph is always open to new connections, new entities, new relationships that weren’t anticipated when the “schema” was designed. This is why RDF scales to the complexity of the real world in ways that relational databases cannot — the real world is a rhizome, not a tree.
RDF officially stands for Resource Description Framework. The “Resource” in the name comes from the web — URIs identify resources, and RDF describes relationships between them.
But Rhizomatic Description Framework is arguably more accurate. RDF doesn’t describe resources the way a database schema describes a table. It describes a network of relationships that has no center, no hierarchy, and no boundary. It is, structurally and philosophically, a rhizome.
Deleuze never wrote about RDF. The W3C never cited A Thousand Plateaus. But they built the same thing.