Uni-Versum argues that personal information systems fail because they manage information rather than knowledge. The difference: information is data plus context; knowledge requires semantic relationships, a point of view, and boundaries that protect focus without severing connections. Every existing tool — file systems, SaaS platforms, personal knowledge management applications — solves one piece of the problem within its own boundary and forces the human to be the integration layer across all boundaries.
The proposed architecture reverses this. Instead of humans adapting to tool-imposed structures, the system organizes from the human’s perspective outward. The human is the center of gravity; workspaces orbit that center; a formal vocabulary gives relationships machine-readable meaning; boundaries repeat fractally at every scale.
Gracia frames the problem through three failures: fragmentation (information scattered across systems that do not communicate), imposed perspective (every tool forces its own organizational model), and sovereignty loss (SaaS platforms own the data and can change terms unilaterally). The DIKW pyramid (data, information, knowledge, wisdom) provides the analytical framework: most tools marketed as “knowledge management” actually manage information. Knowledge requires semantic relationships, perspective, and boundaries — three things no current tool provides together.
The most architecturally significant claim: “Connection differs from relationship. Stating ‘Note A links to Note B’ conveys nothing regarding the reason for connection, the nature of the link, or the significance for the individual. This constitutes mere connection without comprehension.”
Four solution categories are analyzed: file systems (hierarchical, no semantics), SaaS (sovereignty lost, fragmentation by design), integrations (plumbing not architecture — “Copying a Slack message into a Notion database does not make them related in any meaningful way”), and personal knowledge management tools (local sovereignty solved, but bidirectional links carry no type information).
The PKM critique is the sharpest: “A graph of untyped links is a map with roads but no labels. You can see that places are connected, but you do not know if a road is a highway or a footpath, if it goes one way or both, if it is open or closed. The structure is visible; the meaning is not.”
The pattern of failure distills to four recurring steps: recognize a real problem, solve it within the tool’s boundary, ignore everything outside that boundary, force the human to be the integrator.
The architecture rests on four pillars:
Workspaces with boundaries (satelles) — autonomous but registered in the system. Three functional subtypes: insula (communal space with multiple activities), taberna (focused workshop for one project), horreum (warehouse for accumulated reference). Each workspace orbits the person at center “the way a satellite orbits a body with mass.”
The map (census) — a unified registry that aggregates workspace contents and shows relationships. Two interfaces: human-readable and machine-readable, always in sync. The map captures gravitational force — shared context between entities produces pull proportional to relationship density.
Communications (tabellarium) — a routing layer that receives from external channels, normalizes, and routes to the right workspace. The boundary between automatic and human-reviewed routing is “not a technical setting; it is a trust decision.”
Point of view (nos) — the person at center defines the organizing principle. The system is organized from their perspective; their agents extend their perspective without replacing it. Each agent operates within a specific workspace with that workspace’s context and no more.
The watershed metaphor is central: the system is organized like a watershed (emergent, terrain-shaped), not a canal (engineered, centralized). “No central hub commands the routing” — gravity (shared context) handles flow.
The biological cell metaphor drives the fractal architecture. A workspace’s boundary is not a wall but a selective membrane — it determines what passes through, who makes decisions, and how internal organization works. The four pillars replicate at workspace level: sub-spaces within a workspace, an internal entity map, workspace-specific communication channels, and a contextualized perspective.
This fractal replication is architecturally significant: “Rather than one central registry controlling all workspace internals, each workspace maintains its own knowledge. Problems remain localized, enhancing system robustness through decentralized design.”
Each workspace is a specialized organ: a library processes published knowledge (digestive system), a collaboration manages external exchange (respiratory system), a journal integrates signals into thought (nervous system). The human is the circulatory system — “the one who carries meaning between organs that could not reach each other on their own.”
Trust at the boundary has two dimensions: explicit agreements about what each participant can do (not technical permissions but declared agreements), and which communication channels connect the workspace to outside.
The crystallization pattern is important: when an idea accumulates enough mass (shared context, concrete work, gravity), it crystallizes into its own workspace orbiting the parent space. “A new workspace at any scale follows the same pattern as every other workspace.”
The argument’s architectural climax. Without typed relationships, links are topology without semantics. The vocabulary is “not a glossary in an appendix” but “a structural layer” — every entity has a type from the vocabulary, every relationship has a named term.
Latin terms are chosen for functional precision, not aesthetics: English words carry connotations from prior tool use (“workspace” means different things in Slack, VS Code, Notion). Latin terms arrive without baggage. “When you encounter the word satelles for the first time, you have no preconceptions about what it means in Notion or Slack.”
The machine layer makes the vocabulary an ontology rather than a glossary. Terms have formal definitions (what it is, what it relates to, what it implies). The system can answer questions requiring perspective and relationship traversal: “Which of my collaborations is losing momentum, and why?” — not a search query but a question that requires understanding what things are, how they relate, and from whose perspective.
The precision-as-freedom paradox: “When the structural terms are well-defined, everything else can be loose.” The vocabulary governs architecture, not content. “It is the difference between a city’s zoning plan and the conversations people have in their houses.”
Synthesis chapter. Key architectural claims: the system grows without collapsing because the fractal pattern means every addition follows the same structure; the graph is the primary interface (not decorative visualization but actual navigation); the pattern is independent of specific tools.
Current implementation uses Obsidian for workspaces, Markdown for content, JSON-LD for machine-readable data, automation scripts, and a graph as primary navigation. Two vocabularies are published: a meta-vocabulary (schema layer) and a domain vocabulary (Uni-Versum concepts).
The vocabulary infrastructure is the most architecturally sophisticated part of the work. It implements a two-tier vocabulary system mapped to semantic web standards.
Twelve terms define the language for building vocabularies:
Classes (4): class (type of entity, maps to rdfs:Class), concept (abstract idea that is neither class nor property, maps to skos:Concept), property (relationship or attribute, maps to rdf:Property), vocabulary (named set of terms sharing a namespace, maps to skos:ConceptScheme).
Properties (8): broader (hierarchical parent, maps to skos:broader), domain (what class a property applies to, maps to rdfs:domain), range (what class a property targets, maps to rdfs:range), instance-of (the most fundamental property — declares what kind of entity a note represents, maps to rdf:type), note-type (document pattern distinct from semantic type), part-of (structural containment, maps to dcterms:isPartOf), related (symmetric non-hierarchical association, maps to skos:related), uri (actionable access point, maps to rdfs:seeAlso).
The meta-vocabulary is self-referential: class is itself a class, property is itself a class. This is standard RDFS bootstrapping.
Twenty-nine terms define the concepts of the architecture. They organize into several clusters:
| Agent Taxonomy (4 classes): agens (any agent, human or non-human), agens-humanus (human person, subclass of agens), agens-scriptum (automated script, subclass of agens), agens-scriptum-loquens (AI agent using natural language, subclass of agens-scriptum). This creates a three-level hierarchy: agens > agens-humanus | agens-scriptum > agens-scriptum-loquens. |
Workspace Taxonomy (4 classes): satelles (base workspace class), insula (communal space, subclass of satelles), taberna (focused workshop, subclass of satelles), horreum (warehouse/archive, subclass of satelles, with census as its own subclass).
System Pillars (4 classes): uni-versum (the whole personal system), nos (the human perspective center), census (unified registry, a specialized horreum), tabellarium (communications layer).
Registry Infrastructure (2 classes): tabella (individual registry card), tabula (collection of tabellae grouped by class).
Supporting Classes (3): instrumentum (tool that is not an agent), lectio (perspectival reading note), collaboratio (documented collaboration with context).
Agent-Workspace Relationships (5 properties): habitatores (which agents inhabit a workspace, domain: satelles, range: agens), visitatores (which agents visit without being residents, same domain/range), conditor (which nos founded a workspace, domain: satelles, range: nos), fidelis-est (which nos an agent operates under — loyalty/allegiance, domain: agens, range: nos), collaborat (agent-to-agent collaboration, domain: agens, range: agens).
Workspace Operations (2 properties): concordat (workspace syncs via a tool, domain: satelles, range: instrumentum), fontem (source of a lectio, domain: lectio).
Governing Concepts (3): gravitas (relationships as force — the founding metaphor, calculated from relationship density), autonomia (trust contract between human and automated agent — what can be delegated), diploma (trust credential for agents from another nos — inter-system trust).
Knowledge Unit (1): vocabulum (an entry in a vocabulary — the unit of meaning).
Several design decisions are architecturally notable:
Agent classification by interface, not capability. The distinction between agens-scriptum and agens-scriptum-loquens is whether the agent uses natural language as its primary interface. A cron job and an LLM agent are both automated, but only the LLM converses. This is a behavioral distinction, not a capability distinction.
Loyalty over ownership. The fidelis-est property (“is loyal to”) draws from Roman fides — the bond of trust between patron and those operating on their behalf. “It is not obedience; it is allegiance.” This frames agent authority as relational rather than hierarchical.
Autonomia as dynamic contract. Agent autonomy is not a binary permission but an evolving trust contract. Some tasks are fully delegated; others require human judgment at each stage. The boundary shifts as trust develops. This maps directly to the estate’s own escalation tiers.
Diploma for inter-system trust. When an agent from another nos operates in your system, a diploma formalizes what they can and cannot do. The distinction: autonomia governs intra-system human-to-agent trust; diploma governs inter-system trust. This is a federated trust model.
Lectio as perspectival reading. A lectio is not a review or summary but “the record of an encounter between a source and a specific context of work.” The reader’s perspective is constitutive — the same source produces different lectiones in different workspace contexts. This challenges the assumption that citations are objective.
Architectural coherence. The fractal pattern (boundary, registry, communications, perspective) applies at every scale and actually generates the system’s properties rather than being bolted on. The watershed metaphor is not decorative — it captures the emergent, gravity-driven organization that distinguishes this from hub-and-spoke architectures.
Vocabulary as infrastructure. The two-tier vocabulary (schema meta-layer + domain concepts) maps cleanly to established semantic web standards (SKOS, RDFS, JSON-LD) while remaining human-readable. Each term has bilingual definitions, typed relationships, and formal equivalences. This is not documentation — it is a functioning ontology.
| Agent taxonomy precision. The four-level agent hierarchy (agens > agens-humanus | agens-scriptum > agens-scriptum-loquens) and the loyalty/trust vocabulary (fidelis-est, autonomia, diploma) provide a more nuanced agent classification than most multi-agent frameworks. |
Latin as namespace isolation. Using Latin terms eliminates the connotation problem that plagues English vocabulary in technical systems. The term satelles carries exactly one meaning in this system, unlike “workspace” which carries dozens.
Implementation maturity. The work self-describes as “work in progress” with the fractal architecture “designed but only partially implemented,” trust agreements “implicit in practice, not yet formalized,” and communications routing “nascent.” The vocabulary is more complete than the implementation.
Scale untested. The gravitational model (relationship density as force) is described conceptually but not computationally. How gravitas is actually calculated, what thresholds matter, and whether the model produces useful results at scale remains unverified.
Single-person validation. The architecture is currently validated in one person’s practice. The claim that it is “replicable” — that any knowledge worker could build their own Uni-Versum — is aspirational, not demonstrated.
Vocabulary completeness. The domain vocabulary covers 29 terms for the core architecture but “not yet all the specialized areas that specific collaborations require.” The schema vocabulary has no version beyond v1.
Latin accessibility barrier. While functionally motivated, the Latin vocabulary creates a learning curve. The precision benefit is real, but users must learn 29+ Latin terms before the vocabulary is useful. The bilingual definitions (English + Spanish) mitigate this partially.
Uni-Versum represents a rare attempt to build a personal knowledge architecture from formal semantic web standards up, rather than from tool features down. Most PKM systems start with links and try to add meaning later; Uni-Versum starts with meaning (typed relationships, formal vocabulary, machine-readable ontology) and builds the interface on top.
The agent taxonomy and trust vocabulary are directly relevant to multi-agent system design. The distinction between fidelis-est (loyalty/allegiance), autonomia (delegated authority contract), and diploma (inter-system trust credential) provides vocabulary for trust relationships that most agent frameworks handle implicitly or not at all.
The work’s deepest contribution may be the precision-as-freedom principle: by defining structural terms precisely, everything else can remain unstructured. This inverts the common assumption that formal vocabularies require formal content.