Introduction: Stories We Tell About Data
Before we ever store, query, or analyze it, we tell stories about data. Not with words, necessarily, but with structures. With paths, branches, and webs. With ontologies and classification systems. With expeditions and search parties.
Data — raw, abstract, and infinitely recursive — resists intuitive grasp. Its operations are hidden, its shape formless until imposed upon. To make sense of this invisible substance, when we try to structure it, we reach instinctively for analogies. More often than not, the analogies we choose are narrative in nature: we imagine data as something we must navigate, something that branches or something interconnected. Labyrinths, trees and webs: these words are more than visual aids. They are cognitive models, story-shaped vessels that guide our understanding and behaviour.
Every user-facing interface, from a folder hierarchy to a knowledge graph, carries with it an implicit narrative logic. Even technical operations — tagging, sorting, filtering — are quietly guided by storytelling assumptions: there is a starting point, a path, a logic to follow. Sometimes, this logic echoes ancient myths of wandering through mazes; sometimes, it borrows the calm authority of Illuministic classification systems; sometimes, it mimics the erratic pulse of conversation and relation.
In this post, let’s explore how three literary and cognitive structures have come to shape our ways of visualizing and managing data, not as historical curiosities or literary tropes, but as active frameworks through which we design systems, interface with machines, and understand the abstract landscapes of information. Each carries a worldview, a promise, a politics.
- the labyrinth privileges the experience of the journey: complex, uncertain, often nonlinear;
- the tree promises hierarchy, clarity, a clean mapping of meaning;
- the network embraces multiplicity, emergence, and connection over control.
By exploring these metaphors through literature — from Borges to Powers, from Calvino to Le Guin — we’ll try to expose the narrative DNA of our digital systems, and we might find ourselves wondering not just how we organize data, but how data organizes us, what kinds of stories we allow it to tell, and which ones we unconsciously live by.
1. The Labyrinth: Obscurity and Discovery
To enter a labyrinth is to abandon certainty. There is no clear overview, no promise of return, every path might be the wrong one, and every turn might be your last. You might have been here before but there’s no way of telling, as it all looks the same. And yet our heroes go in. On top of the famous prison hosting the Minotaur, Pliny the Elder lists a number of different labyrinths, starting from the Egyptians and suggesting they had been inspirational for Daedalus to build the one in Crete. The labyrinth forges the hero with its structure of suspense, of epistemic tension. It withholds its logic, daring us to decode it. In the context of data, this metaphor proves both ancient and startlingly contemporary: much of our experience of interacting with large information systems is not linear or hierarchical, but labyrinthine and driven by intuition, misdirection, and chance.
The Infinite Folds of Borges and Danielewski’s Interface
Jorge Luis Borges stands as the canonical cartographer of the literary labyrinth, as we have seen in my piece on Digital Archives. His 1941 short story The Garden of Forking Paths posits a universe where every decision branches into alternate timelines: a narrative not of singular plot, but of multiplicity, coexisting outcomes, and endless recursion. Borges’ vision prefigures not only the multiverse and quantuum theories but the structure of hypertext, the user experience of digital archives and databases, where each query reveals not a conclusion, but further nodes, ambiguities, and forks. As you know, The Library of Babel offers an even more vertiginous vision where the challenge is not storing information but finding meaning within infinite variation.
In both cases, the user is cast as an epistemological wanderer, confronted with the ineluctability of choice on one side and an abundance that borders on absurdity on the other. Combine both: to navigate Big Data, we rely on algorithms, heuristics, and the occasional stroke of serendipity, and more often we make a choice of interpretation because you have to, even if the options are seemingly infinite.
When we talk about data, we often depict order. But before the charts, trees, and graphs, there is the experience of getting lost, of facing a structure so vast, so recursive, that it resists any single point of entry. This is where the metaphor of the labyrinth becomes most revealing: not just as an architectural curiosity, but as a condition. In the age of hypertext and databases, we still move like Theseus, thread in hand, navigating the unknown. We need tools of orientation, and survival tools to survive the flood.
That survival, however, is always provisional.
If on a Winter’s Night a Traveller, Italo Calvino’s fragmented novel, simulates the experience of trying to read a system that refuses completion. Each chapter opens a new story, only to break off, redirect, reframe. The reader becomes a seeker, assembling coherence from discontinuity. Tell me it doesn’t sound familiar. The novel mirrors how we interact with broken datasets or labyrinthine archives, making meaning in spite of interruption, not in the comfort of flow. What Calvino offers is a model of navigation, not destination, and shows us how partial access can still yield insight. Narrative is often constructed not from continuity but from collage.
Umberto Eco understood this well, of course. In Foucault’s Pendulum, he dramatizes the danger of pattern-seeking behaviour, of imposing structure on data until the structure bites back. If all you’ve read is The Name of the Rose, here’s a quick summary: a group of editors builds a fictional conspiracy theory by connecting esoteric facts and occult knowledge, only to become trapped in their own creation; what begins as a game becomes deadly serious, a warning about narrative overfitting — the tendency to extract coherence where there is none. In the context of data, this is the peril of overinterpreting correlations, of seeing meaning in coincidence out of the desperate need to find order, of mistaking algorithmic output for truth. The labyrinth, Eco suggests, is not always a place to be solved: sometimes it’s a place where our need for resolution becomes the real danger.
So, how do we avoid overfitting and still find meaning? The labyrinth metaphor provides two solutions: guidance from somebody external to the system (the Ariadne to your Theseus), and internal, spontaneous rise of statistical correlations between elements, which is what we’re trying to do today with Artificial Intelligence.
The House of Leaves by Mark Z. Danielewski turns the labyrinth into an interface for the book itself. Its typography twists, collapses, mirrors, gives you footnotes on footnotes, corridors of pages. The physical act of reading becomes spatial, almost architectural: a direct parallel to navigating nested file systems, digital archives, or sprawling UX environments. The house in the story is larger on the inside than on the outside, its layout changes, defies measurement, resists mapping. It is, in many ways, the shape of data when uncatalogued: a void that expands the more you try to contain it. Reading becomes a kind of crawling — not unlike scraping, not unlike indexing — until you let the book take its own shape. And roll with it.
In all these works, the labyrinth is not simply a trap: it’s a method of knowledge that favours intuition, experience, and uncertainty. It acknowledges that access to information is rarely linear and that sometimes discovery comes through detour. This is evident in digital design too, where serendipity is engineered into platforms, from algorithmic suggestions to associative hyperlinks. The path you take is never the only one possible. Sometimes, the insight you need is not at the end of the road but along its edge, hiding in the loops, the tangents, the recursion.
So much of our interaction with data today remains labyrinthine, not because we lack structure but because our structures no longer assume a single point of view. We may crave dashboards and diagrams, but beneath them lies a Borgesian complexity that continues to shape how we search, interpret, and trust. The data labyrinth, then, is not a failure of clarity: it is a recognition that clarity is sometimes a fiction we impose, a story we tell to make the complexity legible.
If this approach gives you the creeps, don’t you worry and bear with me. Maybe you’ll like the data tree better. Where the labyrinth confuses, the tree classifies. Where the labyrinth meanders, the tree declares order. But we will see that this metaphor, too, carries its own assumptions about growth, knowledge, and control.
2. The Tree: Structure and Control
If the labyrinth is the metaphor of mystery, the tree is the metaphor of structure and clarity. It offers reassurance: a trunk that grounds us, branches that unfold with logic, a canopy of meaning supported by roots we can trace. In the realm of data, the tree promises what the labyrinth withholds: a place for everything, and everything in its place. It is the diagram we reach for when we want to classify, control, and contain. A structure that not only grows, but grows in a knowable direction.
It is no coincidence that the language of databases and digital systems borrows heavily from arboreal imagery: file trees, decision trees, tree maps, root folders. These structures reflect a cognitive comfort with hierarchy, with the idea that meaning descends from a singular origin and radiates outward in discernible, sortable parts. Trees imply a world of vertical relationships, where data can be nested, categorized, inherited.
This desire for structure is deeply human, and perhaps nowhere more poetically explored than in Richard Powers’ The Overstory. Here, trees are not just background but protagonists: carriers of time, memory, and interconnection. Powers invites us to see trees not as passive entities in a human drama, but as narrative structures in their own right. Their slow intelligence, their branching logic, their mycorrhizal communications… all suggest an alternative form of knowledge, one rooted in deep time and distributed agency. At the same time, the novel echoes our instinct to make sense of complexity by tracing it back to roots, to see every story as part of a larger canopy.
Yet this metaphor is not without its tensions. While Powers offers a tree as something dynamic and interconnected, our use of trees in data often reflects a more static impulse. To build a taxonomy is to prune: to cut away ambiguity in favour of clarity, to define what belongs where. Ontologies, those formalized systems of categories and relationships, are tree-like in their architecture: they represent knowledge not as a tangled web, but as a diagram of “is-a” and “part-of” relationships, each node legible in its placement. Neat, isn’t it? Then why it doesn’t work? Why are we shifting away from trees and back into labyrinths more and more, these days? Is it just because we have more powerful Ariadnes, with longer threads?
The utopia of classification isn’t as neat as it seems, and yet literature might come to our aid and suggest us a solution. Ursula K. Le Guin’s Always Coming Home is structured like an anthropological archive of a future people, including stories, songs, rituals, maps, and imagined cultural fragments in a way that resists linearity and embraces layered organization, but retains a sense of rootedness: a tree not of dominance, but of growth from shared soil. The book’s very structure mimics a knowledge system shaped by human use, not abstract logic. Categories emerge not from authority but from lived context, from the rhythms of a culture that sees narrative and data as co-extensive. The result is less a top-down taxonomy and more a habitat of meaning. Which sounds better from the start.
There is something similar in the meditative writings of Annie Dillard, particularly in Pilgrim at Tinker Creek. Here, attention itself becomes a kind of branching act: a slow, recursive witnessing of nature that accrues significance through layered observation. Dillard doesn’t explain: her prose grows outward from small details, inviting the reader to see connections as something that emerges through accumulation, not categorization. It is the logic of the tree again, but one that unfolds organically, not hierarchically. A model, perhaps, for thinking about narrative-driven data design: systems that evolve in relationship to what they record, rather than impose structure from above. Taxonomies might be outdated, and we spoke about it multiple times, particularly starting off from Mario Carpo‘s considerations.
Still, the most haunting challenge to the “data tree idea” may come from Olga Tokarczuk’s Flights, a novel that fragments rather than branches. Though closer in structure to a network, Flights still orbits arboreal motifs: the body as map, the soul as traveler, the story as something that grows by layering, not sequencing. The book resists hierarchy, but it does not abandon rootedness. Instead, it offers a model of distributed order, where each part informs the whole without subordinating it. In data terms, this resembles the shift from rigid schema to schema-on-read, where structure emerges at the moment of interpretation, not before.
And yet, we continue to lean on trees, their elegance is seductive: a clean parent-child structure, a promise that meaning can be sorted, compressed, and retrieved. File hierarchies, drop-down menus, classification systems, are all echo the belief that information can be made legible through controlled growth. Trees allow us to curate complexity, to domesticate chaos.
But what is lost when we prune too much? What nuances disappear when we demand everything fit neatly within a defined branch? Trees are not wrong, but they are limiting. They reflect a worldview in which knowledge is static, curated, placed. In contrast to the labyrinth’s mystery, the tree offers mastery. It is no accident that early attempts at artificial intelligence were built on decision trees: the logic of either/or, of progress through elimination.
Still, we must ask whether the story we want to tell with our data is truly so linear, so singular. Perhaps what we need is not to discard the tree, but to let it grow wilder; to embrace branching without domination, rootedness without rigidity; to design systems that remember the difference between structure and control.
From here, we move toward a different metaphor, one that abandons singular origin and embraces multiplicity: the network. If the labyrinth is the experience of being lost, and the tree is the imposition of order, then the network is the space of relation. Not how things are arranged, but how they connect.
3. The Network: Relation and Multiplicity
Where the tree arranges and the labyrinth conceals, the network connects. It does not begin, it does not end, but it spreads, unfolds, recombines. As a mental scheme for data, the network marks a decisive shift: away from fixed hierarchies and singular truths, toward a dynamic field of relationships, constantly rewritten by the movement of the user. It is a metaphor not of place, but of possibility, an architecture in which meaning is not given, but emerges from interaction.
If the labyrinth is a structure we explore and the tree a structure we build, the network is a structure we participate in. We are not merely readers or users within a system; we are nodes in the system itself, generating meaning as we move, click, associate, remix. This idea is perhaps best captured in the radical botanical metaphor offered by Gilles Deleuze and Félix Guattari: the rhizome. Unlike the tree, which imposes vertical order, the rhizome grows laterally, unpredictably. It has no centre, no beginning, no totalizing structure. It is a model of non-hierarchical, decentralized proliferation, perfect for describing the logic of hyperlinking, relational databases, and peer-to-peer networks.
In A Thousand Plateaus, the rhizome is not simply a metaphor for how things connect, but for how meaning itself operates: contextually, associatively, without final authority. When applied to data, this vision challenges the ontological assumptions of trees and folders. It allows for multiple truths, overlapping categories, intersecting narratives, a world where classification is not a cage but a collective dance. This is the philosophy underlying the semantic web, where links do not merely point but mean: data tagged with relationships, not just attributes.
In David Mitchell’s Cloud Atlas, stories leap across centuries and voices, connected not by chronology or genealogy, but by resonance. Characters echo each other, motifs recur, the different pasts bleed into the future. In a structure that’s polyphonic and recursive, each tale is embedded in another, forming a network of influence rather than a ladder of progress. The novel’s architecture resembles a hyperlink map more than a novel in the classical sense. You don’t read Cloud Atlas to reach a conclusion; you read it to understand how each part reverberates within the whole.
This is the shift that networks make possible: from narrative as linear progression to narrative as systemic relation. Meaning becomes ambient, contingent, shaped by how we move through it. In the context of digital data, this means that truth is not always in the source, but in the linking. The power of the network lies not in any single node, but in the edges between them.
Do you want another one? In Jennifer Egan’s A Visit from the Goon Squad, this ethos is taken further. The novel unfolds in nonlinear fragments, jumping between characters, decades, and media, with one chapter taking the form of a PowerPoint presentation. Characters appear and reappear at unexpected intervals, connected by moments of intimacy, failure, and transformation. The result is not a story told, but a story constructed through traversal, a process that mirrors how users navigate data-rich environments. Not by following a map, but by creating one in the act of movement.
This fluidity is increasingly foundational to how we design data systems. In data lakes, information is stored without predefined schema, waiting for relationships to be defined by the query rather than the structure. In linked data environments, knowledge is not stored in silos but interwoven through URI-based relationships. The architecture becomes interpretive, open-ended, and shaped by context. We move from “what is this?” to “what is this connected to?”, from ontology to ontology-in-motion. Which is really, really, really cool.
Yet this proliferation of connections also raises new challenges. In networks, meaning is mutable, authority is decentralized. While this allows for pluralism and discovery, it can also produce fragmentation and overload. Just as the rhizome resists pruning, networks resist closure. We are always in the middle of things, never at the root or the crown. In such a system, the user is not a passive recipient but an active co-weaver, generating meaning through attention, relation, and movement. If the user loses attention and participation, the whole thing collapses.
This is perhaps the most radical lesson the network teaches us: that truth is not stored, but formed; that meaning is not fixed, but emergent; and everyone of us has a responsibility towards it that trascends that of the mere end-user. We do not merely access data: we compose it, through pathways that are neither identical nor repeatable. And if trees impose control, and labyrinths invite surrender, then networks offer a third possibility: co-creation. A way of reading — and living — in which knowledge grows sideways, relationally, infinitely.
From here, we turn to one final reflection: if literature provides us with mental models, how can we apply these considerations to actual data design?
4. Beyond the Metaphor: What Narrative Models Can Teach Data Design
If metaphors are how we first grasp complexity, perhaps it is time to stop treating them as mere illustrations and begin using them as tools for design. The labyrinth, the tree, the network aren’t just literary or cognitive patterns: they are functional models that can guide how we build, navigate, and trust digital systems. And in no field is this more urgent than in the increasingly layered and collaborative world of construction data management, particularly within Common Data Environments and BIM ecosystems.
So, let’s see where we stand.
The default structure of most technological solutions for document and data management within a Common Data Environment remains arboreal. Projects are broken down into folders, categories, subcategories, reflecting not just a taxonomic mindset, but a regulatory logic. ISO 19650 workflows echo this order: everything in its place, versioned, sequenced, named according to rules. The tree prevails because it offers control, traceability, and hierarchy, all reassuring qualities in a field where liability, compliance, and accountability are non-negotiable.
But the question arises: what happens when this tree becomes too rigid? When the structure no longer reflects the messiness of collaboration, the plurality of inputs, or the lifecycle of evolving models and knowledge? In these moments, alternative narrative metaphors — the labyrinth and the network — offer more than literary flair. They offer design principles.
A labyrinthine approach to data interaction — as we have seen a couple of months ago — foregrounds the user’s experience of discovery. It accepts that a designer, coordinator, or contractor entering a document management system does not always know what they’re looking for, or even the vocabulary to describe it. This is especially true in federated models, where naming conventions aren’t always transparent, and the logic of one discipline may be opaque to another. Here, interface design could learn from Borges and Calvino: structure the CDE to allow serendipity, encourage exploratory navigation, support partial visibility and recursive returns. Faceted search, semantic tagging, and cross-referenced metadata can transform a rigid repository into a narrative engine, where data tells its own story depending on how it’s approached. Some vendors are already shifting towards this logic: usBIM from ACCA comes to mind, and Datagrids’ effort to inject an LLM into Autodesk Construction Cloud.
Meanwhile, the network model offers perhaps the most radical — and needed — shift. If trees are about control and labyrinths about experience, networks are about relation. Imagine a CDE technological solution that thinks more like a graph than a folder: where models, documents, and stakeholders are interlinked through contextual metadata, where relationships between files are as important as the files themselves.
Think of a data environment that knows: “this model update affects that clash report, which is linked to that issue, which is tracked by that team.”
This is not speculative: it’s the logic behind linked data, IFC-based interoperability, and emerging graph-based BIM approaches. But it needs a narrative sensibility to make it humane.
Just as in literature, structure affects legibility. A tree flattens nuance; a network reveals it. A labyrinth demands attention; a network rewards association. For designers of digital workflows, these metaphors should not be siloed but interwoven. Different users, at different project stages, require different ways of knowing: the auditor needs the tree, the architect may prefer the network, the student might benefit from the labyrinth.
This plurality can also inform AI-generated storytelling in construction. Whether drafting scope notes, generating descriptions of issue histories, or summarizing model changes, AI systems trained on project data will inherit our narrative logic. If we structure our environments only as trees, we teach machines to write in absolutes. If we allow networks, they can write in relational nuance. If we simulate labyrinths, they may even capture the ambivalence and complexity that defines real-world design decisions.
Ultimately, these narrative forms also shape trust.
A tree says: “this is the truth, in its place.” A network says: “these are the connections — follow them.” A labyrinth says: “explore — but beware.”
The metaphor we adopt affects how users perceive validity, how they negotiate access, and how they construct understanding across disciplines.
In our construction projects, where data must move across people, time zones, software, and intentions, it is no longer enough to ask whether our systems are compliant or efficient. We must also ask: are they legible? Are they navigable? Are they telling the right stories to the right people? To answer these questions, we must think as readers and authors alike. We must recognize that every data model is a narrative, and that the metaphors we choose will shape not only our technologies, but the futures we build with them.
Conclusion: The Shape of Knowing
Let’s accept that our interaction with data doesn’t merely structure it but creates a story. Before the first column in a spreadsheet, before the first node in a graph, we reach for metaphors to make the abstract tangible, and that’s when we imagine it as a labyrinth, a tree, a network. Each metaphor becomes a shape for knowledge, an interface not only for information but for meaning. And once chosen, these shapes begin to shape us in return.
Throughout this reflection, we’ve seen how these metaphors operate across disciplines and scales, from federated models to the semantic web, but what emerges is not simply a taxonomy of literary structures; it is a deeper recognition that the metaphors we choose are never neutral.
The labyrinth carries the romance of discovery, but also the anxiety of uncertainty. It values experience but resists efficiency. It is poetic, recursive, disorienting, and often truer to the lived complexity of knowledge work than the sanitised structures we impose.
The tree offers order and authority, but its elegance comes at the cost of exclusion. It renders knowledge legible through hierarchy, but risks cutting off what cannot be neatly categorised. It reflects a desire for control, a confidence in roots and branches: sometimes helpful, sometimes oppressive.
The network celebrates emergence, multiplicity, and lateral connection. It mirrors the real fluidity of contemporary data environments, but it also disperses responsibility. In the network, there is no center, which means there is often no clear ground to stand on. It invites co-authorship, but it can also overwhelm.
These metaphors do not simply describe our systems; they express our attitudes toward knowledge itself. They encode our biases, our fears, our aspirations; they reveal how we think we ought to relate to information, whether we want to map it, tame it, wander through it, or become part of it. And in doing so, they shape how we design, how we navigate, and ultimately how we decide.
As professionals working with data in the built environment — as designers, modelers, coordinators, clients — we are not exempt from this narrative impulse. On the contrary, we are its authors. Every Common Data Environment, every folder structure, every naming convention is a story about what matters and how it should be found. Every model element carries not just coordinates and parameters, but a cultural decision about legibility, relevance, trust.
To rethink how we design with data, we must first rethink the metaphors we design by. So let us begin again — not with a blank screen, but with a question: what kind of story do we want our systems to tell?
Do we want data to be a forest of branching truths? A tangle of lived paths? A map of shimmering links? There is no single answer. There never was. But in choosing, consciously, how we structure information, we shape the spaces we live and build in… and the futures we make possible.
No Comments